@jbroll/jscad-modeling 2.12.7

package/src/colors/hslToRgb.js

@@ -0,0 +1,44 @@
+const flatten = require('../utils/flatten')
+
+const hueToColorComponent = require('./hueToColorComponent')
+
+/**
+ * Converts HSL color values to RGB color values.
+ *
+ * @see http://en.wikipedia.org/wiki/HSL_color_space
+ * @param {...Number|Array} values - HSL or HSLA color values
+ * @return {Array} RGB or RGBA color values
+ * @alias module:modeling/colors.hslToRgb
+ *
+ * @example
+ * let mysphere = colorize(hslToRgb([0.9166666666666666, 1, 0.5]), sphere())
+ */
+const hslToRgb = (...values) => {
+  values = flatten(values)
+  if (values.length < 3) throw new Error('values must contain H, S and L values')
+
+  const h = values[0]
+  const s = values[1]
+  const l = values[2]
+
+  let r = l // default is achromatic
+  let g = l
+  let b = l
+
+  if (s !== 0) {
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s
+    const p = 2 * l - q
+    r = hueToColorComponent(p, q, h + 1 / 3)
+    g = hueToColorComponent(p, q, h)
+    b = hueToColorComponent(p, q, h - 1 / 3)
+  }
+
+  if (values.length > 3) {
+    // add alpha value if provided
+    const a = values[3]
+    return [r, g, b, a]
+  }
+  return [r, g, b]
+}
+
+module.exports = hslToRgb

package/src/colors/hslToRgb.test.js

@@ -0,0 +1,37 @@
+const test = require('ava')
+
+const { hslToRgb } = require('./index')
+
+test('hslToRgb (HSL values)', (t) => {
+  let obs = hslToRgb([0, 1, 0])
+  let exp = [0, 0, 0]
+
+  t.deepEqual(obs, exp)
+
+  obs = hslToRgb([0.9166666666666666, 1, 0.5])
+  exp = [1, 0, 0.5000000000000002]
+
+  t.deepEqual(obs, exp)
+
+  obs = hslToRgb(0.9166666666666666, 0, 0.5)
+  exp = [0.5, 0.5, 0.5]
+
+  t.deepEqual(obs, exp)
+})
+
+test('hslToRgb (HSLA values)', (t) => {
+  let obs = hslToRgb([0, 1, 0, 1])
+  let exp = [0, 0, 0, 1]
+
+  t.deepEqual(obs, exp)
+
+  obs = hslToRgb([0.9166666666666666, 1, 0.5, 1])
+  exp = [1, 0, 0.5000000000000002, 1]
+
+  t.deepEqual(obs, exp)
+
+  obs = hslToRgb(0.9166666666666666, 0, 0.5, 0.5)
+  exp = [0.5, 0.5, 0.5, 0.5]
+
+  t.deepEqual(obs, exp)
+})

package/src/colors/hsvToRgb.d.ts

@@ -0,0 +1,8 @@
+import { HSV, HSVA, RGB, RGBA } from './types'
+
+export default hsvToRgb
+
+declare function hsvToRgb(hsv:  HSV): RGB
+declare function hsvToRgb(hsv:  HSVA): RGBA
+declare function hsvToRgb(...hsv:  HSV): RGB
+declare function hsvToRgb(...hsv:  HSVA): RGBA

package/src/colors/hsvToRgb.js

@@ -0,0 +1,73 @@
+const flatten = require('../utils/flatten')
+
+/**
+ * Converts HSV color values to RGB color values.
+ *
+ * @see http://en.wikipedia.org/wiki/HSV_color_space.
+ * @param {...Number|Array} values - HSV or HSVA color values
+ * @return {Array} RGB or RGBA color values
+ * @alias module:modeling/colors.hsvToRgb
+ *
+ * @example
+ * let mysphere = colorize(hsvToRgb([0.9166666666666666, 1, 1]), sphere())
+ */
+const hsvToRgb = (...values) => {
+  values = flatten(values)
+  if (values.length < 3) throw new Error('values must contain H, S and V values')
+
+  const h = values[0]
+  const s = values[1]
+  const v = values[2]
+
+  let r = 0
+  let g = 0
+  let b = 0
+
+  const i = Math.floor(h * 6)
+  const f = h * 6 - i
+  const p = v * (1 - s)
+  const q = v * (1 - f * s)
+  const t = v * (1 - (1 - f) * s)
+
+  switch (i % 6) {
+    case 0:
+      r = v
+      g = t
+      b = p
+      break
+    case 1:
+      r = q
+      g = v
+      b = p
+      break
+    case 2:
+      r = p
+      g = v
+      b = t
+      break
+    case 3:
+      r = p
+      g = q
+      b = v
+      break
+    case 4:
+      r = t
+      g = p
+      b = v
+      break
+    case 5:
+      r = v
+      g = p
+      b = q
+      break
+  }
+
+  if (values.length > 3) {
+    // add alpha value if provided
+    const a = values[3]
+    return [r, g, b, a]
+  }
+  return [r, g, b]
+}
+
+module.exports = hsvToRgb

package/src/colors/hsvToRgb.test.js

@@ -0,0 +1,27 @@
+const test = require('ava')
+
+const { hsvToRgb } = require('./index')
+
+test('hsvToRgb (HSV values)', (t) => {
+  let obs = hsvToRgb([0, 0.2, 0])
+  let exp = [0, 0, 0]
+
+  t.deepEqual(obs, exp)
+
+  obs = hsvToRgb(0.9166666666666666, 1, 1)
+  exp = [1, 0, 0.5]
+
+  t.deepEqual(obs, exp)
+})
+
+test('hsvToRgb (HSVA values)', (t) => {
+  let obs = hsvToRgb([0, 0.2, 0, 1])
+  let exp = [0, 0, 0, 1]
+
+  t.deepEqual(obs, exp)
+
+  obs = hsvToRgb(0.9166666666666666, 1, 1, 0.5)
+  exp = [1, 0, 0.5, 0.5]
+
+  t.deepEqual(obs, exp)
+})

package/src/colors/hueToColorComponent.d.ts

@@ -0,0 +1,3 @@
+export default hueToColorComponent
+
+declare function hueToColorComponent(p: number, q: number, t: number): number

package/src/colors/hueToColorComponent.js

@@ -0,0 +1,18 @@
+/**
+ * Convert hue values to a color component (ie one of r, g, b)
+ * @param  {Number} p
+ * @param  {Number} q
+ * @param  {Number} t
+ * @return {Number} color component
+ * @alias module:modeling/colors.hueToColorComponent
+ */
+const hueToColorComponent = (p, q, t) => {
+  if (t < 0) t += 1
+  if (t > 1) t -= 1
+  if (t < 1 / 6) return p + (q - p) * 6 * t
+  if (t < 1 / 2) return q
+  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6
+  return p
+}
+
+module.exports = hueToColorComponent

package/src/colors/index.d.ts

@@ -0,0 +1,13 @@
+export { default as colorize } from './colorize'
+export { default as colorNameToRgb } from './colorNameToRgb'
+export * as cssColors from './cssColors'
+export { default as hexToRgb } from './hexToRgb'
+export { default as hslToRgb } from './hslToRgb'
+export { default as hsvToRgb } from './hsvToRgb'
+export { default as hueToColorComponent } from './hueToColorComponent'
+export { default as rgbToHex } from './rgbToHex'
+export { default as rgbToHsl } from './rgbToHsl'
+export { default as rgbToHsv } from './rgbToHsv'
+
+export * from './types'
+export as namespace colors

package/src/colors/index.js

@@ -0,0 +1,19 @@
+/**
+ * All shapes (primitives or the results of operations) can be assigned a color (RGBA).
+ * In all cases, the function returns the results, and never changes the original shapes.
+ * @module modeling/colors
+ * @example
+ * const { colorize, hexToRgb } = require('@jscad/modeling').colors
+ */
+module.exports = {
+  colorize: require('./colorize'),
+  colorNameToRgb: require('./colorNameToRgb'),
+  cssColors: require('./cssColors'),
+  hexToRgb: require('./hexToRgb'),
+  hslToRgb: require('./hslToRgb'),
+  hsvToRgb: require('./hsvToRgb'),
+  hueToColorComponent: require('./hueToColorComponent'),
+  rgbToHex: require('./rgbToHex'),
+  rgbToHsl: require('./rgbToHsl'),
+  rgbToHsv: require('./rgbToHsv')
+}

package/src/colors/rgbToHex.d.ts

@@ -0,0 +1,6 @@
+import { RGB, RGBA } from './types'
+
+export default rgbToHex
+
+declare function rgbToHex(rgb: RGB | RGBA): string
+declare function rgbToHex(...rgb: RGB | RGBA): string

package/src/colors/rgbToHex.js

@@ -0,0 +1,27 @@
+const flatten = require('../utils/flatten')
+
+/**
+ * Convert the given RGB color values to CSS color notation (string)
+ * @see https://www.w3.org/TR/css-color-3/
+ * @param {...Number|Array} values - RGB or RGBA color values
+ * @return {String} CSS color notation
+ * @alias module:modeling/colors.rgbToHex
+ */
+const rgbToHex = (...values) => {
+  values = flatten(values)
+  if (values.length < 3) throw new Error('values must contain R, G and B values')
+
+  const r = values[0] * 255
+  const g = values[1] * 255
+  const b = values[2] * 255
+
+  let s = `#${Number(0x1000000 + r * 0x10000 + g * 0x100 + b).toString(16).substring(1, 7)}`
+
+  if (values.length > 3) {
+    // convert alpha to opacity
+    s = s + Number(values[3] * 255).toString(16)
+  }
+  return s
+}
+
+module.exports = rgbToHex

package/src/colors/rgbToHex.test.js

@@ -0,0 +1,15 @@
+const test = require('ava')
+
+const { rgbToHex } = require('./index')
+
+test('rgbToHex', (t) => {
+  let obs = rgbToHex([1, 0, 0.5])
+  let exp = '#ff007f'
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHex(1, 0, 0.5, 0.8)
+  exp = '#ff007fcc'
+
+  t.deepEqual(obs, exp)
+})

package/src/colors/rgbToHsl.d.ts

@@ -0,0 +1,8 @@
+import { HSL, HSLA, RGB, RGBA } from './types'
+
+export default rgbToHsl
+
+declare function rgbToHsl(rgb: RGB): HSL
+declare function rgbToHsl(rgb: RGBA): HSLA
+declare function rgbToHsl(...rgb: RGB): HSL
+declare function rgbToHsl(...rgb: RGBA): HSLA

package/src/colors/rgbToHsl.js

@@ -0,0 +1,53 @@
+const flatten = require('../utils/flatten')
+
+/**
+ * Converts an RGB color value to HSL.
+ *
+ * @see http://en.wikipedia.org/wiki/HSL_color_space.
+ * @see http://axonflux.com/handy-rgb-to-hsl-and-rgb-to-hsv-color-model-c
+ * @param {...Number|Array} values - RGB or RGBA color values
+ * @return {Array} HSL or HSLA color values
+ * @alias module:modeling/colors.rgbToHsl
+ */
+const rgbToHsl = (...values) => {
+  values = flatten(values)
+  if (values.length < 3) throw new Error('values must contain R, G and B values')
+
+  const r = values[0]
+  const g = values[1]
+  const b = values[2]
+
+  const max = Math.max(r, g, b)
+  const min = Math.min(r, g, b)
+  let h
+  let s
+  const l = (max + min) / 2
+
+  if (max === min) {
+    h = s = 0 // achromatic
+  } else {
+    const d = max - min
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0)
+        break
+      case g:
+        h = (b - r) / d + 2
+        break
+      case b:
+        h = (r - g) / d + 4
+        break
+    }
+    h /= 6
+  }
+
+  if (values.length > 3) {
+    // add alpha value if provided
+    const a = values[3]
+    return [h, s, l, a]
+  }
+  return [h, s, l]
+}
+
+module.exports = rgbToHsl

package/src/colors/rgbToHsl.test.js

@@ -0,0 +1,35 @@
+const test = require('ava')
+
+const { rgbToHsl } = require('./index')
+
+test('rgbToHsl', (t) => {
+  let obs = rgbToHsl([1, 0, 0.5])
+  let exp = [0.9166666666666666, 1, 0.5]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsl(0.5, 0.5, 0.5)
+  exp = [0, 0, 0.5]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsl([0.8, 0.7, 0.6])
+  exp = [0.08333333333333329, 0.3333333333333335, 0.7]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsl([0.7, 0.8, 0.6])
+  exp = [0.25000000000000006, 0.3333333333333335, 0.7]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsl([0.6, 0.7, 0.8])
+  exp = [0.5833333333333334, 0.3333333333333335, 0.7]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsl(0.6, 0.7, 0.8, 0.5)
+  exp = [0.5833333333333334, 0.3333333333333335, 0.7, 0.5]
+
+  t.deepEqual(obs, exp)
+})

package/src/colors/rgbToHsv.d.ts

@@ -0,0 +1,8 @@
+import { HSV, HSVA, RGB, RGBA } from './types'
+
+export default rgbToHsv
+
+declare function rgbToHsv(rgb: RGB): HSV
+declare function rgbToHsv(rgb: RGBA): HSVA
+declare function rgbToHsv(...rgb: RGB): HSV
+declare function rgbToHsv(...rgb: RGBA): HSVA

package/src/colors/rgbToHsv.js

@@ -0,0 +1,52 @@
+const flatten = require('../utils/flatten')
+
+/**
+ * Converts an RGB color value to HSV.
+ *
+ * @see http://en.wikipedia.org/wiki/HSV_color_space.
+ * @param {...Number|Array} values - RGB or RGBA color values
+ * @return {Array} HSV or HSVA color values
+ * @alias module:modeling/colors.rgbToHsv
+ */
+const rgbToHsv = (...values) => {
+  values = flatten(values)
+  if (values.length < 3) throw new Error('values must contain R, G and B values')
+
+  const r = values[0]
+  const g = values[1]
+  const b = values[2]
+
+  const max = Math.max(r, g, b)
+  const min = Math.min(r, g, b)
+  let h
+  const v = max
+
+  const d = max - min
+  const s = max === 0 ? 0 : d / max
+
+  if (max === min) {
+    h = 0 // achromatic
+  } else {
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0)
+        break
+      case g:
+        h = (b - r) / d + 2
+        break
+      case b:
+        h = (r - g) / d + 4
+        break
+    }
+    h /= 6
+  }
+
+  if (values.length > 3) {
+    // add alpha if provided
+    const a = values[3]
+    return [h, s, v, a]
+  }
+  return [h, s, v]
+}
+
+module.exports = rgbToHsv

package/src/colors/rgbToHsv.test.js

@@ -0,0 +1,40 @@
+const test = require('ava')
+
+const { rgbToHsv } = require('./index')
+
+test('rgbToHsv', (t) => {
+  let obs = rgbToHsv([1, 0, 0.5])
+  let exp = [0.9166666666666666, 1, 1]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsv(0.5, 0.5, 0.5)
+  exp = [0, 0, 0.5]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsv([0.8, 0.7, 0.6])
+  exp = [0.08333333333333329, 0.25000000000000006, 0.8]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsv([0.7, 0.8, 0.6])
+  exp = [0.25000000000000006, 0.25000000000000006, 0.8]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsv([0.6, 0.7, 0.8])
+  exp = [0.5833333333333334, 0.25000000000000006, 0.8]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsv(0.6, 0.7, 0.8, 0.5)
+  exp = [0.5833333333333334, 0.25000000000000006, 0.8, 0.5]
+
+  t.deepEqual(obs, exp)
+
+  obs = rgbToHsv([0, 0, 0, 0.5])
+  exp = [0, 0, 0, 0.5]
+
+  t.deepEqual(obs, exp)
+})

package/src/colors/types.d.ts

@@ -0,0 +1,6 @@
+export type RGB = [number, number, number]
+export type RGBA = [number, number, number, number]
+export type HSL = [number, number, number]
+export type HSLA = [number, number, number, number]
+export type HSV = [number, number, number]
+export type HSVA = [number, number, number, number]

package/src/connectors/create.js

@@ -0,0 +1,23 @@
+const vec3 = require('../maths/vec3')
+
+/**
+ * Create a new connector.
+ * A connector allows two objects to be connected at predefined positions.
+ *
+ * For example a servo motor and a servo horn can both have a connector called 'shaft'.
+ * The horn can be moved and rotated to any position, and then the servo horn
+ * is attached to the servo motor at the proper position, such that the two connectors match.
+ * Connectors are children of the solid, transform-wise, so transformations are applied
+ * to both solid and connector(s).  (parent => child relationship)
+ *
+ * @property {vec3} point - the position of the connector (relative to its parent)
+ * @property {vec3} axis - the direction (unit vector) of the connector
+ * @property {vec3} normal - the direction (unit vector) perpendicular to axis, that defines the "12 o'clock" orientation of the connector
+ * @alias module:modeling/connectors.create
+ *
+ * @example
+ * let myconnector = create()
+ */
+const create = () => ({ point: vec3.create(), axis: vec3.clone([0, 0, 1]), normal: vec3.clone([1, 0, 0]) })
+
+module.exports = create

package/src/connectors/create.test.js

@@ -0,0 +1,17 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+const { compareVectors } = require('../../test/helpers')
+
+test('connector: create() should return a connector with initial values', (t) => {
+  const obs = create()
+
+  const point = [0, 0, 0]
+  const axis = [0, 0, 1]
+  const normal = [1, 0, 0]
+
+  t.true(compareVectors(obs.point, point))
+  t.true(compareVectors(obs.axis, axis))
+  t.true(compareVectors(obs.normal, normal))
+})

package/src/connectors/extends.js

@@ -0,0 +1,15 @@
+const vec3 = require('../maths/vec3')
+const fromPointAxisNormal = require('./fromPointAxisNormal')
+
+/*
+ * Creates a new connector, with the connection point moved in the direction of the axis
+ * @param {Number} distance the distance to extend the connector to
+ * @param {connector} connector the connector to extend
+ * @returns {connector} a normalized connector
+ */
+const extend = (distance, connector) => {
+  const newpoint = vec3.add(connector.point, vec3.scale(distance, vec3.normalize(connector.axis)))
+  return fromPointAxisNormal(newpoint, connector.axis, connector.normal)
+}
+
+module.exports = extend

package/src/connectors/fromPointAxisNormal.js

@@ -0,0 +1,21 @@
+const vec3 = require('../maths/vec3')
+
+const create = require('./create')
+
+/**
+ * Create a connector from the given point, axis and normal.
+ * @param {vec3} point - the point of the connector, relative to the parent geometry
+ * @param {vec3} axis - the axis (directional vector) of the connector
+ * @param {vec3} normal - the normal (directional vector) of the connector, perpendicular to the axis
+ * @returns {connector} a new connector
+ * @alias module:modeling/connectors.fromPointsAxisNormal
+ */
+const fromPointAxisNormal = (point, axis, normal) => {
+  const connector = create()
+  connector.point = vec3.clone(point)
+  connector.axis = vec3.normalize(vec3.create(), axis)
+  connector.normal = vec3.normalize(vec3.create(), normal)
+  return connector
+}
+
+module.exports = fromPointAxisNormal

package/src/connectors/fromPointAxisNormal.test.js

@@ -0,0 +1,22 @@
+const test = require('ava')
+
+const { fromPointAxisNormal } = require('./index')
+
+const { compareVectors } = require('../../test/helpers/')
+
+test('connector: fromPointAxisNormal() should return a new connector with correct values', (t) => {
+  let obs = fromPointAxisNormal([0, 0, 0], [1, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs.point, [0, 0, 0]))
+  t.true(compareVectors(obs.axis, [1, 0, 0]))
+  t.true(compareVectors(obs.normal, [0, 1, 0]))
+
+  obs = fromPointAxisNormal([0, 0, 0], [0, 2, 0], [0, 0, 4])
+  t.true(compareVectors(obs.point, [0, 0, 0]))
+  t.true(compareVectors(obs.axis, [0, 1, 0]))
+  t.true(compareVectors(obs.normal, [0, 0, 1]))
+
+  obs = fromPointAxisNormal([5, 5, 5], [0, 0, 10], [0, 10, 5])
+  t.true(compareVectors(obs.point, [5, 5, 5]))
+  t.true(compareVectors(obs.axis, [0, 0, 1]))
+  t.true(compareVectors(obs.normal, [0, 0.8944271909999159, 0.4472135954999579]))
+})

package/src/connectors/index.js

@@ -0,0 +1,12 @@
+/**
+ * @module modeling/connectors
+ */
+module.exports = {
+  create: require('./create'),
+  // extends: require('./extends'),
+  fromPointAxisNormal: require('./fromPointAxisNormal'),
+  // normalize: require('./normalize'),
+  toString: require('./toString'),
+  transform: require('./transform'),
+  transformationBetween: require('./transformationBetween')
+}

package/src/connectors/normalize.js

@@ -0,0 +1,20 @@
+const vec3 = require('../maths/vec3')
+
+const fromPointAxisNormal = require('./fromPointAxisNormal')
+
+/*
+ * Normalize the given connector, calculating new axis and normal
+ * @param {connector} connector - the connector to normalize
+ * @returns {connector} a new connector
+ */
+const normalize = (connector) => {
+  const newaxis = vec3.normalize(connector.axis)
+
+  // make the normal vector truly normal
+  const newnormal = vec3.normalize(vec3.cross(connector.normal, connector.axis))
+  vec3.cross(newnormal, newaxis, newnormal)
+
+  return fromPointAxisNormal(connector.point, newaxis, newnormal)
+}
+
+module.exports = normalize

package/src/connectors/toString.js

@@ -0,0 +1,15 @@
+/**
+ * Return a string representing the given connector.
+ *
+ * @param {connector} connector - the connector of reference
+ * @returns {string} string representation
+ * @alias module:modeling/connectors.toString
+ */
+const toString = (connector) => {
+  const point = connector.point
+  const axis = connector.axis
+  const normal = connector.normal
+  return `connector: point: [${point[0].toFixed(7)}, ${point[1].toFixed(7)}, ${point[2].toFixed(7)}],  axis: [${axis[0].toFixed(7)}, ${axis[1].toFixed(7)}, ${axis[2].toFixed(7)}], normal: [${normal[0].toFixed(7)}, ${normal[1].toFixed(7)}, ${normal[2].toFixed(7)}]`
+}
+
+module.exports = toString