@jscad/modeling 2.9.6 → 2.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.6",
+  "version": "2.11.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "9768af96e5da00cd113c00ddeb0f6046707819b1"
+  "gitHead": "5899622c5ffc640001da7261d7c06a1223064ccc"
 }

package/src/geometries/path2/appendArc.js

@@ -1,3 +1,4 @@
+const { TAU } = require('../../maths/constants')
 const vec2 = require('../../maths/vec2')
 
 const fromPoints = require('./fromPoints')
@@ -12,7 +13,7 @@ const toPoints = require('./toPoints')
  * @param {vec2} [options.radius=[0,0]] - radius of arc (X and Y)
  * @param {Number} [options.xaxisrotation=0] - rotation (RADIANS) of the X axis of the arc with respect to the X axis of the coordinate system
  * @param {Boolean} [options.clockwise=false] - draw an arc clockwise with respect to the center point
- * @param {Boolean} [options.large=false] - draw an arc longer than PI radians
+ * @param {Boolean} [options.large=false] - draw an arc longer than TAU / 2 radians
  * @param {Number} [options.segments=16] - number of segments per full rotation
  * @param {path2} geometry - the path of which to append the arc
  * @returns {path2} a new path with the appended points
@@ -111,15 +112,15 @@ const appendArc = (options, geometry) => {
     const theta1 = vec2.angleRadians(vector1)
     const theta2 = vec2.angleRadians(vector2)
     let deltatheta = theta2 - theta1
-    deltatheta = deltatheta % (2 * Math.PI)
+    deltatheta = deltatheta % TAU
     if ((!sweepFlag) && (deltatheta > 0)) {
-      deltatheta -= 2 * Math.PI
+      deltatheta -= TAU
     } else if ((sweepFlag) && (deltatheta < 0)) {
-      deltatheta += 2 * Math.PI
+      deltatheta += TAU
     }
 
     // Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse
-    let numsteps = Math.ceil(Math.abs(deltatheta) / (2 * Math.PI) * segments) + 1
+    let numsteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
     if (numsteps < 1) numsteps = 1
     for (let step = 1; step < numsteps; step++) {
       const theta = theta1 + step / numsteps * deltatheta

package/src/geometries/path2/appendArc.test.js

@@ -1,5 +1,7 @@
 const test = require('ava')
 
+const { TAU } = require('../../maths/constants')
+
 const { appendArc, fromPoints, toPoints } = require('./index')
 
 const { comparePoints } = require('../../../test/helpers/')
@@ -48,7 +50,7 @@ test('appendArc: appending to a path produces a new path', (t) => {
   t.is(pts.length, 16)
 
   // test xaxisrotation
-  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisrotation: Math.PI / 2 }, p2)
+  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisrotation: TAU / 4 }, p2)
   pts = toPoints(obs)
   exp = [
     [27, -22],

package/src/geometries/path2/appendBezier.js

@@ -1,3 +1,4 @@
+const { TAU } = require('../../maths/constants')
 const vec2 = require('../../maths/vec2')
 const vec3 = require('../../maths/vec2')
 
@@ -117,7 +118,7 @@ const appendBezier = (options, geometry) => {
 
   // subdivide each segment until the angle at each vertex becomes small enough:
   let subdivideBase = 1
-  const maxangle = Math.PI * 2 / segments
+  const maxangle = TAU / segments
   const maxsinangle = Math.sin(maxangle)
   while (subdivideBase < newpoints.length - 1) {
     const dir1 = vec2.subtract(v0, newpoints[subdivideBase], newpoints[subdivideBase - 1])

package/src/geometries/path2/transform.js

@@ -10,7 +10,7 @@ const mat4 = require('../../maths/mat4')
  * @alias module:modeling/geometries/path2.transform
  *
  * @example
- * let newpath = transform(fromZRotation(Math.PI / 4), path)
+ * let newpath = transform(fromZRotation(TAU / 8), path)
  */
 const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)

package/src/index.d.ts

@@ -11,6 +11,7 @@ export * as booleans from './operations/booleans'
 export * as expansions from './operations/expansions'
 export * as extrusions from './operations/extrusions'
 export * as hulls from './operations/hulls'
+export * as modifiers from './operations/modifiers'
 export * as transforms from './operations/transforms'
 
 export as namespace modeling

package/src/maths/constants.js

@@ -24,8 +24,18 @@ const NEPS = 1e-13
 // for comparing coplanar polygons, as provided by the sphere primitive at high
 // segmentation. NEPS is for 64 bit Number values.
 
+/**
+ * The TAU property represents the ratio of the circumference of a circle to its radius.
+ * Approximately 6.28318530717958647692
+ * @default
+ * @example
+ * const { TAU } = require('@jscad/modeling').maths.constants
+ */
+const TAU = Math.PI * 2
+
 module.exports = {
   EPS,
   NEPS,
+  TAU,
   spatialResolution
 }

package/src/maths/mat4/fromRotation.js

@@ -17,7 +17,7 @@ const identity = require('./identity')
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromRotation
  * @example
- * let matrix = fromRotation(create(), Math.PI / 2, [0, 0, 3])
+ * let matrix = fromRotation(create(), TAU / 4, [0, 0, 3])
  */
 const fromRotation = (out, rad, axis) => {
   let [x, y, z] = axis

package/src/maths/mat4/fromTaitBryanRotation.js

@@ -13,7 +13,7 @@ const { sin, cos } = require('../utils/trigonometry')
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromTaitBryanRotation
  * @example
- * let matrix = fromTaitBryanRotation(create(), Math.PI / 2, 0, Math.PI)
+ * let matrix = fromTaitBryanRotation(create(), TAU / 4, 0, TAU / 2)
  */
 const fromTaitBryanRotation = (out, yaw, pitch, roll) => {
   // precompute sines and cosines of Euler angles

package/src/maths/mat4/fromXRotation.js

@@ -12,7 +12,7 @@ const { sin, cos } = require('../utils/trigonometry')
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromXRotation
  * @example
- * let matrix = fromXRotation(create(), Math.PI / 2)
+ * let matrix = fromXRotation(create(), TAU / 4)
  */
 const fromXRotation = (out, radians) => {
   const s = sin(radians)

package/src/maths/mat4/fromYRotation.js

@@ -12,7 +12,7 @@ const { sin, cos } = require('../utils/trigonometry')
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromYRotation
  * @example
- * let matrix = fromYRotation(create(), Math.PI / 2)
+ * let matrix = fromYRotation(create(), TAU / 4)
  */
 const fromYRotation = (out, radians) => {
   const s = sin(radians)

package/src/maths/mat4/fromZRotation.js

@@ -12,7 +12,7 @@ const { sin, cos } = require('../utils/trigonometry')
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromZRotation
  * @example
- * let matrix = fromZRotation(create(), Math.PI / 2)
+ * let matrix = fromZRotation(create(), TAU / 4)
  */
 const fromZRotation = (out, radians) => {
   const s = sin(radians)

package/src/maths/mat4/invert.test.js

@@ -1,8 +1,11 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+const vec3 = require('../vec3/index')
+
 const { create, invert, fromTranslation, fromXRotation } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
-const vec3 = require('../vec3/index')
 
 test('mat4: invert() translate ', (t) => {
   const matrix = fromTranslation(create(), [10, 10, 0])
@@ -17,7 +20,7 @@ test('mat4: invert() translate ', (t) => {
 })
 
 test('mat4: invert() rotate ', (t) => {
-  const matrix = fromXRotation(create(), Math.PI / 2)
+  const matrix = fromXRotation(create(), TAU / 4)
   const matrixInv = invert(create(), matrix)
 
   const vec1 = [10, 10, 10]

package/src/maths/mat4/isOnlyTransformScale.js

@@ -1,7 +1,7 @@
 
 /**
  * Determine whether the given matrix is only translate and/or scale.
- * This code returns true for PI rotation as it can be interpreted as scale.
+ * This code returns true for TAU / 2 rotation as it can be interpreted as scale.
  *
  * @param {mat4} matrix - the matrix
  * @returns {Boolean} true if matrix is for translate and/or scale

package/src/maths/mat4/isOnlyTransformScale.test.js

@@ -1,9 +1,11 @@
 const test = require('ava')
 
+const { TAU } = require('../constants')
+
 const { isOnlyTransformScale, create, fromTranslation, fromTaitBryanRotation, fromScaling, invert, multiply } = require('./index')
 
 test('mat4: isOnlyTransformScale() should return true for right angles', (t) => {
-  let someRotation = fromTaitBryanRotation(create(), Math.PI, 0, 0)
+  let someRotation = fromTaitBryanRotation(create(), TAU / 2, 0, 0)
   t.true(isOnlyTransformScale(someRotation))
   t.true(isOnlyTransformScale(invert(create(), someRotation)))
 

package/src/maths/rotation.test.js

@@ -2,15 +2,18 @@ const test = require('ava')
 
 const { compareVectors } = require('../../test/helpers/index')
 
-const { mat4, vec2, vec3 } = require('./index')
+const { constants, mat4, vec2, vec3 } = require('./index')
 
 // ALL POSITIVE ROTATIONS ARE CLOCKWISE
 // see https://webglfundamentals.org/webgl/lessons/webgl-3d-orthographic.html
 // IN A LEFT-HANDED COORDINATE SYSTEM
 
+// JSCAD IS RIGHT-HANDED COORDINATE SYSTEM
+// WHERE POSITIVE ROTATIONS ARE COUNTER-CLOCKWISE
+
 // identity matrices for comparisons
 
-const rad90 = Math.PI / 2
+const rad90 = constants.TAU / 4
 
 // +90 degree rotation about X
 const cwX90Matrix = [

package/src/maths/utils/trigonometry.js

@@ -6,28 +6,28 @@ const { NEPS } = require('../constants')
 const rezero = (n) => Math.abs(n) < NEPS ? 0 : n
 
 /**
- * Return Math.sin but accurate for 90 degree rotations.
+ * Return Math.sin but accurate for TAU / 4 rotations.
  * Fixes rounding errors when sin should be 0.
  *
  * @param {Number} radians - angle in radians
  * @returns {Number} sine of the given angle
  * @alias module:modeling/utils.sin
  * @example
- * sin(Math.PI) == 0
- * sin(2 * Math.PI) == 0
+ * sin(TAU / 2) == 0
+ * sin(TAU) == 0
  */
 const sin = (radians) => rezero(Math.sin(radians))
 
 /**
- * Return Math.cos but accurate for 90 degree rotations.
+ * Return Math.cos but accurate for TAU / 4 rotations.
  * Fixes rounding errors when cos should be 0.
  *
  * @param {Number} radians - angle in radians
  * @returns {Number} cosine of the given angle
  * @alias module:modeling/utils.cos
  * @example
- * cos(0.5 * Math.PI) == 0
- * cos(1.5 * Math.PI) == 0
+ * cos(TAU * 0.25) == 0
+ * cos(TAU * 0.75) == 0
  */
 const cos = (radians) => rezero(Math.cos(radians))
 

package/src/maths/utils/trigonometry.test.js

@@ -1,14 +1,16 @@
 const test = require('ava')
 
+const { TAU } = require('../constants')
+
 const { cos, sin } = require('./trigonometry')
 
 test('utils: sin() should return rounded values', (t) => {
   t.is(sin(0), 0)
   t.is(sin(9), Math.sin(9))
-  t.is(sin(0.5 * Math.PI), 1)
-  t.is(sin(1.0 * Math.PI), 0)
-  t.is(sin(1.5 * Math.PI), -1)
-  t.is(sin(2.0 * Math.PI), 0)
+  t.is(sin(0.25 * TAU), 1)
+  t.is(sin(0.5 * TAU), 0)
+  t.is(sin(0.75 * TAU), -1)
+  t.is(sin(TAU), 0)
   t.is(sin(NaN), NaN)
   t.is(sin(Infinity), NaN)
 })
@@ -16,10 +18,10 @@ test('utils: sin() should return rounded values', (t) => {
 test('utils: cos() should return rounded values', (t) => {
   t.is(cos(0), 1)
   t.is(cos(9), Math.cos(9))
-  t.is(cos(0.5 * Math.PI), 0)
-  t.is(cos(1.0 * Math.PI), -1)
-  t.is(cos(1.5 * Math.PI), 0)
-  t.is(cos(2.0 * Math.PI), 1)
+  t.is(cos(0.25 * TAU), 0)
+  t.is(cos(0.5 * TAU), -1)
+  t.is(cos(0.75 * TAU), 0)
+  t.is(cos(TAU), 1)
   t.is(cos(NaN), NaN)
   t.is(cos(Infinity), NaN)
 })

package/src/maths/vec2/fromAngleDegrees.js

@@ -8,6 +8,6 @@ const fromAngleRadians = require('./fromAngleRadians')
  * @returns {vec2} out
  * @alias module:modeling/maths/vec2.fromAngleDegrees
  */
-const fromAngleDegrees = (out, degrees) => fromAngleRadians(out, Math.PI * degrees / 180)
+const fromAngleDegrees = (out, degrees) => fromAngleRadians(out, degrees * 0.017453292519943295)
 
 module.exports = fromAngleDegrees

package/src/maths/vec2/fromAngleRadians.test.js

@@ -1,4 +1,7 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { fromAngleRadians, create } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
@@ -7,6 +10,6 @@ test('vec2: fromAngleRadians() should return a new vec2 with correct values', (t
   const obs1 = fromAngleRadians(create(), 0)
   t.true(compareVectors(obs1, [1.0, 0.0]))
 
-  const obs2 = fromAngleRadians(obs1, Math.PI)
+  const obs2 = fromAngleRadians(obs1, TAU / 2)
   t.true(compareVectors(obs2, [-1, 1.2246468525851679e-16]))
 })

package/src/maths/vec2/normal.js

@@ -1,3 +1,5 @@
+const { TAU } = require('../constants')
+
 const create = require('./create')
 const rotate = require('./rotate')
 
@@ -10,6 +12,6 @@ const rotate = require('./rotate')
  * @returns {vec2} out
  * @alias module:modeling/maths/vec2.normal
  */
-const normal = (out, vector) => rotate(out, vector, create(), (Math.PI / 2))
+const normal = (out, vector) => rotate(out, vector, create(), (TAU / 4))
 
 module.exports = normal

package/src/maths/vec2/rotate.test.js

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotate, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec2: rotate() called with three parameters should update a vec2 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0)
   const ret1 = rotate(obs1, [0, 0], [0, 0], 0)

package/src/maths/vec3/rotateX.test.js

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotateX, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec3: rotateX() called with four parameters should update a vec3 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0, 0)
   const ret1 = rotateX(obs1, [0, 0, 0], [0, 0, 0], 0)

package/src/maths/vec3/rotateY.test.js

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotateY, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec3: rotateY() called with three parameters should update a vec3 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0, 0)
   const ret1 = rotateY(obs1, [0, 0, 0], [0, 0, 0], 0)

package/src/maths/vec3/rotateZ.test.js

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotateZ, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec3: rotateZ() called with four parameters should update a vec3 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0, 0)
   const ret1 = rotateZ(obs1, [0, 0, 0], [0, 0, 0], 0)

package/src/measurements/index.d.ts

@@ -4,6 +4,10 @@ export { default as measureAggregateEpsilon } from './measureAggregateEpsilon'
 export { default as measureAggregateVolume } from './measureAggregateVolume'
 export { default as measureArea } from './measureArea'
 export { default as measureBoundingBox } from './measureBoundingBox'
+export { default as measureBoundingSphere } from './measureBoundingSphere'
+export { default as measureCenter } from './measureCenter'
+export { default as measureCenterOfMass } from './measureCenterOfMass'
+export { default as measureDimensions } from './measureDimensions'
 export { default as measureEpsilon } from './measureEpsilon'
 export { default as measureVolume } from './measureVolume'
 

package/src/measurements/measureBoundingSphere.d.ts

@@ -0,0 +1,9 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+type Centroid = [number, number, number]
+
+export default measureBoundingSphere
+
+declare function measureBoundingSphere(geometry: Geometry): [Centroid, number]
+declare function measureBoundingSphere(...geometries: RecursiveArray<Geometry>): [Centroid, number][]

package/src/measurements/measureCenter.d.ts

@@ -0,0 +1,7 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+export default measureCenter
+
+declare function measureCenter(geometry: Geometry): [number, number, number]
+declare function measureCenter(...geometries: RecursiveArray<Geometry>): [number, number, number][]

package/src/measurements/measureCenterOfMass.d.ts

@@ -0,0 +1,7 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+export default measureCenterOfMass
+
+declare function measureCenterOfMass(geometry: Geometry): [number, number, number]
+declare function measureCenterOfMass(...geometries: RecursiveArray<Geometry>): [number, number, number][]

package/src/measurements/measureDimensions.d.ts

@@ -0,0 +1,7 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+export default measureDimensions
+
+declare function measureDimensions(geometry: Geometry): [number, number, number]
+declare function measureDimensions(...geometries: RecursiveArray<Geometry>): [number, number, number][]

package/src/operations/expansions/expand.test.js

@@ -1,9 +1,11 @@
 const test = require('ava')
 
 const { comparePoints, nearlyEqual } = require('../../../test/helpers')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 const measureBoundingBox = require('../../measurements/measureBoundingBox')
 const area = require('../../maths/utils/area')
+const { TAU } = require('../../maths/constants')
 const sphere = require('../../primitives/sphere')
 
 const { expand } = require('./index')
@@ -51,7 +53,7 @@ test('expand: round-expanding a bent line produces expected geometry', (t) => {
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
   t.notThrows(() => geom2.validate(expandedPathGeom2))
-  const expectedArea = 56 + 2 * Math.PI * delta * 1.25 // shape will have 1 and 1/4 circles
+  const expectedArea = 56 + TAU  * delta * 1.25 // shape will have 1 and 1/4 circles
   nearlyEqual(t, area(expandedPoints), expectedArea, 0.01, 'Measured area should be pretty close')
   const boundingBox = measureBoundingBox(expandedPathGeom2)
   t.true(comparePoints(boundingBox, [[-7, -2, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))

package/src/operations/expansions/expandShell.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../../maths/constants')
+const { EPS, TAU } = require('../../maths/constants')
 
 const mat4 = require('../../maths/mat4')
 const vec3 = require('../../maths/vec3')
@@ -120,7 +120,7 @@ const expandShell = (options, geometry) => {
 
     // first of all equally spaced around the cylinder:
     for (let i = 0; i < segments; i++) {
-      addUniqueAngle(angles, (i * Math.PI * 2 / segments))
+      addUniqueAngle(angles, (i * TAU / segments))
     }
 
     // and also at every normal of all touching planes:
@@ -130,10 +130,10 @@ const expandShell = (options, geometry) => {
       const co = vec3.dot(xbase, planenormal)
       let angle = Math.atan2(si, co)
 
-      if (angle < 0) angle += Math.PI * 2
+      if (angle < 0) angle += TAU
       addUniqueAngle(angles, angle)
       angle = Math.atan2(-si, -co)
-      if (angle < 0) angle += Math.PI * 2
+      if (angle < 0) angle += TAU
       addUniqueAngle(angles, angle)
     }
 

package/src/operations/expansions/offsetFromPoints.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../../maths/constants')
+const { EPS, TAU } = require('../../maths/constants')
 
 const intersect = require('../../maths/utils/intersect')
 const line2 = require('../../maths/line2')
@@ -139,7 +139,7 @@ const offsetFromPoints = (options, points) => {
 
       if (rotation !== 0.0) {
         // generate the segments
-        cornersegments = Math.floor(segments * (Math.abs(rotation) / (2 * Math.PI)))
+        cornersegments = Math.floor(segments * (Math.abs(rotation) / TAU))
         const step = rotation / cornersegments
         const start = vec2.angle(vec2.subtract(v0, corner.s0[1], corner.c))
         const cornerpoints = []

package/src/operations/extrusions/extrudeFromSlices.test.js

@@ -2,6 +2,7 @@ const test = require('ava')
 
 const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
 
+const { TAU } = require('../../maths/constants')
 const mat4 = require('../../maths/mat4')
 
 const { geom2, geom3, poly3 } = require('../../geometries')
@@ -56,10 +57,10 @@ test('extrudeFromSlices (torus)', (t) => {
   hex = poly3.transform(mat4.fromTranslation(mat4.create(), [0, 20, 0]), hex)
   hex = slice.fromPoints(poly3.toPoints(hex))
 
-  const angle = Math.PI / 4
+  const angle = TAU / 8
   const geometry3 = extrudeFromSlices(
     {
-      numberOfSlices: Math.PI * 2 / angle,
+      numberOfSlices: TAU / angle,
       capStart: false,
       capEnd: false,
       close: true,

package/src/operations/extrusions/extrudeHelical.d.ts

@@ -0,0 +1,14 @@
+import { Geom2, Geom3 } from '../../geometries/types'
+
+export default extrudeHelical
+
+export interface ExtrudeHelicalOptions {
+  angle?: number
+  startAngle?: number
+  pitch?: number
+  height?: number
+  endOffset?: number
+  segmentsPerRotation?: number
+}
+
+declare function extrudeHelical(options: ExtrudeHelicalOptions, geometry: Geom2): Geom3