Transforms

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

```let circleA = circle({radius: 5})
let circleB = circleA.scale([5,10]) // a new cicle, scaled as requested```

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

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

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

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

Transforms can also be chained together.

```// rotate the circle about the X axis by 45 degrees
// and translate the circle up the Z axis 10 units
// and assign the result to circleB
let circleB = circleA.rotateX(45).translate([0,0,10])```

The original shape can be transformed any number of times. For example, the same cylinder can be rotated, making copies of the cylinders, and then unioned together. This is a common pattern when creating complex designs.

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.

Rotate

Shapes can be rotated by any given degree about the X, Y, and Z axis. The degrees can be specified as either positive or negative values.

Defaults:

• degree : 0 or [0,0,0]
```let obj = cube([5,20,5])
obj = rotate([90,15,30],obj)
obj = rotate(90,[1,0.25,0.5],obj)```

The CSG library functions can also be used. NOTE: Deprecated in the V2 API

```obj.rotateX(90);
obj.rotateY(45);
obj.rotateZ(30);

obj.rotate(rotationCenter, rotationAxis, degrees)
obj.rotateEulerAngles(alpha, beta, gamma, position)```

Scale

Shapes can be scaled by any factor. Shapes are enlarged (increases) or shrunk (diminishes) by a scale factor. The result of scaling is a similar shape (in the geometric sense) to the original.

Defaults:

• factor : 1.0 or [1.0,1.0,1.0]
```let obj = sphere(5)
obj = scale(2,obj)
obj = scale([1,2,3],obj)```

The CSG library functions can also be used. NOTE: Deprecated in the V2 API

`obj.scale([1,2,3])`

Translate

Shapes can be translated (moved) to another location. In other words, every point in the shape is moved by a fixed distance in the same direction. The offset can be positive or negative.

Defaults:

• offset : 0 or [0,0,0]
```let obj = sphere(5)
obj = translate([0,0,10],obj)```

The CSG library functions can also be used. NOTE: Deprecated in the V2 API

`obj.translate([0,0,10])`

Center

Shapes can be centered about the X, Y or Z axis.

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

```let obj = sphere(5)
obj = center(true,cube(), obj)  // center the objects across all axes
obj = center([true, true, false], obj)  // center the object across only X and Y axis```

The CSG library functions can also be used. NOTE: Deprecated in the V2 API

```cube().center(true)                // center the object across all axes
cube().center([true,true,false])   // center the object across only X and Y axis```

Reflect

Shapes can reflect about the X, Y, or Z axis.

Defaults:

• axis : 0 or [0, 0, 0], set 1 to reflect about X, Y, or Z axis
```let obj = cube([5, 20, 5])
obj = mirror([1, 0, 1], obj) // mirror about X and Z axis```

The CSG library functions can also be used. NOTE: Deprecated in the V2 API

```var cube = CSG.cube().translate([1,0,0])

var cube2 = cube.mirroredX() // mirrored about the X axis
var cube3 = cube.mirroredY() // mirrored about the Y axis
var cube4 = cube.mirroredZ() // mirrored about the Z axis

// create a plane by specifying 3 points:
var plane = CSG.Plane.fromPoints([5,0,0], [5, 1, 0], [3, 1, 7]);

// and mirror in that plane:
var cube5 = cube.mirrored(plane);```

Matrix Transform

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

```let m = new CSG.Matrix4x4()
m = m.multiply(CSG.Matrix4x4.rotationX(40))
m = m.multiply(CSG.Matrix4x4.rotationZ(40))
m = m.multiply(CSG.Matrix4x4.translation([-.5, 0, 0]))
m = m.multiply(CSG.Matrix4x4.scaling([1.1, 1.2, 1.3]))

// and apply the transform:
let cube3 = cube().transform(m)```

Color

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

NOTE: 2D shapes cannot exhibit colors today. This is a known issue.

```let a = color("Red",sphere())
let b = color([1, 0.5, 0.3],sphere())
let c = color([1, 0.5, 0.3, 0.6],sphere(10),cube(20))```

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

The CSG library functions can also be used. NOTE: Deprecated in the V2 API

```let a = object.setColor(css2rgb('dodgerblue'))
let b = sphere().setColor(1, 0.5, 0.3)
let c = sphere().setColor([1, 0.5, 0.3, 0.7])```

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

Following functions to convert between color spaces.

```let rgb = css2rgb('navy')
let rgb = html2rgb('#RRGGBB')

let rgb = hsl2rgb(h,s,l) // or hsl2rgb([h,s,l])
let rgb = hsv2rgb(h,s,v) // or hsv2rgb([h,s,v])

let hsv = rgb2hsv(r,g,b) // or rgb2hsv([r,g,b])
let hsl = rgb2hsl(r,g,b) // or rgb2hsl([r,g,b])
let html = rgb2html(r,g,b)```

whereas

• r,g,b (red, green, blue)
• h,s,l (hue, saturation, lightness)
• h,s,v (hue, saturation, value)