primitive 1.0.0 → 1.2.1

package/lib/optimize.js

@@ -1,53 +0,0 @@
-import State from './state'
-
-export const hillClimb = (state, maxAge) => {
-  let bestState = state
-  let bestEnergy = state.energy()
-
-  for (let age = 0; age < maxAge; ++age) {
-    const newState = bestState.mutate()
-    const newEnergy = newState.energy()
-
-    if (newEnergy < bestEnergy) {
-      bestEnergy = newEnergy
-      bestState = newState
-      age = -1
-    }
-  }
-
-  return bestState
-}
-
-export const getBestHillClimbState = (worker, opts) => {
-  const state = getBestRandomState(worker, opts)
-  return hillClimb(state, opts.numCandidateMutations)
-}
-
-export const getBestRandomState = (worker, opts) => {
-  const {
-    numCandidateShapes,
-    shapeType,
-    shapeAlpha
-  } = opts
-
-  let bestEnergy = null
-  let bestState = null
-
-  for (let i = 0; i < numCandidateShapes; ++i) {
-    const state = State.create(worker, shapeType, shapeAlpha)
-    const energy = state.energy()
-
-    if (!i || energy < bestEnergy) {
-      bestEnergy = energy
-      bestState = state
-    }
-  }
-
-  return bestState
-}
-
-export default {
-  hillClimb,
-  getBestHillClimbState,
-  getBestRandomState
-}

package/lib/primitive.js

@@ -1,76 +0,0 @@
-import ow from 'ow'
-
-import core from './core'
-import Model from './model'
-
-const noop = () => { }
-
-export default async (opts) => {
-  const {
-    context,
-    target,
-    onStep,
-
-    // inputSize = undefined, // TODO: support resizing target
-    outputSize = undefined,
-
-    minEnergy = undefined,
-
-    shapeAlpha = 128,
-    shapeType = 'triangle',
-
-    numCandidates = 1, // [ 1, 32 ]
-    numCandidateShapes = 50, // [ 10, 300 ]
-    numCandidateMutations = 100, // [ 10, 500 ]
-    numCandidateExtras = 0, // [ 0, 16 ]
-
-    log = noop
-  } = opts
-
-  // validate options
-  ow(opts, ow.object.plain.label('opts'))
-  ow(target, ow.object.label('target'))
-  ow(target.width, ow.number.positive.integer.label('target.width'))
-  ow(target.height, ow.number.positive.integer.label('target.height'))
-  ow(target.data, ow.any(ow.uint8Array, ow.uint8ClampedArray))
-  ow(shapeAlpha, ow.number.integer.greaterThanOrEqual(0).lessThanOrEqual(255).label('shapeAlpha'))
-  ow(shapeType, ow.string.nonEmpty.label('shapeType'))
-  ow(numCandidates, ow.number.integer.positive.label('numCandidates'))
-  ow(numCandidateShapes, ow.number.integer.positive.label('numCandidateShapes'))
-  ow(numCandidateMutations, ow.number.integer.positive.label('numCandidateMutations'))
-  ow(log, ow.function.label('log'))
-  ow(onStep, ow.function.label('onStep'))
-
-  const backgroundColor = core.getMeanColor(target)
-
-  const model = new Model({
-    context,
-    target,
-    backgroundColor,
-    outputSize,
-    numCandidates
-  })
-
-  const step = async (index) => {
-    await onStep(model, step)
-
-    const candidates = model.step({
-      shapeType,
-      shapeAlpha,
-      numCandidateShapes,
-      numCandidateMutations,
-      numCandidateExtras
-    })
-
-    if (minEnergy && model.score <= minEnergy) {
-      return false
-    }
-
-    return candidates
-  }
-
-  return {
-    model,
-    step
-  }
-}

package/lib/rasterize.js

@@ -1,101 +0,0 @@
-import Scanline from './scanline'
-
-/**
- * Converts a polygon to an array of rasterizable scanlines.
- *
- * @param {Array<Object>} points
- * @return {Array<Scanline>}
- */
-export default (points) => {
-  const lines = []
-  let edges = []
-
-  for (let i = 0; i < points.length; ++i) {
-    const p1 = points[i]
-    const p2 = (i >= points.length - 1 ? points[0] : points[i + 1])
-    const p1p2 = bresenham(p1.x | 0, p1.y | 0, p2.x | 0, p2.y | 0)
-    edges = edges.concat(p1p2)
-  }
-
-  const yToXs = new Map()
-  for (let i = 0; i < edges.length; ++i) {
-    const point = edges[i]
-    let xSet = yToXs.get(point.y)
-
-    if (xSet) {
-      xSet.add(point.x)
-    } else {
-      xSet = new Set()
-      xSet.add(point.x)
-      yToXs.set(point.y, xSet)
-    }
-  }
-
-  yToXs.forEach((xSet, y) => {
-    const minMax = minMaxElements(xSet)
-
-    if (minMax) {
-      lines.push(new Scanline(y, minMax.min, minMax.max))
-    }
-  })
-
-  return lines
-}
-
-function bresenham (x1, y1, x2, y2) {
-  const points = []
-
-  let dx = x2 - x1
-  const ix = Math.sign(dx)
-  dx = Math.abs(dx) * 2
-
-  let dy = y2 - y1
-  const iy = Math.sign(dy)
-  dy = Math.abs(dy) * 2
-
-  points.push({ x: x1, y: y1 })
-
-  if (dx >= dy) {
-    let error = (dy - (dx >> 1))
-
-    while (x1 !== x2) {
-      if (error >= 0 && (error !== 0 || ix > 0)) {
-        error -= dx
-        y1 += iy
-      }
-
-      error += dy
-      x1 += ix
-      points.push({ x: x1, y: y1 })
-    }
-  } else {
-    let error = (dx - (dy >> 1))
-
-    while (y1 !== y2) {
-      if (error >= 0 && (error !== 0 || iy > 0)) {
-        error -= dy
-        x1 += ix
-      }
-
-      error += dx
-      y1 += iy
-      points.push({ x: x1, y: y1 })
-    }
-  }
-
-  return points
-}
-
-function minMaxElements (iterable) {
-  let min = null
-  let max = null
-
-  for (let v of iterable) {
-    if (!min || v < min) min = v
-    if (!max || v > max) max = v
-  }
-
-  if (min !== null && max !== null) {
-    return { min, max }
-  }
-}

package/lib/scanline.js

@@ -1,25 +0,0 @@
-export default class Scanline {
-  constructor (y, x1, x2) {
-    if (x1 > x2) {
-      let t = x1
-      x1 = x2
-      x2 = t
-    }
-
-    this.y = y | 0
-    this.x1 = x1 | 0
-    this.x2 = x2 | 0
-  }
-
-  static filter (lines, width, height) {
-    return lines.filter((line) => {
-      if (line.y < 0 || line.y >= height) return false
-      if (line.x1 >= width || line.x2 < 0) return false
-
-      line.x1 = Math.max(0, Math.min(width - 1, line.x1))
-      line.x2 = Math.max(0, Math.min(width - 1, line.x2))
-
-      return (line.x1 < line.x2)
-    })
-  }
-}

package/lib/shapes/ellipse.js

@@ -1,112 +0,0 @@
-import randomInt from 'random-int'
-import randomNormal from 'random-normal'
-
-import Scanline from '../scanline'
-import Shape from './shape'
-
-export default class Ellipse extends Shape {
-  constructor (opts) {
-    super(opts)
-    if (!opts) return
-
-    this.circle = !!opts.circle
-    this.x = randomInt(0, this.width - 1)
-    this.y = randomInt(0, this.height - 1)
-
-    this.rx = randomInt(1, 32)
-    this.ry = this.circle
-      ? this.rx
-      : randomInt(1, 32)
-  }
-
-  copy () {
-    const shape = new Ellipse()
-    shape.width = this.width
-    shape.height = this.height
-    shape.circle = this.circle
-    shape.x = this.x
-    shape.y = this.y
-    shape.rx = this.rx
-    shape.ry = this.ry
-    return shape
-  }
-
-  bounds () {
-    let { x1, y1, x2, y2 } = this
-    let t
-
-    if (x1 > x2) {
-      t = x1
-      x1 = x2
-      x2 = t
-    }
-
-    if (y1 > y2) {
-      t = y1
-      y1 = y2
-      y2 = t
-    }
-
-    return { x1, y1, x2, y2 }
-  }
-
-  mutate () {
-    const { width, height } = this
-    const shape = this.copy()
-    const m = 16
-
-    switch (randomInt(0, 2)) {
-      case 0:
-        shape.x = Math.max(0, Math.min(width - 1, (shape.x + randomNormal() * m)))
-        shape.y = Math.max(0, Math.min(height - 1, (shape.y + randomNormal() * m)))
-        break
-
-      case 1:
-        shape.rx = Math.max(1, Math.min(width - 1, (shape.rx + randomNormal() * m)))
-        if (shape.circle) shape.ry = shape.rx
-        break
-
-      case 2:
-        shape.ry = Math.max(1, Math.min(height - 1, (shape.ry + randomNormal() * m)))
-        if (shape.circle) shape.rx = shape.ry
-        break
-    }
-
-    return shape
-  }
-
-  rasterize () {
-    const { width, height, x, y, rx, ry } = this
-    const lines = []
-    const aspect = rx / ry
-
-    for (let dy = 0; dy < ry; ++dy) {
-      const y1 = y - dy
-      const y2 = y + dy
-
-      if ((y1 < 0 || y1 >= height) && (y2 < 0 || y2 >= height)) {
-        continue
-      }
-
-      const s = Math.sqrt(ry * ry - dy * dy) * aspect
-      const x1 = Math.max(0, x - s)
-      const x2 = Math.min(width - 1, x + s)
-
-      if (y1 >= 0 && y1 < height) {
-        lines.push(new Scanline(y1, x1, x2))
-      }
-
-      if (y2 >= 0 && y2 < height && dy > 0) {
-        lines.push(new Scanline(y2, x1, x2))
-      }
-    }
-
-    return lines
-  }
-
-  toSVG (attrs = '') {
-    return (
-      `<ellipse ${attrs} cx="${this.x}" cy="${this.y}" rx="${this.rx}" ry="${this.ry}" />`
-    )
-  }
-}

package/lib/shapes/factory.js

@@ -1,52 +0,0 @@
-import randomInt from 'random-int'
-
-import Ellipse from './ellipse'
-import Rectangle from './rectangle'
-import RotatedEllipse from './rotated-ellipse'
-import RotatedRectangle from './rotated-rectangle'
-import Triangle from './triangle'
-
-const SHAPES = [
-  // ellipse and rectangle are redundant with their rotated versions
-  // 'ellipse',
-  // 'rectangle',
-  'rotated-ellipse',
-  'rotated-rectangle',
-  'triangle'
-]
-
-const factory = (shapeType, opts) => {
-  switch (shapeType) {
-    case 'rectangle':
-    case 'rect':
-      return new Rectangle(opts)
-
-    case 'rotated-rectangle':
-    case 'rotated-rect':
-      return new RotatedRectangle(opts)
-
-    case 'circle':
-      return new Ellipse({
-        circle: true,
-        ...opts
-      })
-
-    case 'ellipse':
-      return new Ellipse(opts)
-
-    case 'rotated-ellipse':
-      return new RotatedEllipse(opts)
-
-    case 'triangle':
-      return new Triangle(opts)
-
-    default:
-      return factory(random(), opts)
-  }
-}
-
-function random () {
-  return SHAPES[randomInt(SHAPES.length)]
-}
-
-export default factory

package/lib/shapes/rectangle.js

@@ -1,93 +0,0 @@
-import randomInt from 'random-int'
-import randomNormal from 'random-normal'
-
-import Scanline from '../scanline'
-import Shape from './shape'
-
-export default class Rectangle extends Shape {
-  constructor (opts) {
-    super(opts)
-    if (!opts) return
-
-    this.x1 = randomInt(0, this.width - 1)
-    this.y1 = randomInt(0, this.height - 1)
-
-    this.x2 = Math.max(0, Math.min(this.width - 1, this.x1 + randomInt(-16, 16)))
-    this.y2 = Math.max(0, Math.min(this.height - 1, this.y1 + randomInt(-16, 16)))
-  }
-
-  copy () {
-    const shape = new Rectangle()
-    shape.width = this.width
-    shape.height = this.height
-    shape.x1 = this.x1
-    shape.y1 = this.y1
-    shape.x2 = this.x2
-    shape.y2 = this.y2
-    return shape
-  }
-
-  bounds () {
-    let { x1, y1, x2, y2 } = this
-    let t
-
-    if (x1 > x2) {
-      t = x1
-      x1 = x2
-      x2 = t
-    }
-
-    if (y1 > y2) {
-      t = y1
-      y1 = y2
-      y2 = t
-    }
-
-    return { x1, y1, x2, y2 }
-  }
-
-  mutate () {
-    const { width, height } = this
-    const shape = this.copy()
-    const m = 16
-
-    switch (randomInt(0, 1)) {
-      case 0:
-        shape.x1 = Math.max(0, Math.min(width - 1, (shape.x1 + randomNormal() * m)))
-        shape.y1 = Math.max(0, Math.min(height - 1, (shape.y1 + randomNormal() * m)))
-        break
-
-      case 1:
-        shape.x2 = Math.max(0, Math.min(width - 1, (shape.x2 + randomNormal() * m)))
-        shape.y2 = Math.max(0, Math.min(height - 1, (shape.y2 + randomNormal() * m)))
-        break
-    }
-
-    return shape
-  }
-
-  rasterize () {
-    const { x1, y1, x2, y2 } = this.bounds()
-    const lines = []
-
-    for (let y = y1; y <= y2; ++y) {
-      lines.push(new Scanline(y, x1, x2))
-    }
-
-    return lines
-  }
-
-  draw (ctx) {
-    // TODO
-  }
-
-  toSVG (attrs = '') {
-    const { x1, y1, x2, y2 } = this.bounds()
-    const w = x2 - x1 + 1
-    const h = y2 - y1 + 1
-
-    return (
-      `<rect ${attrs} x="${x1}" y="${y1}" width="${w}" height="${h}" />`
-    )
-  }
-}

package/lib/shapes/rotated-ellipse.js

@@ -1,99 +0,0 @@
-import randomInt from 'random-int'
-import randomNormal from 'random-normal'
-
-import rasterize from '../rasterize'
-import Scanline from '../scanline'
-import Shape from './shape'
-
-export default class RotatedEllipse extends Shape {
-  constructor (opts) {
-    super(opts)
-    if (!opts) return
-
-    this.x = randomInt(0, this.width - 1)
-    this.y = randomInt(0, this.height - 1)
-
-    this.rx = randomInt(1, 32)
-    this.ry = randomInt(1, 32)
-
-    this.angle = Math.random() * 360
-  }
-
-  copy () {
-    const shape = new RotatedEllipse()
-    shape.width = this.width
-    shape.height = this.height
-    shape.x = this.x
-    shape.y = this.y
-    shape.rx = this.rx
-    shape.ry = this.ry
-    shape.angle = this.angle
-    return shape
-  }
-
-  mutate () {
-    const { width, height } = this
-    const shape = this.copy()
-    const m = 16
-
-    switch (randomInt(0, 2)) {
-      case 0:
-        shape.x = Math.max(0, Math.min(width - 1, (shape.x + randomNormal() * m)))
-        shape.y = Math.max(0, Math.min(height - 1, (shape.y + randomNormal() * m)))
-        break
-
-      case 1:
-        shape.rx = Math.max(1, Math.min(width - 1, (shape.rx + randomNormal() * m)))
-        shape.ry = Math.max(1, Math.min(height - 1, (shape.ry + randomNormal() * m)))
-        break
-
-      case 2:
-        shape.angle = shape.angle + randomNormal() * m
-        break
-    }
-
-    return shape
-  }
-
-  rasterize () {
-    const points = this.getPoints()
-    const lines = rasterize(points)
-    return Scanline.filter(lines, this.width, this.height)
-  }
-
-  getPoints (numPoints = 20) {
-    const { x, y, rx, ry, angle } = this
-    const points = []
-    const rads = angle * Math.PI / 180.0
-    const c = Math.cos(rads)
-    const s = Math.sin(rads)
-
-    for (let i = 0; i < numPoints; ++i) {
-      const rot = ((360.0 / numPoints) * i) * (Math.PI / 180.0)
-      const crx = rx * Math.cos(rot)
-      const cry = ry * Math.sin(rot)
-
-      const tx = (crx * c - cry * s + x) | 0
-      const ty = (crx * s + cry * c + y) | 0
-
-      points.push({ x: tx, y: ty })
-    }
-
-    return points
-  }
-
-  draw (ctx) {
-    throw new Error('TODO')
-  }
-
-  toSVG (attrs = '') {
-    // TODO: native rotated ellipse will produce smaller and smoother results
-    const points = this.getPoints()
-      .map((point) => `${point.x} ${point.y}`)
-      .join(' ')
-
-    return (
-      `<polygon ${attrs} points="${points}" />`
-    )
-  }
-}