@jscad/modeling 3.0.4-alpha.0 → 3.0.6-alpha.0

package/src/operations/transforms/translate.js

@@ -3,6 +3,8 @@ import * as mat4 from '../../maths/mat4/index.js'
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Translate the given objects using the given options.
@@ -18,15 +20,21 @@ export const translate = (offset, ...objects) => {
   if (!Array.isArray(offset)) throw new Error('offset must be an array')
 
   // adjust the offset if necessary
-  offset = offset.slice() // don't modify the original
-  while (offset.length < 3) offset.push(0)
+  if (offset.length < 3) {
+    offset = offset.slice() // don't modify the original
+    while (offset.length < 3) {
+      offset.push(0)
+    }
+  }
 
   const matrix = mat4.fromTranslation(mat4.create(), offset)
 
   const results = objects.map((object) => {
-    if (path2.isA(object)) return path2.transform(matrix, object)
-    if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return translate(offset, ...object)
     return object

package/src/primitives/arc.js

@@ -8,6 +8,7 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an arc in two dimensional space where all points are at the same distance from the center.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of arc
  * @param {number} [options.radius=1] - radius of arc
@@ -17,19 +18,19 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
  * @param {boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
  * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.arc
+ *
  * @example
  * let myshape = arc({ center: [-1, -1], radius: 2, endAngle: (TAU / 4)})
  */
-export const arc = (options) => {
-  const defaults = {
-    center: [0, 0],
-    radius: 1,
-    startAngle: 0,
-    endAngle: TAU,
-    makeTangent: false,
-    segments: 32
-  }
-  let { center, radius, startAngle, endAngle, makeTangent, segments } = Object.assign({}, defaults, options)
+export const arc = (options = {}) => {
+  let {
+    center = [0, 0],
+    radius = 1,
+    startAngle = 0,
+    endAngle = TAU,
+    makeTangent = false,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
@@ -50,14 +51,13 @@ export const arc = (options) => {
 
   const minAngle = Math.acos(((radius * radius) + (radius * radius) - (EPS * EPS)) / (2 * radius * radius))
 
-  const centerV = vec2.clone(center)
   let point
   const pointArray = []
   if (rotation < minAngle) {
     // there is no rotation, just a single point
     point = vec2.fromAngleRadians(vec2.create(), startAngle)
     vec2.scale(point, point, radius)
-    vec2.add(point, point, centerV)
+    vec2.add(point, point, center)
     pointArray.push(point)
   } else {
     const numSteps = Math.floor(segments * (Math.abs(rotation) / TAU))
@@ -76,9 +76,9 @@ export const arc = (options) => {
       const angle = startAngle + (step * (rotation / numSteps))
       point = vec2.fromAngleRadians(vec2.create(), angle)
       vec2.scale(point, point, radius)
-      vec2.add(point, point, centerV)
+      vec2.add(point, point, center)
       pointArray.push(point)
     }
   }
-  return path2.fromPoints({ closed: false }, pointArray)
+  return path2.fromPoints({}, pointArray)
 }

package/src/primitives/circle.js

@@ -6,6 +6,7 @@ import { isGTE } from './commonChecks.js'
 
 /**
  * Construct a circle in two dimensional space where all points are at the same distance from the center.
+ *
  * @see [ellipse]{@link module:modeling/primitives.ellipse} for more options
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of circle
@@ -15,18 +16,18 @@ import { isGTE } from './commonChecks.js'
  * @param {number} [options.segments=32] - number of segments to create per full rotation
  * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.circle
+ *
  * @example
  * let myshape = circle({radius: 10})
  */
-export const circle = (options) => {
-  const defaults = {
-    center: [0, 0],
-    radius: 1,
-    startAngle: 0,
-    endAngle: TAU,
-    segments: 32
-  }
-  let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
+export const circle = (options = {}) => {
+  let {
+    center = [0, 0],
+    radius = 1,
+    startAngle = 0,
+    endAngle = TAU,
+    segments = 32
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 

package/src/primitives/cube.js

@@ -12,12 +12,11 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = cube({size: 10})
  */
-export const cube = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    size: 2
-  }
-  let { center, size } = Object.assign({}, defaults, options)
+export const cube = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    size = 2
+  } = options
 
   if (!isGTE(size, 0)) throw new Error('size must be positive')
 

package/src/primitives/cuboid.js

@@ -5,6 +5,7 @@ import { isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned solid cuboid in three dimensional space.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cuboid
  * @param {Array} [options.size=[2,2,2]] - dimensions of cuboid; width, depth, height
@@ -14,12 +15,11 @@ import { isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = cuboid({size: [5, 10, 5]})
  */
-export const cuboid = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    size: [2, 2, 2]
-  }
-  const { center, size } = Object.assign({}, defaults, options)
+export const cuboid = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    size = [2, 2, 2]
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of width, depth and height values')

package/src/primitives/cylinder.js

@@ -4,6 +4,7 @@ import * as geom3 from '../geometries/geom3/index.js'
 
 /**
  * Construct a Z axis-aligned cylinder in three dimensional space.
+ *
  * @see [cylinderElliptic]{@link module:modeling/primitives.cylinderElliptic} for more options
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
@@ -16,14 +17,13 @@ import * as geom3 from '../geometries/geom3/index.js'
  * @example
  * let myshape = cylinder({height: 2, radius: 10})
  */
-export const cylinder = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    height: 2,
-    radius: 1,
-    segments: 32
-  }
-  const { center, height, radius, segments } = Object.assign({}, defaults, options)
+export const cylinder = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    height = 2,
+    radius = 1,
+    segments = 32
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 

package/src/primitives/cylinderElliptic.js

@@ -11,6 +11,7 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct a Z axis-aligned elliptic cylinder in three dimensional space.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
  * @param {number} [options.height=2] - height of cylinder
@@ -25,17 +26,16 @@ import { isGT, isGTE, isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = cylinderElliptic({height: 2, startRadius: [10,5], endRadius: [8,3]})
  */
-export const cylinderElliptic = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    height: 2,
-    startRadius: [1, 1],
-    startAngle: 0,
-    endRadius: [1, 1],
-    endAngle: TAU,
-    segments: 32
-  }
-  let { center, height, startRadius, startAngle, endRadius, endAngle, segments } = Object.assign({}, defaults, options)
+export const cylinderElliptic = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    height = 2,
+    startRadius = [1, 1],
+    startAngle = 0,
+    endRadius = [1, 1],
+    endAngle = TAU,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isGT(height, 0)) throw new Error('height must be greater then zero')

package/src/primitives/ellipse.js

@@ -10,6 +10,7 @@ import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipse in two dimensional space.
+ *
  * @see https://en.wikipedia.org/wiki/Ellipse
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of ellipse
@@ -19,18 +20,18 @@ import { isGTE, isNumberArray } from './commonChecks.js'
  * @param {number} [options.segments=32] - number of segments to create per full rotation
  * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.ellipse
+ *
  * @example
  * let myshape = ellipse({radius: [5,10]})
  */
-export const ellipse = (options) => {
-  const defaults = {
-    center: [0, 0],
-    radius: [1, 1],
-    startAngle: 0,
-    endAngle: TAU,
-    segments: 32
-  }
-  let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
+export const ellipse = (options = {}) => {
+  let {
+    center = [0, 0],
+    radius = [1, 1],
+    startAngle = 0,
+    endAngle = TAU,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(radius, 2)) throw new Error('radius must be an array of X and Y values')
@@ -60,7 +61,6 @@ export const ellipse = (options) => {
 
   segments = Math.floor(segments * (rotation / TAU))
 
-  const centerV = vec2.clone(center)
   const step = rotation / segments // radians per segment
 
   const points = []
@@ -68,9 +68,9 @@ export const ellipse = (options) => {
   for (let i = 0; i < segments; i++) {
     const angle = (step * i) + startAngle
     const point = vec2.fromValues(radius[0] * cos(angle), radius[1] * sin(angle))
-    vec2.add(point, centerV, point)
+    vec2.add(point, center, point)
     points.push(point)
   }
-  if (rotation < TAU) points.push(centerV)
+  if (rotation < TAU) points.push(vec2.clone(center)) // close with a new point
   return geom2.create([points])
 }

package/src/primitives/ellipsoid.js

@@ -9,6 +9,7 @@ import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipsoid in three dimensional space.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of ellipsoid
  * @param {Array} [options.radius=[1,1,1]] - radius of ellipsoid, along X, Y and Z
@@ -20,14 +21,13 @@ import { isGTE, isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = ellipsoid({radius: [5, 10, 20]})
 */
-export const ellipsoid = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    radius: [1, 1, 1],
-    segments: 32,
-    axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
-  }
-  const { center, radius, segments, axes } = Object.assign({}, defaults, options)
+export const ellipsoid = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    radius = [1, 1, 1],
+    segments = 32,
+    axes = [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(radius, 3)) throw new Error('radius must be an array of X, Y and Z values')

package/src/primitives/geodesicSphere.js

@@ -8,6 +8,7 @@ import { isGTE } from './commonChecks.js'
 
 /**
  * Construct a geodesic sphere based on icosahedron symmetry.
+ *
  * @param {object} [options] - options for construction
  * @param {number} [options.radius=1] - target radius of sphere
  * @param {number} [options.frequency=6] - subdivision frequency per face, multiples of 6
@@ -17,12 +18,11 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = geodesicSphere({radius: 15, frequency: 18})
  */
-export const geodesicSphere = (options) => {
-  const defaults = {
-    radius: 1,
-    frequency: 6
-  }
-  let { radius, frequency } = Object.assign({}, defaults, options)
+export const geodesicSphere = (options = {}) => {
+  let {
+    radius = 1,
+    frequency = 6
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(frequency, 6)) throw new Error('frequency must be six or more')

package/src/primitives/line.js

@@ -2,7 +2,9 @@ import * as path2 from '../geometries/path2/index.js'
 
 /**
  * Construct a new line in two dimensional space from the given points.
+ *
  * The points must be provided as an array, where each element is a 2D point.
+ *
  * @param {Array} points - array of points from which to create the path
  * @returns {Path2} new 2D path
  * @alias module:modeling/primitives.line

package/src/primitives/polygon.js

@@ -24,13 +24,12 @@ import * as geom2 from '../geometries/geom2/index.js'
  * or
  * let poly = polygon({ points: [roof, wall], paths: [[0, 1, 2], [3, 4, 5, 6]] })
  */
-export const polygon = (options) => {
-  const defaults = {
-    points: [],
-    paths: [],
-    orientation: 'counterclockwise'
-  }
-  const { points, paths, orientation } = Object.assign({}, defaults, options)
+export const polygon = (options = {}) => {
+  const {
+    points = [],
+    paths = [],
+    orientation = 'counterclockwise'
+  } = options
 
   if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
 

package/src/primitives/polyhedron.js

@@ -21,14 +21,13 @@ import { isNumberArray } from './commonChecks.js'
  * let myFaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
  * let myShape = polyhedron({points: myPoints, faces: myFaces, orientation: 'inward'})
  */
-export const polyhedron = (options) => {
-  const defaults = {
-    points: [],
-    faces: [],
-    colors: undefined,
-    orientation: 'outward'
-  }
-  const { points, faces, colors, orientation } = Object.assign({}, defaults, options)
+export const polyhedron = (options = {}) => {
+  const {
+    points = [],
+    faces = [],
+    colors = undefined,
+    orientation = 'outward'
+  } = options
 
   if (!(Array.isArray(points) && Array.isArray(faces))) {
     throw new Error('points and faces must be arrays')

package/src/primitives/rectangle.js

@@ -6,6 +6,7 @@ import { isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with four sides at right angles.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rectangle, width and length
@@ -15,12 +16,11 @@ import { isNumberArray } from './commonChecks.js'
  * @example
  * let myshape = rectangle({size: [10, 20]})
  */
-export const rectangle = (options) => {
-  const defaults = {
-    center: [0, 0],
-    size: [2, 2]
-  }
-  const { center, size } = Object.assign({}, defaults, options)
+export const rectangle = (options = {}) => {
+  const {
+    center = [0, 0],
+    size = [2, 2]
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(size, 2)) throw new Error('size must be an array of X and Y values')

package/src/primitives/roundedCuboid.js

@@ -115,6 +115,7 @@ const stitchSides = (bottomCorners, topCorners) => {
 
 /**
  * Construct an axis-aligned solid cuboid in three dimensional space with rounded corners.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of rounded cube
  * @param {Array} [options.size=[2,2,2]] - dimension of rounded cube; width, depth, height
@@ -126,14 +127,13 @@ const stitchSides = (bottomCorners, topCorners) => {
  * @example
  * let myCube = roundedCuboid({size: [10, 20, 10], roundRadius: 2, segments: 16})
  */
-export const roundedCuboid = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    size: [2, 2, 2],
-    roundRadius: 0.2,
-    segments: 32
-  }
-  let { center, size, roundRadius, segments } = Object.assign({}, defaults, options)
+export const roundedCuboid = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    size = [2, 2, 2],
+    roundRadius = 0.2,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of X, Y and Z values')

package/src/primitives/roundedCylinder.js

@@ -12,6 +12,7 @@ import { cylinder } from './cylinder.js'
 
 /**
  * Construct a Z axis-aligned solid cylinder in three dimensional space with rounded ends.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
  * @param {number} [options.height=2] - height of cylinder
@@ -24,15 +25,14 @@ import { cylinder } from './cylinder.js'
  * @example
  * let myshape = roundedCylinder({ height: 10, radius: 2, roundRadius: 0.5 })
  */
-export const roundedCylinder = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    height: 2,
-    radius: 1,
-    roundRadius: 0.2,
-    segments: 32
-  }
-  const { center, height, radius, roundRadius, segments } = Object.assign({}, defaults, options)
+export const roundedCylinder = (options = {}) => {
+  const {
+    center = [0, 0, 0],
+    height = 2,
+    radius = 1,
+    roundRadius = 0.2,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isGTE(height, 0)) throw new Error('height must be positive')

package/src/primitives/roundedRectangle.js

@@ -10,6 +10,7 @@ import { rectangle } from './rectangle.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with rounded corners.
+ *
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rounded rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rounded rectangle; width and length
@@ -21,14 +22,13 @@ import { rectangle } from './rectangle.js'
  * @example
  * let myshape = roundedRectangle({size: [10, 20], roundRadius: 2})
  */
-export const roundedRectangle = (options) => {
-  const defaults = {
-    center: [0, 0],
-    size: [2, 2],
-    roundRadius: 0.2,
-    segments: 32
-  }
-  let { center, size, roundRadius, segments } = Object.assign({}, defaults, options)
+export const roundedRectangle = (options = {}) => {
+  let {
+    center = [0, 0],
+    size = [2, 2],
+    roundRadius = 0.2,
+    segments = 32
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(size, 2)) throw new Error('size must be an array of X and Y values')

package/src/primitives/sphere.js

@@ -15,14 +15,13 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = sphere({radius: 5})
  */
-export const sphere = (options) => {
-  const defaults = {
-    center: [0, 0, 0],
-    radius: 1,
-    segments: 32,
-    axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
-  }
-  let { center, radius, segments, axes } = Object.assign({}, defaults, options)
+export const sphere = (options = {}) => {
+  let {
+    center = [0, 0, 0],
+    radius = 1,
+    segments = 32,
+    axes = [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
+  } = options
 
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 

package/src/primitives/square.js

@@ -3,6 +3,7 @@ import { isGTE } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned square in two dimensional space with four equal sides at right angles.
+ *
  * @see [rectangle]{@link module:modeling/primitives.rectangle} for more options
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of square
@@ -13,12 +14,11 @@ import { isGTE } from './commonChecks.js'
  * @example
  * let myshape = square({size: 10})
  */
-export const square = (options) => {
-  const defaults = {
-    center: [0, 0],
-    size: 2
-  }
-  let { center, size } = Object.assign({}, defaults, options)
+export const square = (options = {}) => {
+  let {
+    center = [0, 0],
+    size = 2
+  } = options
 
   if (!isGTE(size, 0)) throw new Error('size must be positive')
 

package/src/primitives/star.js

@@ -28,6 +28,7 @@ const getPoints = (vertices, radius, startAngle, center) => {
 
 /**
  * Construct a star in two dimensional space.
+ *
  * @see https://en.wikipedia.org/wiki/Star_polygon
  * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of star
@@ -43,16 +44,15 @@ const getPoints = (vertices, radius, startAngle, center) => {
  * let star1 = star({vertices: 8, outerRadius: 10}) // star with 8/2 density
  * let star2 = star({vertices: 12, outerRadius: 40, innerRadius: 20}) // star with given radius
  */
-export const star = (options) => {
-  const defaults = {
-    center: [0, 0],
-    vertices: 5,
-    outerRadius: 1,
-    innerRadius: 0,
-    density: 2,
-    startAngle: 0
-  }
-  let { center, vertices, outerRadius, innerRadius, density, startAngle } = Object.assign({}, defaults, options)
+export const star = (options = {}) => {
+  let {
+    center = [0, 0],
+    vertices = 5,
+    outerRadius = 1,
+    innerRadius = 0,
+    density = 2,
+    startAngle = 0
+  } = options
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isGTE(vertices, 2)) throw new Error('vertices must be two or more')
@@ -71,10 +71,8 @@ export const star = (options) => {
     innerRadius = outerRadius * getRadiusRatio(vertices, density)
   }
 
-  const centerV = vec2.clone(center)
-
-  const outerPoints = getPoints(vertices, outerRadius, startAngle, centerV)
-  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, centerV)
+  const outerPoints = getPoints(vertices, outerRadius, startAngle, center)
+  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, center)
 
   const allPoints = []
   for (let i = 0; i < vertices; i++) {