primitive 1.0.0 → 1.2.1

package/lib/browser-context.js

@@ -1,98 +0,0 @@
-import ow from 'ow'
-
-import { cssrgba } from './color'
-
-export const PARTIALS = true
-export const platform = 'browser'
-
-export const loadImage = async (input) => {
-  ow(input, ow.any(
-    ow.string.nonEmpty.label('input'),
-    ow.object.instanceOf(global.ImageData).label('input'),
-    ow.object.instanceOf(global.Image).label('input')
-  ))
-
-  if (typeof input === 'string') {
-    const img = new global.Image()
-    img.crossOrigin = 'anonymous'
-
-    await new Promise((resolve, reject) => {
-      img.onload = resolve
-      img.onerror = img.onabort = () => reject(new Error('image failed to load'))
-      img.src = input
-    })
-
-    return loadImage(img)
-  } else if (input instanceof global.ImageData) {
-    return input
-  } else if (input instanceof global.Image) {
-    input.crossOrigin = 'anonymous'
-    const canvas = document.createElement('canvas')
-    canvas.width = input.naturalWidth
-    canvas.height = input.naturalHeight
-    const ctx = canvas.getContext('2d')
-    ctx.drawImage(input, 0, 0)
-    return ctx.getImageData(0, 0, canvas.width, canvas.height)
-  } else {
-    throw new Error('invalid input image')
-  }
-}
-
-export const loadCanvas = async (value, label = 'canvas') => {
-  ow(value, ow.any(
-    ow.string.nonEmpty.label(label),
-    ow.object.instanceOf(global.HTMLCanvasElement).label(label)
-  ))
-
-  if (typeof value === 'string') {
-    const canvas = document.querySelector(value)
-
-    if (!canvas) {
-      throw new Error(`invalid ${label} selector "${value}" not found`)
-    }
-
-    if (!(canvas instanceof global.HTMLCanvasElement)) {
-      throw new Error(`invalid ${label} selector "${value}" is not a canvas element`)
-    }
-
-    return canvas
-  } else {
-    return value
-  }
-}
-
-export const enableContextAntialiasing = (ctx) => {
-  ctx.mozImageSmoothingQuality = 'high'
-  ctx.webkitImageSmoothingQuality = 'high'
-  ctx.msImageSmoothingQuality = 'high'
-  ctx.imageSmoothingQuality = 'high'
-
-  ctx.mozImageSmoothingEnabled = true
-  ctx.webkitImageSmoothingEnabled = true
-  ctx.msImageSmoothingEnabled = true
-  ctx.imageSmoothingEnabled = true
-}
-
-export const createImage = (width, height, fillColor = undefined) => {
-  ow(width, ow.number.label('width').positive.integer)
-  ow(height, ow.number.label('height').positive.integer)
-
-  const canvas = document.createElement('canvas')
-  canvas.width = width
-  canvas.height = height
-  const ctx = canvas.getContext('2d')
-  if (fillColor) {
-    ctx.fillStyle = cssrgba(fillColor)
-    ctx.fillRect(0, 0, width, height)
-  }
-  return ctx.getImageData(0, 0, width, height)
-}
-
-export default {
-  PARTIALS,
-  platform,
-  loadImage,
-  loadCanvas,
-  enableContextAntialiasing,
-  createImage
-}

package/lib/color.js

@@ -1,6 +0,0 @@
-import chromatism from 'chromatism'
-export default chromatism
-
-export const cssrgba = (color) => {
-  return `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`
-}

package/lib/context.js

@@ -1,101 +0,0 @@
-import execa from 'execa'
-import fs from 'fs'
-import ndarray from 'ndarray'
-import ow from 'ow'
-import pify from 'pify'
-import pump from 'pump-promise'
-import getPixels from 'get-pixels'
-import savePixels from 'save-pixels'
-
-const getPixelsP = pify(getPixels)
-
-export const PARTIALS = true
-export const platform = 'node'
-
-export const loadImage = async (input) => {
-  ow(input, ow.string.label('input').nonEmpty)
-
-  const result = await getPixelsP(input)
-  const { data, shape } = result
-
-  return {
-    data,
-    width: shape[0],
-    height: shape[1]
-  }
-}
-
-export const createImage = (width, height, color = undefined) => {
-  ow(width, ow.number.label('width').positive.integer)
-  ow(height, ow.number.label('height').positive.integer)
-
-  const data = new Uint8ClampedArray(width * height * 4)
-
-  if (color) {
-    for (let i = 0; i < width * height; ++i) {
-      const o = i * 4
-      data[o + 0] = color.r
-      data[o + 1] = color.g
-      data[o + 2] = color.b
-      data[o + 3] = color.a
-    }
-  }
-
-  return {
-    data,
-    width,
-    height
-  }
-}
-
-export const saveImage = async (image, filename, opts) => {
-  ow(image, ow.object.label('image').nonEmpty)
-  ow(filename, ow.string.label('filename').nonEmpty)
-
-  const pixels = ndarray(image.data, [ image.height, image.width, 4 ])
-  const parts = filename.split('.')
-  const format = parts[parts.length - 1]
-  const stream = savePixels(pixels.transpose(1, 0, 2), format)
-  return pump(stream, fs.createWriteStream(filename))
-}
-
-export const saveGIF = async (frames, filename, opts) => {
-  ow(frames, ow.array.label('frames'))
-  ow(filename, ow.string.label('filename').nonEmpty)
-  ow(opts, ow.object.label('opts').plain.nonEmpty)
-
-  const {
-    // gif output options
-    gifski = {
-      fps: 10,
-      quality: 80,
-      fast: false
-    }
-  } = opts
-
-  const params = [
-    '-o', filename,
-    '--fps', gifski.fps,
-    gifski.fast && '--fast',
-    '--quality', gifski.quality,
-    '-W', 600, // TODO: make this configurable
-    '--quiet'
-  ]
-    .concat(frames)
-    .filter(Boolean)
-
-  const executable = process.env.GIFSKI_PATH || 'gifski'
-  const cmd = [ executable ].concat(params).join(' ')
-  if (opts.log) opts.log(cmd)
-
-  await execa.shell(cmd)
-}
-
-export default {
-  PARTIALS,
-  platform,
-  loadImage,
-  createImage,
-  saveImage,
-  saveGIF
-}

package/lib/context.test.js

@@ -1,31 +0,0 @@
-import test from 'ava'
-import fs from 'fs'
-import path from 'path'
-import rmfr from 'rmfr'
-import tempy from 'tempy'
-
-import context from './context'
-
-const fixtures = path.join(__dirname, '..', 'media')
-
-test('monalisa.png', async (t) => {
-  const img0 = await context.loadImage(path.join(fixtures, 'monalisa.png'))
-  const temp = tempy.file({ extension: 'png' })
-  await context.saveImage(img0, temp)
-  const img1 = await context.loadImage(temp)
-
-  t.deepEqual(img0.data, img1.data)
-  await rmfr(temp)
-})
-
-test('flower.jpg', async (t) => {
-  const img0 = await context.loadImage(path.join(fixtures, 'flower.jpg'))
-  const temp = tempy.file({ extension: 'png' })
-  await context.saveImage(img0, temp)
-  const img1 = await context.loadImage(temp)
-
-  t.true(fs.existsSync(temp))
-  t.is(img0.width, img1.width)
-  t.is(img0.height, img1.height)
-  await rmfr(temp)
-})

package/lib/core.js

@@ -1,199 +0,0 @@
-'use strict'
-
-export const getMeanColor = (image) => {
-  const { data, width, height } = image
-
-  let r = 0
-  let g = 0
-  let b = 0
-
-  for (let i = 0; i < height; ++i) {
-    for (let j = 0; j < width; ++j) {
-      const o = (i * width + j) * 4
-      r += data[o + 0]
-      g += data[o + 1]
-      b += data[o + 2]
-    }
-  }
-
-  r = r / (width * height) | 0
-  g = g / (width * height) | 0
-  b = b / (width * height) | 0
-
-  return { r, g, b, a: 255 }
-}
-
-export const computeColor = (target, current, lines, alpha) => {
-  const { width } = target
-  const dataT = target.data
-  const dataC = current.data
-
-  const a = 255.0 / alpha
-
-  let count = 0
-  let r = 0.0
-  let g = 0.0
-  let b = 0.0
-
-  for (let i = 0; i < lines.length; ++i) {
-    const line = lines[i]
-
-    for (let j = line.x1; j <= line.x2; ++j) {
-      const o = (line.y * width + j) * 4
-
-      const tr = dataT[o + 0]
-      const tg = dataT[o + 1]
-      const tb = dataT[o + 2]
-
-      const cr = dataC[o + 0]
-      const cg = dataC[o + 1]
-      const cb = dataC[o + 2]
-
-      r += (tr - cr) * a + cr
-      g += (tg - cg) * a + cg
-      b += (tb - cb) * a + cb
-
-      ++count
-    }
-  }
-
-  if (count > 0) {
-    r = Math.max(0, Math.min(255, (r / count))) | 0
-    g = Math.max(0, Math.min(255, (g / count))) | 0
-    b = Math.max(0, Math.min(255, (b / count))) | 0
-  }
-
-  return { r, g, b, a: alpha }
-}
-
-export const difference = (imageA, imageB) => {
-  const { width, height } = imageA
-  const dataA = imageA.data
-  const dataB = imageB.data
-
-  if (dataA.length !== dataB.length) {
-    throw new Error('image.difference incompatible images')
-  }
-
-  let sum = 0.0
-
-  for (let i = 0; i < height; ++i) {
-    for (let j = 0; j < width; ++j) {
-      const o = (i * width + j) * 4
-
-      const ar = dataA[o + 0]
-      const ag = dataA[o + 1]
-      const ab = dataA[o + 2]
-
-      const br = dataB[o + 0]
-      const bg = dataB[o + 1]
-      const bb = dataB[o + 2]
-
-      const dr = ar - br
-      const dg = ag - bg
-      const db = ab - bb
-
-      sum += (dr * dr + dg * dg + db * db)
-    }
-  }
-
-  return Math.sqrt(sum / (width * height * 3)) / 255
-}
-
-export const differencePartial = (target, before, after, score, lines) => {
-  const { width, height } = target
-  const dataT = target.data
-  const dataB = before.data
-  const dataA = after.data
-
-  if (dataT.length !== dataB.length || dataT.length !== dataA.length) {
-    throw new Error('image.differencePartial incompatible images')
-  }
-
-  let sum = Math.pow(score * 255, 2) * width * height * 3
-
-  for (let i = 0; i < lines.length; ++i) {
-    const line = lines[i]
-
-    for (let j = line.x1; j <= line.x2; ++j) {
-      const o = (line.y * width + j) * 4
-
-      const tr = dataT[o + 0]
-      const tg = dataT[o + 1]
-      const tb = dataT[o + 2]
-
-      const br = dataB[o + 0]
-      const bg = dataB[o + 1]
-      const bb = dataB[o + 2]
-
-      const ar = dataA[o + 0]
-      const ag = dataA[o + 1]
-      const ab = dataA[o + 2]
-
-      const dr1 = tr - br
-      const dg1 = tg - bg
-      const db1 = tb - bb
-
-      const dr2 = tr - ar
-      const dg2 = tg - ag
-      const db2 = tb - ab
-
-      sum -= (dr1 * dr1 + dg1 * dg1 + db1 * db1)
-      sum += (dr2 * dr2 + dg2 * dg2 + db2 * db2)
-    }
-  }
-
-  return Math.sqrt(sum / (width * height * 3)) / 255
-}
-
-export const copyLines = (dest, src, lines) => {
-  const { width, height } = src
-  const m = width * height * 4
-
-  if (dest.data.length !== src.data.length) {
-    throw new Error('image.copyLines incompatible images')
-  }
-
-  for (let i = 0; i < lines.length; ++i) {
-    const line = lines[i]
-    const o1 = Math.min(m, (line.y * width + line.x1) * 4)
-    const o2 = Math.min(m, (line.y * width + line.x2) * 4)
-    dest.data.set(src.data.slice(o1, o2), o1)
-  }
-}
-
-export const drawLines = (image, color, lines) => {
-  const { data, width } = image
-
-  const sr = color.r
-  const sg = color.g
-  const sb = color.b
-  const sa = color.a
-
-  for (let i = 0; i < lines.length; ++i) {
-    const line = lines[i]
-    const ma = sa / 255
-    const a = 1.0 - ma
-
-    for (let j = line.x1; j <= line.x2; ++j) {
-      const o = (line.y * width + j) * 4
-
-      const dr = data[o + 0]
-      const dg = data[o + 1]
-      const db = data[o + 2]
-
-      data[o + 0] = (dr * a + sr * ma) | 0
-      data[o + 1] = (dg * a + sg * ma) | 0
-      data[o + 2] = (db * a + sb * ma) | 0
-    }
-  }
-}
-
-export default {
-  getMeanColor,
-  computeColor,
-  difference,
-  differencePartial,
-  copyLines,
-  drawLines
-}

package/lib/core.test.js

@@ -1,70 +0,0 @@
-import test from 'ava'
-import path from 'path'
-
-import context from './context'
-import core from './core'
-import Scanline from './scanline'
-
-const fixtures = path.join(__dirname, '..', 'media')
-
-test('difference', async (t) => {
-  const image = await context.loadImage(path.join(fixtures, 'monalisa.png'))
-  const color = core.getMeanColor(image)
-  const blank = context.createImage(image.width, image.height)
-  const current = context.createImage(image.width, image.height, color)
-
-  const diff0 = core.difference(image, blank)
-  t.true(diff0 > 0)
-
-  const diff1 = core.difference(image, current)
-  t.true(diff1 > 0)
-  t.true(diff0 > diff1)
-
-  const diff2 = core.difference(image, image)
-  t.is(diff2, 0)
-
-  let diff = diff0
-  for (let i = 0; i < image.height; ++i) {
-    const o = i * image.width * 4
-    blank.data.set(image.data.slice(o, o + image.width * 4), o)
-    const diff3 = core.difference(image, blank)
-    t.true(diff3 < diff)
-    diff = diff3
-  }
-  t.is(diff, 0)
-})
-
-test('drawLines', async (t) => {
-  const image = await context.loadImage(path.join(fixtures, 'monalisa.png'))
-  const color = core.getMeanColor(image)
-  const current = context.createImage(image.width, image.height, color)
-
-  const diff0 = core.difference(image, current)
-  t.true(diff0 > 0)
-
-  const lines = []
-  const c = { r: 255, g: 0, b: 0, a: 255 }
-  const m = image.width / 2 | 0
-
-  for (let i = 0; i < 16; ++i) {
-    lines.push(new Scanline(i, 5, m, 255))
-  }
-
-  t.is(lines.length, Scanline.filter(lines, image.width, image.height).length)
-
-  core.drawLines(current, c, lines)
-
-  for (let i = 0; i < 16; ++i) {
-    for (let j = 5; j < m; ++j) {
-      const o = (i * image.width + j) * 4
-      t.is(current.data[o + 0], 255)
-      t.is(current.data[o + 1], 0)
-      t.is(current.data[o + 2], 0)
-      t.is(current.data[o + 3], 255)
-    }
-  }
-
-  const diff1 = core.difference(image, current)
-  t.true(diff1 > 0)
-  t.true(diff1 > diff0)
-})

package/lib/model.js

@@ -1,168 +0,0 @@
-import * as chromatism from 'chromatism'
-import ow from 'ow'
-
-import core from './core'
-import optimize from './optimize'
-import Worker from './worker'
-
-export default class Model {
-  constructor (opts) {
-    const {
-      context,
-      target,
-      backgroundColor,
-      outputSize,
-      numCandidates = 1
-    } = opts
-
-    const { width, height } = target
-    const aspect = width / height
-
-    if (outputSize) {
-      if (aspect >= 1) {
-        this.sw = outputSize
-        this.sh = outputSize / aspect | 0
-        this.scale = outputSize / width
-      } else {
-        this.sw = outputSize * aspect | 0
-        this.sh = outputSize
-        this.scale = outputSize / height
-      }
-    } else {
-      this.sw = width
-      this.sh = height
-      this.scale = 1
-    }
-
-    this.context = context
-    this.target = target
-    this.backgroundColor = backgroundColor
-
-    this.current = this.createImage()
-    this.score = core.difference(this.target, this.current)
-
-    this.shapes = []
-    this.colors = []
-    this.scores = []
-    this.workers = []
-
-    for (let i = 0; i < numCandidates; ++i) {
-      this.workers.push(new Worker({
-        context,
-        target
-      }))
-    }
-
-    if (this.context.PARTIALS) {
-      this.before = this.context.createImage(width, height)
-    }
-  }
-
-  createImage () {
-    const { width, height } = this.target
-    return this.context.createImage(width, height, this.backgroundColor)
-  }
-
-  add (shape, alpha) {
-    const lines = shape.rasterize()
-    const color = core.computeColor(this.target, this.current, lines, alpha)
-    let score
-
-    if (this.context.PARTIALS) {
-      this.before.data.set(this.current.data)
-      core.drawLines(this.current, color, lines)
-      score = core.differencePartial(this.target, this.before, this.current, this.score, lines)
-    } else {
-      core.drawLines(this.current, color, lines)
-      score = core.difference(this.target, this.current)
-    }
-
-    this.score = score
-    this.shapes.push(shape)
-    this.colors.push(color)
-    this.scores.push(score)
-  }
-
-  step (opts) {
-    ow(opts, ow.object.plain)
-    ow(opts.shapeType, ow.string.nonEmpty)
-    ow(opts.shapeAlpha, ow.number.integer.positive)
-    ow(opts.numCandidateShapes, ow.number.integer.positive)
-    ow(opts.numCandidateMutations, ow.number.integer.positive)
-
-    let state = this._getBestCandidateState(opts)
-    this.add(state.shape, state.alpha)
-
-    if (opts.numCandidateExtras) {
-      ow(opts.numCandidateExtras, ow.number.integer)
-
-      for (let i = 0; i < opts.numCandidateExtras; ++i) {
-        state.worker.init(this.current, this.score)
-        const a = state.energy()
-        state = optimize.hillClimb(state, opts.numCandidateMutations)
-        const b = state.energy()
-        if (b <= a) break
-
-        this.add(state.shape, state.alpha)
-      }
-    }
-
-    return this.workers
-      .reduce((sum, worker) => sum + worker.counter, 0)
-  }
-
-  _getBestCandidateState (opts) {
-    const states = this.workers
-      .map((worker) => {
-        worker.init(this.current, this.score)
-        return optimize.getBestHillClimbState(worker, opts)
-      })
-
-    let bestEnergy = null
-    let bestState = null
-
-    for (let i = 0; i < states.length; ++i) {
-      const state = states[i]
-      const energy = state.energy()
-
-      if (!i || energy < bestEnergy) {
-        bestEnergy = energy
-        bestState = state
-      }
-    }
-
-    return bestState
-  }
-
-  toSVG () {
-    const bg = chromatism.convert(this.backgroundColor).hex
-    const body = this.shapes
-      .map((shape, index) => {
-        const color = this.colors[index]
-        const fill = chromatism.convert(color).hex
-        const attrs = `fill="${fill}" fill-opacity="${color.a / 255}"`
-        return shape.toSVG(attrs)
-      })
-      .join('\n')
-
-    return `
-<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="${this.sw}" height="${this.sh}">
-  <rect x="0" y="0" width="${this.sw}" height="${this.sh}" fill="${bg}" />
-  <g transform="scale(${this.scale}) translate(0.5 0.5)">
-    ${body}
-  </g>
-</svg>
-`
-  }
-
-  toFrames (scoreDelta = 0) {
-    throw new Error('TODO')
-
-    /*
-    for (let i = 0; i < this.shapes.length; ++i) {
-      const shape = this.shapes[i]
-      const color = this.colors[i]
-    }
-    */
-  }
-}