###### meta data for this page

# Design Guide

Creating a new JSCAD design starts by writing simple scripts which call functions to create and manipulate shapes. In general, JSCAD designs are written using the JavaScript language.

*Find out more about JavaScript at w3schools*

The JSCAD suite of applications executes the script, generates shapes, applies transforms, performs operations, and renders the design for viewing.

## Anatomy of a Design

A JSCAD design (script) must have at least one function defined, the **main()** function, which must to return a shape.

const { sphere } = require('@jscad/modeling').primitives const main = () => { return sphere() // a single shape } module.exports = { main }

Or an array of shapes.

const { cube, cylinder, sphere } = require('@jscad/modeling').primitives const main () => { const a = cube() const b = sphere() const c = cylinder() return [a,b,c] // an array of shapes } module.exports = { main }

In addition, functions can be created to split the design into managable pieces, i.e. parts, etc.

const { cube, sphere } = require('@jscad/modeling').primitives const partA = (options) => { // called from main() below var shapes = [] shapes.push( sphere() ) shapes.push( cube(options) ) return shapes } const main = () => { let list = partA({radius: 10}) return list } module.exports = { main }

### Projects

As designs grow in complexity, the need for smaller, reusable parts becomes apparent. This is the time to consider using a “project”.

Projects are simple directories, containing several files (parts) of the design. For example, a project for a RC car design would have various parts. And the reusable parts can be separated out.

- …/rc-car
- chassis.js
- body.js
- tire.js
- index.js

The 'index' within the project is the entry point of the project. The main function of the 'index' creates each of the pieces, move the pieces into position, and returns the complete design. And by convention, exports the main function.

const chassis = require('./chassis') const body = require('./body') const tire = require('./tire') const main = (params) => { const partA = chassis(params) const partB = body(params) const tires = [ ... ] return [partA, partB, tires] } module.exports = { main }

Projects can also be used when working with external formats, such as STL files. This allows designs to include STL meshes just like any other part. The STL file is placed within the project directory just like any other part.

- …/rc-car
- chassis.js
- body.js
- tire.js
- index.js
- rc_receiver.stl

And the design is adjusted to include the new part from the STL file.

const chassis = require('./chassis') const body = require('./body') const tire = require('./tire') const receiver = require('./rc_receiver.stl') const main = (params) => { const partA = chassis(params) const partB = body(params) const tires = [ ... ] return [partA, partB, tires, receiver] } module.exports = { main }

### Design Parameters

A design can have interactive parameters by declaring a special function; getParameterDefinitions().

In applications and browsers, these parameters are presented to users, allowing users to change designs.

#### Usage

This function must return an array of parameter definitions, as show below.

const getParameterDefinitions = () => { return [ { name: 'length', type: 'int', initial: 150, caption: 'Length?' }, { name: 'width', type: 'int', initial: 100, caption: 'Width?' }, ] }

The parameters are evaluated and values are passed into the main function. Be sure to declare the main function properly.

const main = (params) => { var l = params.length var w = params.width ... }

#### Parameter Types

The parameters are defined as input fields on a single HTML5 form, i.e. the list of parameters. For more information on HTML5 input fields, see some examples at W3 Schools.

*Note: Browsers are NOT the same and will treat unsupported parameter types as TEXT.*

Type | Example | Returned Value |
---|---|---|

checkbox | {name: 'bigorsmall', type: 'checkbox', checked: true, caption: 'Big?'} | if checked true, else false |

checkbox | {name: 'bigorsmall', type: 'checkbox', checked: true, initial: 20, caption: 'Big?'} | if checked 20, else false |

color | { name: 'color', type: 'color', initial: '#FFB431', caption: 'Color?' } | “#rrggbb”, use html2rgb() to convert |

date | {name: 'birthday', type: 'date', caption: 'Birthday?'} | “YYYY-MM-DD” |

{name: 'address', type: 'email', caption: 'Email Address?'} | string value | |

float | {name: 'angle', type: 'number', initial: 2.5, step: 0.5, caption: 'Angle?'} | float value |

int | {name: 'age', type: 'int', initial: 20, caption: 'Age?'} | integer value |

number | {name: 'angle', type: 'number', initial: 2.5, step: 0.5, caption: 'Angle?'} | float value |

password | {name: 'password', type: 'password', caption: 'Secret?'} | string value |

slider | {name: 'count', type: 'slider', min: 2, max: 10, caption: 'How many?'} | float value |

text | {name: 'name', type: 'text', caption: 'Name?'} | string value |

url | {name: 'webpage', type: 'url', caption: 'Web page URL?'} | string value |

group | { name: 'balloon', type: 'group', caption: 'Balloons' } | none, only displayed |

The parameters accept additional restrictions and assistance. These include 'initial', 'max', 'maxLength', 'min', 'pattern', 'placeholder', 'size', and 'step'.

There is one more special parameter type called 'choice', which defines a list of choices for selection.

const getParameterDefinitions = () => { return [ { name: 'rounded', type: 'choice', caption: 'Rounded edges', values: [0, 1], captions: ['No', 'Yes (slow!)'], initial: 0 } ] }

The list of captions are those shown as a pull down list. The list of values define a value for each caption. And, the chosen value is passed into the main function.

## 3D Primitives

‘3D’ stands for three (3) dimensional. A 3D primitive is any shape that has three dimensions, which are often called width, depth, and height (or X, Y, Z.) 3D shapes have a known volume if closed.

The mathematical study of 3D shapes and dimensions is called solid geometry.

### Resolution of Shapes

All rounded shapes have a `segments`

option which controls tesselation. If `segments`

is set to 8, then 8 polygons are used to create a full revolution. If the `segments`

option is omitted, the default value is used.

This allows each design to control the amount of detail present, but beware that calculations and rendering time will also increase. For example, the number of polygons increases quadratically with each increase of the `segments`

for spheres.

Sometimes, a design requires a certain degree of resolution which is expressed in the length between points, or the angle between points. If this is the case, then use the conversion function to calculate the required segments. See Conversions

### Cuboid

A three dimensional shape created from six retangular faces, each at right angles to another, and opposite faces are equal.

*Learn about cuboids at MathIsFun.com*

The `size`

specifies the size of each face spanning X, Y and Z axis. Cuboids can be created at a requested `center`

.

Defaults:

- size : [2, 2, 2]
- center : [0, 0, 0]

const { cuboid } = require('@jscad/modeling').primitives const myshape = cuboid({size: [1, 2, 3]}) const myshape = cuboid({size: [1, 2, 3], center: [4, 5, 6]})

#### Cube

The **cube** is a special case of the cuboid in which all six faces are squares.

Defaults:

- size : 2
- center : [0, 0, 0]

const { cube } = require('@jscad/modeling').primitives const myshape = cube({size: 3}) const myshape = cube({size: 3, center: [4, 5, 6]})

#### Rounded Cuboid

Rounded cuboids can be created by specifying a `roundRadius`

for the corners.

Defaults:

- size : [2, 2, 2]
- center : [0, 0, 0]
- roundRadius : 0.2
- segments : 32

const { roundedCuboid } = require('@jscad/modeling').primitives const myshape = roundedCuboid({size: [1, 2, 3], roundRadius: 0.25}) const myshape = roundedCuboid({size: [1, 2, 3], roundRadius: 0.25, center: [4, 5, 6], segments: 32})

### Ellipsoid

A three dimensional surface that has three pairwise perpendicular axes of symmetry which intersect at a center.

The `radius`

determines the size of the ellipsoid about the X, Y, and Z axis. Ellipsoids can be created at a requested `center`

. The `segments`

specify the number of segments to create per full rotation.

Defaults:

- radius : [1, 1, 1]
- center : [0, 0, 0]
- segments : 32

const { ellipsoid } = require('@jscad/modeling').primitives const myshape = ellipsoid({radius: [5, 10, 20]}) const myshape = ellipsoid({radius: [5, 10, 20], center: [5, 5, 5], segments: 64})

#### Sphere

A three dimensional shape like a ball, where every point on the surface is the same distance from the center.

*Learn about spheres at MathIsFun.com*

The `radius`

determines the size of the sphere. Spheres can be created at a requested `center`

. The `segments`

specify the number of segments to create per full rotation.

Defaults:

- radius : 1
- center : [0, 0, 0]
- segments : 32

const { sphere } = require('@jscad/modeling').primitives const myshape = sphere({radius: 3.5}) const myshape = sphere({radius: 3.5, center: [5, 5, 5], segments: 64})

#### Geodesic Sphere

A three dimensional shape formed by a convex polyhedron consisting of triangles. The base form is the icosahedron polyhedron with 20 faces.

The `radius`

determines the size of the sphere. The `frequency`

specifies the division of each face. A frequency of one (1) reveals the base form, icosahedron.

Defaults:

- radius : 1
- frequency : 6

const { geodesicSphere } = require('@jscad/modeling').primitives const myshape = geodesicSphere({radius: 15, frequency: 18}) // frequency should be a multiple of 6

### Cylinder

A three dimensional shape with two flat ends that are circular. The cylinder has the same cross-section from one end to the other, extending about the Z axis.

*Learn about cylinders at MathIsFun.com*

The `radius`

specifies the circular size about the Z axis, while the `height`

specifies the size. Cylinders can be created at a requested `center`

. The `segments`

specify the number of segments to create per full rotation.

Defaults:

- radius : 1
- height : 2
- center : [0, 0, 0]
- segments : 32

const { cylinder } = require('@jscad/modeling').primitives const myshape = cylinder({radius: 5, height: 10}) const myshape = cylinder({radius: 5, height: 10, center: [5, 5, 5], segments: 64})

#### Elliptical Cylinder

Various cylindrical shapes can be created using the elliptical cylinder, including cylinders with changing radius (cones).

Defaults:

- height : 2
- startRadius : [1, 1]
- endRadius : [1, 1]
- center : [0, 0, 0]
- segments : 32
- startAngle : 0
- endAngle : PI * 2

const { cylinderElliptic } = require('@jscad/modeling').primitives const myshape = cylinderElliptic({height: 2, startRadius: [10, 5], endRadius: [8, 3]})

#### Rounded Cylinder

Cylinders can be created with rounded ends by specifying `roundRadius`

.

Defaults:

- radius : 1
- height : 2
- roundRadius: 0.5
- center : [0, 0, 0]
- segments : 32

const { roundedCylinder } = require('@jscad/modeling').primitives const myshape = roundedCylinder({radius: 5, height: 10, roundRadius: 0.5}) const myshape = roundedCylinder({radius: 5, height: 10, roundRadius: 0.5, center: [5, 5, 5], segments: 64})

### Torus

A three dimensional shape made by revolving a small circle (inner) along the circumference a bigger circle (outer).

*Learn about torus at MathIsFun.com*

A torus is defined as such:

- Inner Circle
- inner radius
- inner rotation before rotating about the outer circle
- inner segments

- Outer Circle
- outer radius
- outer segments

- Rotation
- start angle of rotation
- outer rotation

Defaults:

- innerRadius : 1
- innerRotation : 0
- innerSegments : 32
- outerRadius : 4
- outerSegments : 32
- startAngle : 0
- outerRotation : PI * 2

const { torus } = require('@jscad/modeling').primitives const myshape = torus({innerRadius: 10, outerRadius: 100})

### Polyhedron

A three dimensional shape where connecting faces create a solid. Each face is a three dimensional polygon (a flat shape with straight sides).

*Learn about polyhedrons at MathIsFun.com*

Create a polyhedron from a list of `points`

and a list of `faces`

. The `points`

list all the vertexes of the shape, while the `faces`

define the points used within each face.

*Note: The order of the points must be consistent, defining 'inward' or 'outward' facing polygons.*

const { polyhedron } = require('@jscad/modeling').primitives const points = [ [10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10] ] const faces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ] const myshape = polyhedron({points, faces, orientation: 'inward'})

## 2D Primitives

‘2D’ stands for two (2) dimensional. A 2D primitive is any shape that has two dimensions, which are width and length (or X and Y.) The 2D dimensional shapes have no thickness (Although, JSCAD shows a very thin shape.)

One way of thinking about 2D shapes is anything that lays flat on a piece of paper, such as drawing a circle or a square.

The mathematical study of 2D shapes and dimensions is called plane geometry.

#### Resolution of Shapes

All rounded shapes have a `segments`

option which controls tessellation. If `segments`

is set to 8, then 8 segments are used to create PI * 2 radians of revolution. If the `segments`

option is omitted, the default value is used.

This allows each design to control the amount of detail present, but beware that calculations and rendering time will also increase. For example, the number of polygons increases quadratically with each increase of the `segments`

for spheres.

### Rectangle

A two dimensional shape made with four straight sides where all interior angles are right angles (90°).

*Learn about rectangles at MathIsFun.com*

The `size`

specifies the size across X and Y axis. Rectangles can be created at a requested `center`

.

Defaults:

- size : [2, 2]
- center : [0, 0]

const { rectangle } = require('@jscad/modeling').primitives const myshape = rectangle({size: [3, 4]}) const myshape = rectangle({size: [3, 4], center: [5, 5]})

#### Square

The specialized square primitive also exists, but requires only one number value for all sides.

Defaults:

- size : 2
- center : [0, 0]

const { square } = require('@jscad/modeling').primitives const myshape = square({size: 3}) const myshape = square({size: 3, center: [5, 5]})

#### Rounded Rectangle

Rounded rectangles can be created by specifying a `roundRadius`

for the corners.

Defaults:

- size : [2, 2]
- center : [0, 0]
- roundedRadius: 0.2
- segments: 32

const { roundedRectangle } = require('@jscad/modeling').primitives const myshape = roundedRectangle({size: [10, 20], roundRadius: 2}) const myshape = roundedRectangle({size: [10, 20], roundRadius: 2, center: [5, 5], segments: 64})

### Ellipse

A two dimensional shape that surrounds two focal points, such that for all points on the curve, the sum of the two distances to the focal points is a constant.

The `radius`

determines the size of the ellipsoid about X and Y axis. Ellipsoids can be created at a requested `center`

. The `segments`

specify the number of segments to create per full rotation.

Defaults:

- radius : [1, 1]
- center : [0, 0]
- startAngle : 0
- endAngle : PI * 2
- segments: 32

const { ellipse } = require('@jscad/modeling').primitives const myshape = ellipse({radius: [5, 10]}) const myshape = ellipse({radius: [5, 10], center: [5, 5], startAngle: Math.PI / 2, endAngle: Math.PI, segments: 64})

#### Circle

A two dimensional shape made by drawing a curve that is always the same distance from a center. All points are the same distance from the center.

*Learn about circles at MathIsFun.com*

The `radius`

specifies the size across both X and Y axis. Circles can be created at a requested `center`

. The `segments`

specify the number of segments to create per full rotation.

Defaults:

- radius : 1
- center : [0, 0]
- segments: 32

const { circle } = require('@jscad/modeling').primitives const myshape = circle({radius: 10}) const myshape = circle({radius: 10, center: [5, 5], startAngle: Math.PI / 2, endAngle: Math.PI, segments: 64})

### Polygon

A two dimensional shape with straight sides, and the shape is “closed” (all the sides connect up).

*Learn about polygons at MathIsFun.com*

*NOTE: The ordering of points is VERY IMPORTANT. If the polygon is going to be extruded then the points must be in counter-clockwise order, otherwise the faces of the object will be facing inwards. See Orientation.*

*HINT: Polygons should have a positive area.*

The following show examples of creating polygons from a list of points.

Defaults:

- empty

const { polygon } = require('@jscad/modeling').primitives const myshape = polygon({ points: [ [0,0],[3,0],[3,3] ] })

### Star

A two dimensional shape made from straight rays extending from a center. All vertices are the same distance from the center.

Note: See the paper on The Inner Radius of n/m Stars by Julian D. A. Wiseman for more details.

Defaults:

- vertices : 5
- density : 2
- outerRadius : 1
- innerRadius : 0
- startAngle : 0
- center : [0, 0, 0]

const { star } = require('@jscad/modeling').primitives 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

## Transforms

All shapes can be transformed, i.e. translated to another location, rotated by certain angles, etc. In all cases, the transform function returns a **new shape**, not the original.

const myshape = circle({radius: 5}) const newshape = scale([5, 10], circleA) // a new cicle, scaled as requested

So, in order to modify the original, place the original on the left-hand side of the expression.

let myshape = circle({radius: 5}) myshape = scale([5, 10], myshape) // a new circle, scaled as requested, reassigned to the original

In fact, the two lines above can be combined into a single line.

let myshape = scale([5, 10]). circle({radius: 5})) // a new circle, and scaled as requested

Transforms can also be chained together, but keep in mind that the order of transforms is important.

let myshape = scale([5, 10]). circle({radius: 5})) myshape = translate([0, 0, 10]), rotateX(45, myshape))

The original shape can be transformed any number of times. For example, the a single cylinder can be rotated and translated to make multiple copies of the original. And then, the set of cylinders can be combined together using union. This is a common pattern when creating complex designs.

The transforms return a single shape or an array of shapes depending on the given shapes.

const newshape = align({modes: ['none', 'center', 'none']}, oldshape) /* Returns a single shape */ const newshapes = align({modes: ['min', 'center', 'none'], alignTo: [10, null, 10], grouped: true }, oldshape, [oldshape0, oldshape1]) /* Returns an array of new shapes*/

### Orientation

The standard for all 3D systems today, including graphics cards, design tools, etc. is orientating shapes using the right-hand rule. JSCAD follows the same rules internally, and produces shapes, applies transforms, etc. using the right-hand rule of orientation. See Orientation for more information.

### Rotate

Shapes can be rotated by any given angle about the X, Y, and Z axis. The `angles`

can be specified as either positive or negative values, in RADIANS.

*Learn about rotation at MathIsFun.com*

Defaults:

- angles : [0, 0, 0]

const { cuboid } = require('@jscad/modeling').primitives const { rotate } = require('@jscad/modeling').transforms const myshape = cuboid({size: [5, 20, 5]}) const newshape = rotate([(Math.PI * 2 / 4), (Math.PI * 2 / 24), (Math.PI * 2 / 12)], myshape)

In addition, there are simple versions of the same function for rotating about a single axis.

const { cuboid } = require('@jscad/modeling').primitives const { rotateX,rotateY,rotateZ } = require('@jscad/modeling').transforms const myshape = cuboid({size: [5, 20, 5]}) let newshape = rotateX((Math.PI * 2 / 4), myshape) newshape = rotateY((Math.PI * 2 / 24), newshape) newshape = rotateZ((Math.PI * 2 / 12), newshape)

There is a utility function to convert DEGREE to RADIAN values.

const { cuboid } = require('@jscad/modeling').primitives const { rotateX,rotate } = require('@jscad/modeling').transforms const { degToRad } = require('@jscad/modeling').utils const myshape = cuboid({size: [5, 20, 5]}) const newshape = rotate([degToRad(90), degToRad(15), degToRad(30)], myshape) const newshape = rotateX(degToRad(90), myshape)

### Scale

Shapes can be scaled by any factor, enlarging (increasing) or shrinking (diminishing) shapes by the `factors`

about X, Y, and Z axis. The result of scaling is a similar shape (in the geometric sense) to the original.

*Learn about the scaling shapes at Wikipedia.org*

Defaults:

- factors : [1.0, 1.0, 1.0]

const myshape = sphere({radius: 5}) const newshape = scale([2, 4, 6], myshape)

In addition, there are simple versions of the same function for scaling about a single axis.

const myshape = sphere({radius: 5}) let newshape = scaleX(2, myshape) newshape = scaleY(4, newshape) newshape = scaleZ(6, newshape)

### Translate

Shapes can be translated (moved) to another location. In other words, every point in the shape is moved by a fixed distance as given by the `offset`

. The `offset`

can be positive or negative.

*Learn about translation at MathIsFun.com*

Defaults:

- offset : [0, 0, 0]

const myshape = sphere([radius: 5}) const newshape = translate([3, 7, -10], myshape)

In addition, there are simple versions of the same function for translating about a single axis.

const myshape = sphere([radius: 5}) let newshape = translateX(3, myshape) newshape = translateY(7, newshape) newshape = translateZ(-10, newshape)

### Align

Shapes can be aligned across X, Y, and Z axis. In other words, each shape is translated to the requested position, aligning the boundaries of the shapes. The `modes`

of alignment control which position to use, with values 'center', 'min', 'max', or 'none'. The alignment can also be positioned to a specific point, `relativeTo`

.

Defaults:

- modes : ['center', 'center', 'min']
- group : false (do not align all shapes as a group)
- relativeTo : [0, 0, 0]

const newshapes = align({modes: ['min', 'none', 'none'], myshape1, myshape2, myshape3) // align shapes at the minimum X const newshapes = align({modes: ['min', 'center', 'none'], relativeTo: [10, null, 10], grouped: true}, myshape1, myshape2, myshape3)

### Center

Shapes can be centered about the X, Y or Z axis, or centered relative to a given point.

*Note: The center of a shape is calculated as the midpoint between minimum and maximum points.*

Defaults:

- axes : [true, true, true]
- relativeTo : [0, 0, 0]

const myshape = sphere({radius: 5}) let newshape = center({}, myshape) // center the shape across all axes newshape = center({axes: [true, true, false]}, myshape) // center the object across only X and Y axis newshape = center({relativeTo: [5, 6, 7]}, myshape) // center the shape relative to the given point

There are also simple versions of this function to center the shape about the origin.

const myshape = sphere({radius: 5}) let newshape = centerX(myshape) newshape = centerY(newshape) newshape = centerZ(newshape)

### Mirror

Shapes can mirror (reflect) about the X, Y, or Z axis, and more specifically about any `origin`

.

*Learn about reflection at MathIsFun.com*

Defaults:

- origin : [0, 0, 0]
- normal : [0, 0, 1] (mirror about the Z axis)

const myshape = cube({size: [5, 20, 5]}) const newshape = mirror({origin: 3, 3, 3], normal: [1, 0, 1]}, myshape)

There are simple versions of this function to mirror a single axis about the origin.

const myshape = cube({size: [5, 20, 5]}) let newshape = mirrorX(myshape) newshape = mirrorY(newshape) newshape = mirrorZ(newshape)

### Matrix Transform

The previous transforms are actually simplified versions of matrix mathematics. For example, translate is just applying addition using a matrix.

*Learn about matrix mathematics at MathIsFun.com*

let matrix = mat4.create() matrix = mat4.multiply(mat4.rotationX(40)) matrix = mat4.multiply(mat4.rotationZ(40)) matrix = mat4.multiply(mat4.translation([-.5, 0, 0])) matrix = mat4.multiply(mat4.scaling([1.1, 1.2, 1.3])) // and apply the transform const myshape = transform(matrix, cube())

## Operations

All shapes (primitives or the results of operations) can be passed to special functions to perform logical operations, e.g. removing a hole from a board. In all cases, the operation returns the results, and **never** changes the original shapes.

### Union

Several shapes can be combined (merged) into a single shape, creating complex 'parts'. The combining of smaller obects together allows the 'part' to be used in other operations, transformations, etc.

const newshape = union(cube({size: 10}), cylinder({radius: 4, heigth: 14})

### Intersect

Several objects can be combined (overlapped) into a single shape. This result is the logical intersection of the shapes.

const newshape = intersect(cube({size: 10}), cylinder({radius: 4, heigth: 14})

### Subtract

Several shapes can be removed (subtracted) from another. The result is the logical difference of shapes.

*Note: The first shape given is the base shape for all subtractions.*

const newshape = subtract(cube({size: 10}), cylinder({radius: 4, heigth: 14})

### Hull

Several shapes can be combined together to form the convex hull, i.e. sum of the outside shells. This includes irregular shapes such as combining a circle with a square.

*Learn more about convex hull at Wikipedia.org*

const newshape = hull(shape1, shape2, shape3)

### Hull Chain

Hull chain is a variant of 'hull' essentially sequential hulling each pair of shapes, then creating a union of the results.

const newshape = hullChain(shape1, shape2, shape3)

### Scission

*'Scission' meaning “The act of cutting or dividing, as with an edged instrument”*

Sometimes complex shapes need to be divided into the smaller pieces. A good example is when creating 'molds' from the pieces of a boolean operation. Or splitting a complex shape into the component pieces from an imported design, i.e. splitting STL models.

const newshapes = scission(bigshape) // expect an array containing the pieces

## Extrusions

Extruding a two dimensional shape into a three dimensional shape can be performed in various ways. In each extrusion process, a continuous three dimensional shape is formed with a constant cross section similar to that of the two dimensional shape.

*NOTE: In order for extrusions to produce correct shapes, the initial two dimensional shape must have the proper orientation. See Orientation below.*

### Linear Extrude

Extrude a two dimensional shape in an upward linear direction.

The two dimensional shape is extruded to the `height`

, upwards along the Z axis. The two dimensional shape is be rotated `twistAngle`

about the Z axis during the extrusion, creating `twistSteps`

during the extrusion.

*Note: The two dimensional shape can be placed anywhere to create various twisted shapes.*

Defaults:

- height : 1
- twist : 0
- twistSteps : 1 (Note: Increasing the value of twistSteps improves the overall shape.)

const { extrudeLinear } = require('@jscad/modeling').extrusions const myshape = extrudeLinear({height: radiusZ * 2}, shape1) const myshape = extrudeLinear({height: radiusZ * 2, twistAngle: Math.PI / 2, twistSteps: 10}, shape2)

### Rectangular Extrude

Extrude a rectangle (upright, perpendicular) along the outlines of the two dimensional shape.

The two dimensional shape is extruded to the `height`

, upwards along the Z axis.

*Note: The extrusion process uses Linear Extrude underneath, so the extrusion can be rotated twistAngle about the Z axis during the extrusion, creating twistSteps during the extrusion.*

Defaults:

- size: 1 (width of rectangle during extrusion)
- height : 1

const myshape = extrudeRectangular({height: radiusZ * 2, size: 0.25}, shape1) const myshape = extrudeRectangular({height: radiusZ * 2, size: 3, twistAngle: Math.PI / 2, twistSteps: 10}, shape2)

### Rotate Extrude

Extrude a two dimensional shape in a rotation about the Z axis. The two dimensional shape can be placed anywhere to create various three dimensional shapes. The `segments`

specify the number of segments to create per full rotation.

Defaults:

- startAngle : 0
- angle: PI * 2
- overflow: 'cap' (cap the ends in order to create a solid)
- segments: 12 (Note: Increasing the value of segments improves the overall shape.)

const myshape = extrudeRotate({segments: 64}, shape1) const myshape = extrudeRotate({segments: 8, angle: Math.PI startAngle: 0}, shape3)

## Projections

The projection of a shape is a two dimensional representation of a three dimensional object. In this case, the projection is a parallel projection where the lines of projection are parallel, i.e. the projection is the same whether the shape is far away or near to the projection plane.

### Project

add diagram

The outlines of three dimension shapes can be projected to two dimensional space. The 'axis' and 'origin' define the plane of which to project, which can be positioned anywhere about the shape.

Defaults: (Z Axis)

- axis : [0, 0, 1]
- origin: [0, 0, 0]

const myshape = project({}, sphere({radius: 20, segments: 5}))

### Expansions / Offsets

All shapes (primitives or the results of operations) can be passed to special functions to expand (enlarge) or contract (lessen) a shape. In all cases, the operation returns the results, and never changes the original shapes.

### Offset

*Note: The original shape is black.*

Offsetting two or three dimensional shapes can be performed, which maintains a specific `delta`

distance from the shape. The `corners`

can be filled with 'edge', 'round“, or 'chamfer' edges.

The opposite is also possible by specifying a negative (-) `delta`

.

Defaults:

- delta : 1
- corners : 'edge'
- segments : 16

const myshape = offset({corners: 'round'}, shape1) const myshape = offset({delta: -2}, shape2) const myshape = offset({delta: 2}, shape3)

*Note: Offsetting three dimensional shapes NOT possible today. This is a known issue.*

## Shape Attributes

at

### Color

Shapes can exhibit different colors. And just like the other transformations, adding color to a shape produces a new shape, i.e. one with color.

Colors are not only important for visual rendering but also controlling the selection of filaments during 3D printing. Therefore, colors should be applied as the last step in designs to insure proper printing.

const myshape = colorize([1, 0, 0], sphere()) // RGB red const myshape = colorize([1, 0.5, 0.3], sphere()) // color const myshape = colorize([1, 0.5, 0.3, 0.6], sphere()) // color plus alpha transparency

*Note: There are known issues with transparency, and depending on the order of colors, objects may not seem transparent. Try different 'alpha' values or colors.*

#### Color Space Conversion

There are several functions to convert between color spaces, including color names.

const wildcylinder = colorize(colorNameToRgb('fuchsia'), cylinder()) const bluesphere = colorize(hexToRgb('#000080'), sphere()) // navy blue const mysphere = colorize(hslToRgb([0.9166666666666666, 1, 0.5]), sphere()) const mysphere = colorize(hsvToRgb([0.9166666666666666, 1, 1]), sphere())

whereas

- r,g,b (red, green, blue) of RGB color model
- h,s,l (hue, saturation, lightness) of HSL color model
- h,s,v (hue, saturation, value) of HSV color model

See the Extended Color Keywords for all available colors. Color keywords are case-insensitive, e.g. 'RED' is the same as 'red'.

### Measurements

Sometimes the measurements of a shape can assist when creating a design. This is especially true for shapes imported from external formats.

const { measureArea, measureBoundingBox, measureVolume } = require('@jscad/modeling').measurements

#### Area

Measuring the area of a shape is possible, for both 2D and 3D shapes.

let area = measureArea(sphere())

*Note: The area for a path is always zero(0) as paths are infinitely thin.*

In addition, the total (aggregate) area for the given geometries can be measured.

let totalArea = measureAggregateArea(sphere(),cube())

*Note: This measurement will not account for overlapping geometry.*

#### Bounding Box

Measuring the bounding box (min and max bounds) of a shape is possible.

The measureBoundingBox function can be used to retrieve the bounding box of an object, returning an array with two points specifying the minimum and maximum coordinates, i.e. X, Y, Z values.

let bounds = measureBoundingBox(sphere())

In addition, the total (aggregate) bounding box for the given geometries can be measured.

let totalBounds = measureAggregateBoundingBox(sphere(),cube())

#### Bounding Sphere

Measuring the (approximate) bounding sphere of a shape is possible.

let bounds = measureBoundingSphere(cube())

#### Center

Measuring the center of a shape is possible.

let center = measureCenter(sphere())

*Note: This is equivalent to the center of the bounding box.*

#### Center of Mass

Measuring the center of mass of a shape is possible.

let center = measureCenterOfMass(sphere())

*Note: The center of mass for a path is always zero(0) as paths are infinitely thin.*

#### Dimensions

Measuring the dimensions of a shape is possible, i.e. width, depth, and height of a shape.

let dimensions = measureDimensions(sphere())

*Note: This is the equivalent width, depth, height of the bounding box.*

#### Epsilon

Measuring the epsilon of shapes is possible. Epsilon values are used in various functions to determine minimum distances between points, planes, etc.

let epsilon = measureEpsilon(sphere())

In addition, the combined epsilon for a group geometries can be measured.

let groupEpsilon = measureAggregateEpsilon(sphere(),cube())

#### Volume

Measuring the volume of a shape is possible.

let volume = measureVolume(sphere())

*Note: The volume of 2D shapes is always zero(0).*

In addition, the total (aggregate) volume for the given geometries can be measured.

let totalVolume = measureAggregateVolume(sphere(),cube())

*Note: This measurement will not account for overlapping geometry.*