primitive 1.0.1 → 1.2.1

package/lib/shapes/rotated-rectangle.js

@@ -1,125 +0,0 @@
-import random, { normal } from '../random'
-
-import rasterize from '../rasterize'
-import Scanline from '../scanline'
-import Shape from './shape'
-
-export default class RotatedRectangle extends Shape {
-  constructor (opts) {
-    super(opts)
-    if (!opts) return
-
-    this.x1 = random.int(0, this.width - 1)
-    this.y1 = random.int(0, this.height - 1)
-
-    this.x2 = Math.max(0, Math.min(this.width - 1, this.x1 + random.int(-16, 16)))
-    this.y2 = Math.max(0, Math.min(this.height - 1, this.y1 + random.int(-16, 16)))
-
-    this.angle = random.float() * 360
-  }
-
-  copy () {
-    const shape = new RotatedRectangle()
-    shape.width = this.width
-    shape.height = this.height
-    shape.x1 = this.x1
-    shape.y1 = this.y1
-    shape.x2 = this.x2
-    shape.y2 = this.y2
-    shape.angle = this.angle
-    return shape
-  }
-
-  mutate () {
-    const { width, height } = this
-    const shape = this.copy()
-    const m = 16
-
-    switch (random.int(0, 2)) {
-      case 0:
-        shape.x1 = Math.max(0, Math.min(width - 1, shape.x1 + normal() * m))
-        shape.y1 = Math.max(0, Math.min(height - 1, shape.y1 + normal() * m))
-        break
-
-      case 1:
-        shape.x2 = Math.max(0, Math.min(width - 1, shape.x2 + normal() * m))
-        shape.y2 = Math.max(0, Math.min(height - 1, shape.y2 + normal() * m))
-        break
-
-      case 2:
-        shape.angle = shape.angle + normal() * m
-        break
-    }
-
-    return shape
-  }
-
-  rasterize () {
-    const points = this.getPoints()
-    const lines = rasterize(points)
-    return Scanline.filter(lines, this.width, this.height)
-  }
-
-  getPoints () {
-    const { x1, y1, x2, y2, angle } = this
-
-    const xm1 = Math.min(x1, x2)
-    const xm2 = Math.max(x1, x2)
-    const ym1 = Math.min(y1, y2)
-    const ym2 = Math.max(y1, y2)
-
-    const cx = (xm1 + xm2) / 2
-    const cy = (ym1 + ym2) / 2
-
-    const ox1 = xm1 - cx
-    const ox2 = xm2 - cx
-    const oy1 = ym1 - cy
-    const oy2 = ym2 - cy
-
-    const rads = angle * Math.PI / 180.0
-    const c = Math.cos(rads)
-    const s = Math.sin(rads)
-
-    const ulx = (ox1 * c - oy1 * s + cx) | 0
-    const uly = (ox1 * s + oy1 * c + cy) | 0
-    const blx = (ox1 * c - oy2 * s + cx) | 0
-    const bly = (ox1 * s + oy2 * c + cy) | 0
-    const urx = (ox2 * c - oy1 * s + cx) | 0
-    const ury = (ox2 * s + oy1 * c + cy) | 0
-    const brx = (ox2 * c - oy2 * s + cx) | 0
-    const bry = (ox2 * s + oy2 * c + cy) | 0
-
-    return [
-      {
-        x: ulx,
-        y: uly
-      },
-      {
-        x: urx,
-        y: ury
-      },
-      {
-        x: brx,
-        y: bry
-      },
-      {
-        x: blx,
-        y: bly
-      }
-    ]
-  }
-
-  draw (ctx) {
-    throw new Error('TODO')
-  }
-
-  toSVG (attrs = '') {
-    const points = this.getPoints()
-      .map((point) => `${point.x} ${point.y}`)
-      .join(' ')
-
-    return (
-      `<polygon ${attrs} points="${points}" />`
-    )
-  }
-}

package/lib/shapes/shape.js

@@ -1,26 +0,0 @@
-export default class Shape {
-  constructor (opts = { }) {
-    this.width = opts.width
-    this.height = opts.height
-  }
-
-  copy () {
-    throw new Error('TODO')
-  }
-
-  mutate () {
-    throw new Error('TODO')
-  }
-
-  rasterize () {
-    throw new Error('TODO')
-  }
-
-  draw (ctx, scale) {
-    throw new Error('TODO')
-  }
-
-  toSVG () {
-    throw new Error('TODO')
-  }
-}

package/lib/shapes/triangle.js

@@ -1,216 +0,0 @@
-import random, { normal } from '../random'
-
-import Scanline from '../scanline'
-import Shape from './shape'
-
-export default class Triangle extends Shape {
-  constructor (opts) {
-    super(opts)
-    if (!opts) return
-
-    do {
-      this.x1 = random.int(0, this.width - 1)
-      this.y1 = random.int(0, this.height - 1)
-
-      this.x2 = this.x1 + random.int(-15, 15)
-      this.y2 = this.y1 + random.int(-15, 15)
-
-      this.x3 = this.x1 + random.int(-15, 15)
-      this.y3 = this.y1 + random.int(-15, 15)
-    } while (!this.isValid())
-  }
-
-  copy () {
-    const shape = new Triangle()
-    shape.width = this.width
-    shape.height = this.height
-    shape.x1 = this.x1
-    shape.y1 = this.y1
-    shape.x2 = this.x2
-    shape.y2 = this.y2
-    shape.x3 = this.x3
-    shape.y3 = this.y3
-    return shape
-  }
-
-  mutate () {
-    const { width, height } = this
-    const m = 16
-    let shape = this.copy()
-    let n = 0
-
-    while (true) {
-      switch (random.int(0, 2)) {
-        case 0:
-          shape.x1 = Math.max(-m, Math.min(width - 1 + m, (shape.x1 + normal() * m)))
-          shape.y1 = Math.max(-m, Math.min(height - 1 + m, (shape.y1 + normal() * m)))
-          break
-
-        case 1:
-          shape.x2 = Math.max(-m, Math.min(width - 1 + m, (shape.x2 + normal() * m)))
-          shape.y2 = Math.max(-m, Math.min(height - 1 + m, (shape.y2 + normal() * m)))
-          break
-
-        case 2:
-          shape.x3 = Math.max(-m, Math.min(width - 1 + m, (shape.x3 + normal() * m)))
-          shape.y3 = Math.max(-m, Math.min(height - 1 + m, (shape.y3 + normal() * m)))
-          break
-      }
-
-      if (shape.isValid()) {
-        return shape
-      }
-
-      if (++n > 128) {
-        shape = this.copy()
-        n = 0
-      }
-    }
-  }
-
-  isValid () {
-    const minDegrees = 15
-
-    let a1, a2, a3
-    {
-      let x1 = (this.x2 - this.x1)
-      let y1 = (this.y2 - this.y1)
-      let x2 = (this.x3 - this.x1)
-      let y2 = (this.y3 - this.y1)
-      const d1 = Math.sqrt(x1 * x1 + y1 * y1)
-      const d2 = Math.sqrt(x2 * x2 + y2 * y2)
-      x1 /= d1
-      y1 /= d1
-      x2 /= d2
-      y2 /= d2
-      a1 = degrees(Math.acos(x1 * x2 + y1 * y2))
-    }
-
-    {
-      let x1 = (this.x1 - this.x2)
-      let y1 = (this.y1 - this.y2)
-      let x2 = (this.x3 - this.x2)
-      let y2 = (this.y3 - this.y2)
-      const d1 = Math.sqrt(x1 * x1 + y1 * y1)
-      const d2 = Math.sqrt(x2 * x2 + y2 * y2)
-      x1 /= d1
-      y1 /= d1
-      x2 /= d2
-      y2 /= d2
-      a2 = degrees(Math.acos(x1 * x2 + y1 * y2))
-    }
-
-    a3 = 180 - a1 - a2
-    return a1 > minDegrees && a2 > minDegrees && a3 > minDegrees
-  }
-
-  rasterize () {
-    const { width, height } = this
-    const lines = rasterize(this.x1, this.y1, this.x2, this.y2, this.x3, this.y3)
-    return Scanline.filter(lines, width, height)
-  }
-
-  draw (ctx) {
-    ctx.beginPath()
-    ctx.moveTo(this.x1, this.y1)
-    ctx.lineTo(this.x2, this.y2)
-    ctx.lineTo(this.x3, this.y3)
-    ctx.fill()
-  }
-
-  toSVG (attrs = '') {
-    return (
-      `<polygon ${attrs} points="${this.x1},${this.y1} ${this.x2},${this.y2} ${this.x3},${this.y3}" />`
-    )
-  }
-}
-
-function degrees (radians) {
-  return 180 * radians / Math.PI
-}
-
-function rasterize (x1, y1, x2, y2, x3, y3) {
-  let t
-
-  if (y1 > y3) {
-    t = x1
-    x1 = x3
-    x3 = t
-
-    t = y1
-    y1 = y3
-    y3 = t
-  }
-
-  if (y1 > y2) {
-    t = x1
-    x1 = x2
-    x2 = t
-
-    t = y1
-    y1 = y2
-    y2 = t
-  }
-
-  if (y2 > y3) {
-    t = x2
-    x2 = x3
-    x3 = t
-
-    t = y2
-    y2 = y3
-    y3 = t
-  }
-
-  if (y2 === y3) {
-    return rasterizeBottom(x1, y1, x2, y2, x3, y3)
-  } else if (y1 === y2) {
-    return rasterizeTop(x1, y1, x2, y2, x3, y3)
-  } else {
-    const x4 = x1 + (((y2 - y1) / (y3 - y1)) * (x3 - x1)) | 0
-    const y4 = y2
-
-    return []
-      .concat(rasterizeBottom(x1, y1, x2, y2, x4, y4))
-      .concat(rasterizeTop(x2, y2, x4, y4, x3, y3))
-  }
-}
-
-function rasterizeBottom (x1, y1, x2, y2, x3, y3) {
-  const lines = []
-
-  const s1 = (x2 - x1) / (y2 - y1)
-  const s2 = (x3 - x1) / (y3 - y1)
-  let ax = x1
-  let bx = x1
-
-  for (let y = y1; y <= y2; ++y) {
-    const a = ax
-    const b = bx
-
-    ax += s1
-    bx += s2
-
-    lines.push(new Scanline(y, a, b))
-  }
-
-  return lines
-}
-
-function rasterizeTop (x1, y1, x2, y2, x3, y3) {
-  const lines = []
-
-  const s1 = (x3 - x1) / (y3 - y1)
-  const s2 = (x3 - x2) / (y3 - y2)
-  let ax = x3
-  let bx = x3
-
-  for (let y = y3; y >= y1; y--) {
-    ax -= s1
-    bx -= s2
-
-    lines.push(new Scanline(y, ax, bx))
-  }
-
-  return lines
-}

package/lib/shapes/triangle.test.js

@@ -1,73 +0,0 @@
-import test from 'ava'
-
-import context from '../context'
-// import core from '../core'
-import Triangle from './triangle'
-
-test('new Triangle()', async (t) => {
-  const image = context.createImage(512, 512)
-
-  for (let i = 0; i < 10000; ++i) {
-    const shape = new Triangle(image)
-
-    t.true(shape.x1 >= -16)
-    t.true(shape.x1 < 512 + 16)
-    t.true(shape.y1 >= -16)
-    t.true(shape.y1 < 512 + 16)
-
-    t.true(shape.x2 >= -16)
-    t.true(shape.x2 < 512 + 16)
-    t.true(shape.y2 >= -16)
-    t.true(shape.y2 < 512 + 16)
-
-    t.true(shape.x3 >= -16)
-    t.true(shape.x3 < 512 + 16)
-    t.true(shape.y3 >= -16)
-    t.true(shape.y3 < 512 + 16)
-
-    t.true(shape.isValid())
-
-    const shape2 = shape.copy()
-    t.deepEqual(shape, shape2)
-  }
-})
-
-test('Triangle.mutate', async (t) => {
-  const image = context.createImage(512, 512)
-
-  for (let i = 0; i < 10000; ++i) {
-    const base = new Triangle(image)
-    Object.freeze(base)
-    const shape = base.mutate()
-
-    t.is(base.width, shape.width)
-    t.is(base.height, shape.height)
-
-    t.true(shape.x1 >= -16)
-    t.true(shape.x1 < 512 + 16)
-    t.true(shape.y1 >= -16)
-    t.true(shape.y1 < 512 + 16)
-
-    t.true(shape.x2 >= -16)
-    t.true(shape.x2 < 512 + 16)
-    t.true(shape.y2 >= -16)
-    t.true(shape.y2 < 512 + 16)
-
-    t.true(shape.x3 >= -16)
-    t.true(shape.x3 < 512 + 16)
-    t.true(shape.y3 >= -16)
-    t.true(shape.y3 < 512 + 16)
-
-    t.true(shape.isValid())
-
-    /*
-    let s = shape
-    for (let j = 0; j < 5000; ++j) {
-      s = s.mutate()
-      const lines = s.rasterize()
-      core.drawLines(image, { r: 255, g: 0, b: 0, a: 128 }, lines)
-      await context.saveImage(image, `${j}.png`)
-    }
-    */
-  }
-})

package/lib/state.js

@@ -1,69 +0,0 @@
-'use strict'
-
-import randomInt from 'random-int'
-import shapeFactory from './shapes/factory'
-
-export default class State {
-  constructor (opts) {
-    if (!opts) return
-
-    const {
-      worker,
-      shape,
-      alpha
-    } = opts
-
-    this.worker = worker
-    this.shape = shape
-    this.score = -1
-
-    if (!alpha) {
-      this.alpha = 128
-      this.mutateAlpha = true
-    } else {
-      this.alpha = alpha
-      this.mutateAlpha = false
-    }
-  }
-
-  copy () {
-    const state = new State()
-    state.worker = this.worker
-    state.shape = this.shape // .copy()
-    state.score = this.score
-    state.alpha = this.alpha
-    state.mutateAlpha = this.mutateAlpha
-    return state
-  }
-
-  energy () {
-    if (this.score < 0) {
-      this.score = this.worker.energy(this.shape, this.alpha)
-    }
-
-    return this.score
-  }
-
-  mutate () {
-    const state = this.copy()
-    state.shape = state.shape.mutate()
-    if (state.mutateAlpha) {
-      state.alpha = Math.max(1, Math.min(255, (state.alpha + randomInt(-10, 10)) | 0))
-    }
-    state.score = -1
-    return state
-  }
-
-  static create (worker, shapeType, alpha) {
-    const shape = shapeFactory(shapeType, {
-      width: worker.width,
-      height: worker.height
-    })
-
-    return new State({
-      worker,
-      shape,
-      alpha
-    })
-  }
-}

package/lib/worker.js

@@ -1,50 +0,0 @@
-'use strict'
-
-import core from './core'
-
-export default class Worker {
-  constructor (opts) {
-    const {
-      context,
-      target
-    } = opts
-
-    this.context = context
-    this.target = target
-    this.width = target.width
-    this.height = target.height
-
-    this.counter = 0
-    this.current = null
-    this.score = 0
-
-    this.buffer = context.createImage(this.width, this.height)
-  }
-
-  init (current, score) {
-    this.current = current
-    this.score = score
-    this.counter = 0
-  }
-
-  energy (shape, alpha) {
-    this.counter++
-
-    const lines = shape.rasterize()
-    const color = core.computeColor(this.target, this.current, lines, alpha)
-    let score
-
-    if (this.context.PARTIALS) {
-      core.copyLines(this.buffer, this.current, lines)
-      core.drawLines(this.buffer, color, lines)
-      score = core.differencePartial(this.target, this.current, this.buffer, this.score, lines)
-    } else {
-      this.buffer.data.set(this.current.data)
-      core.drawLines(this.buffer, color, lines)
-      score = core.difference(this.target, this.buffer)
-    }
-
-    // console.log('worker.energy', this.counter, score)
-    return score
-  }
-}

package/main.js

@@ -1,6 +0,0 @@
-'use strict'
-
-// node commonjs entrypoint
-
-const _require = require('esm')(module) // eslint-disable-line
-module.exports = _require('./module').default

package/main.test.js

@@ -1,39 +0,0 @@
-import test from 'ava'
-import path from 'path'
-
-import primitive from './main'
-
-const fixturesPath = path.join(__dirname, 'media')
-
-const fixtures = [
-  'monalisa.png',
-  'lena.png'
-]
-
-const shapeTypes = [
-  'triangle',
-  'ellipse',
-  'rotated-ellipse',
-  'rectangle',
-  'rotated-rectangle',
-  'random'
-]
-
-fixtures.forEach((fixture) => {
-  const input = path.join(fixturesPath, fixture)
-
-  shapeTypes.forEach((shapeType) => {
-    test(`${fixture} - ${shapeType}`, async (t) => {
-      const model = await primitive({
-        input,
-        shapeType,
-        numSteps: 10,
-        numCandidateShapes: 5,
-        numCandidateMutations: 30,
-        log: console.log.bind(console)
-      })
-
-      t.true(model.score < 1)
-    })
-  })
-})