Skip to content

Instantly share code, notes, and snippets.

@Barneybook Barneybook/index.html
Last active Aug 29, 2015

Embed
What would you like to do?
Learn more about clone URLs
Download ZIP
Raw
index.html
<html>
<head>
<script language="javascript" type="text/javascript" src="./js/p5.js"></script>
<!-- uncomment lines below to include extra p5 libraries -->
<!--<script language="javascript" src="../addons/p5.dom.js"></script>-->
<!--<script language="javascript" src="../addons/p5.sound.js"></script>-->
<script language="javascript" type="text/javascript" src="./js/sketch.js"></script>
<!-- this line removes any default padding and style. you might only need one of these values set. -->
<style> body {padding: 0; margin: 0; background-color: black;} </style>
</head>
<body>
</body>
</html>
Raw
p5.js
/*! p5.js v0.4.3 March 30, 2015 */
(function (root, factory) {
if (typeof define === 'function' && define.amd)
define('p5', [], function () { return (root.returnExportsGlobal = factory());});
else if (typeof exports === 'object')
module.exports = factory();
else
root['p5'] = factory();
}(this, function () {
var amdclean = {};
amdclean['shim'] = function (require) {
window.requestDraw = function () {
return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (callback, element) {
window.setTimeout(callback, 1000 / 60);
};
}();
}({});
amdclean['constants'] = function (require) {
var PI = Math.PI;
return {
ARROW: 'default',
CROSS: 'crosshair',
HAND: 'pointer',
MOVE: 'move',
TEXT: 'text',
WAIT: 'wait',
HALF_PI: PI / 2,
PI: PI,
QUARTER_PI: PI / 4,
TAU: PI * 2,
TWO_PI: PI * 2,
DEGREES: 'degrees',
RADIANS: 'radians',
CORNER: 'corner',
CORNERS: 'corners',
RADIUS: 'radius',
RIGHT: 'right',
LEFT: 'left',
CENTER: 'center',
TOP: 'top',
BOTTOM: 'bottom',
BASELINE: 'alphabetic',
POINTS: 'points',
LINES: 'lines',
TRIANGLES: 'triangles',
TRIANGLE_FAN: 'triangles_fan',
TRIANGLE_STRIP: 'triangles_strip',
QUADS: 'quads',
QUAD_STRIP: 'quad_strip',
CLOSE: 'close',
OPEN: 'open',
CHORD: 'chord',
PIE: 'pie',
PROJECT: 'square',
SQUARE: 'butt',
ROUND: 'round',
BEVEL: 'bevel',
MITER: 'miter',
RGB: 'rgb',
HSB: 'hsb',
AUTO: 'auto',
ALT: 18,
BACKSPACE: 8,
CONTROL: 17,
DELETE: 46,
DOWN_ARROW: 40,
ENTER: 13,
ESCAPE: 27,
LEFT_ARROW: 37,
OPTION: 18,
RETURN: 13,
RIGHT_ARROW: 39,
SHIFT: 16,
TAB: 9,
UP_ARROW: 38,
BLEND: 'normal',
ADD: 'lighter',
DARKEST: 'darken',
LIGHTEST: 'lighten',
DIFFERENCE: 'difference',
EXCLUSION: 'exclusion',
MULTIPLY: 'multiply',
SCREEN: 'screen',
REPLACE: 'source-over',
OVERLAY: 'overlay',
HARD_LIGHT: 'hard-light',
SOFT_LIGHT: 'soft-light',
DODGE: 'color-dodge',
BURN: 'color-burn',
THRESHOLD: 'threshold',
GRAY: 'gray',
OPAQUE: 'opaque',
INVERT: 'invert',
POSTERIZE: 'posterize',
DILATE: 'dilate',
ERODE: 'erode',
BLUR: 'blur',
NORMAL: 'normal',
ITALIC: 'italic',
BOLD: 'bold',
LINEAR: 'linear',
QUADRATIC: 'quadratic',
BEZIER: 'bezier',
CURVE: 'curve'
};
}({});
amdclean['core'] = function (require, shim, constants) {
'use strict';
var constants = constants;
var p5 = function (sketch, node, sync) {
if (arguments.length === 2 && typeof node === 'boolean') {
sync = node;
node = undefined;
}
this._setupDone = false;
this._pixelDensity = window.devicePixelRatio || 1;
this._startTime = new Date().getTime();
this._userNode = node;
this._curElement = null;
this._elements = [];
this._preloadCount = 0;
this._updateInterval = 0;
this._isGlobal = false;
this._loop = true;
this._styles = [];
this._defaultCanvasSize = {
width: 100,
height: 100
};
this._events = {
'mousemove': null,
'mousedown': null,
'mouseup': null,
'click': null,
'mousewheel': null,
'mouseover': null,
'mouseout': null,
'keydown': null,
'keyup': null,
'keypress': null,
'touchstart': null,
'touchmove': null,
'touchend': null,
'resize': null,
'blur': null
};
if (window.DeviceOrientationEvent) {
this._events.deviceorientation = null;
} else if (window.DeviceMotionEvent) {
this._events.devicemotion = null;
} else {
this._events.MozOrientation = null;
}
this._loadingScreenId = 'p5_loading';
this._start = function () {
if (this._userNode) {
if (typeof this._userNode === 'string') {
this._userNode = document.getElementById(this._userNode);
}
}
this._loadingScreen = document.getElementById(this._loadingScreenId);
if (!this._loadingScreen) {
this._loadingScreen = document.createElement('loadingDiv');
this._loadingScreen.innerHTML = 'loading...';
this._loadingScreen.style.position = 'absolute';
var node = this._userNode || document.body;
node.appendChild(this._loadingScreen);
}
this.createCanvas(this._defaultCanvasSize.width, this._defaultCanvasSize.height, true);
var userPreload = this.preload || window.preload;
var context = this._isGlobal ? window : this;
if (userPreload) {
this._preloadMethods.forEach(function (f) {
context[f] = function () {
var argsArray = Array.prototype.slice.call(arguments);
return context._preload(f, argsArray);
};
});
userPreload();
if (this._preloadCount === 0) {
this._setup();
this._runFrames();
this._draw();
}
} else {
this._setup();
this._runFrames();
this._draw();
}
}.bind(this);
this._preload = function (func, args) {
var context = this._isGlobal ? window : this;
context._setProperty('_preloadCount', context._preloadCount + 1);
var preloadCallback = function (resp) {
context._setProperty('_preloadCount', context._preloadCount - 1);
if (context._preloadCount === 0) {
context._setup();
context._runFrames();
context._draw();
}
};
args.push(preloadCallback);
return p5.prototype[func].apply(context, args);
}.bind(this);
this._setup = function () {
var context = this._isGlobal ? window : this;
if (typeof context.preload === 'function') {
this._preloadMethods.forEach(function (f) {
context[f] = p5.prototype[f];
});
}
if (typeof context.setup === 'function') {
context.setup();
}
this.canvas.style.visibility = '';
this.canvas.className = this.canvas.className.replace('p5_hidden', '');
this._setupDone = true;
this._loadingScreen.parentNode.removeChild(this._loadingScreen);
}.bind(this);
this._draw = function () {
var now = new Date().getTime();
this._frameRate = 1000 / (now - this._lastFrameTime);
this._lastFrameTime = now;
this._setProperty('frameCount', this.frameCount + 1);
if (this._loop) {
if (this._drawInterval) {
clearInterval(this._drawInterval);
}
this._drawInterval = setTimeout(function () {
window.requestDraw(this._draw.bind(this));
}.bind(this), 1000 / this._targetFrameRate);
}
this.redraw();
this._updatePAccelerations();
this._updatePMouseCoords();
this._updatePTouchCoords();
}.bind(this);
this._runFrames = function () {
if (this._updateInterval) {
clearInterval(this._updateInterval);
}
}.bind(this);
this._setProperty = function (prop, value) {
this[prop] = value;
if (this._isGlobal) {
window[prop] = value;
}
}.bind(this);
this.remove = function () {
if (this._curElement) {
this._loop = false;
if (this._drawInterval) {
clearTimeout(this._drawInterval);
}
if (this._updateInterval) {
clearTimeout(this._updateInterval);
}
for (var ev in this._events) {
window.removeEventListener(ev, this._events[ev]);
}
for (var i = 0; i < this._elements.length; i++) {
var e = this._elements[i];
if (e.elt.parentNode) {
e.elt.parentNode.removeChild(e.elt);
}
for (var elt_ev in e._events) {
e.elt.removeEventListener(elt_ev, e._events[elt_ev]);
}
}
var self = this;
this._registeredMethods.remove.forEach(function (f) {
if (typeof f !== 'undefined') {
f.call(self);
}
});
if (this._isGlobal) {
for (var p in p5.prototype) {
try {
delete window[p];
} catch (x) {
window[p] = undefined;
}
}
for (var p2 in this) {
if (this.hasOwnProperty(p2)) {
try {
delete window[p2];
} catch (x) {
window[p2] = undefined;
}
}
}
}
}
}.bind(this);
for (var k in constants) {
p5.prototype[k] = constants[k];
}
if (!sketch) {
this._isGlobal = true;
for (var p in p5.prototype) {
if (typeof p5.prototype[p] === 'function') {
var ev = p.substring(2);
if (!this._events.hasOwnProperty(ev)) {
window[p] = p5.prototype[p].bind(this);
}
} else {
window[p] = p5.prototype[p];
}
}
for (var p2 in this) {
if (this.hasOwnProperty(p2)) {
window[p2] = this[p2];
}
}
} else {
sketch(this);
}
for (var e in this._events) {
var f = this['_on' + e];
if (f) {
var m = f.bind(this);
window.addEventListener(e, m);
this._events[e] = m;
}
}
var self = this;
window.addEventListener('focus', function () {
self._setProperty('focused', true);
});
window.addEventListener('blur', function () {
self._setProperty('focused', false);
});
if (sync) {
this._start();
} else {
if (document.readyState === 'complete') {
this._start();
} else {
window.addEventListener('load', this._start.bind(this), false);
}
}
};
p5.prototype._preloadMethods = [
'loadJSON',
'loadImage',
'loadStrings',
'loadXML',
'loadShape',
'loadTable'
];
p5.prototype._registeredMethods = {
pre: [],
post: [],
remove: []
};
p5.prototype.registerPreloadMethod = function (m) {
p5.prototype._preloadMethods.push(m);
}.bind(this);
p5.prototype.registerMethod = function (name, m) {
if (!p5.prototype._registeredMethods.hasOwnProperty(name)) {
p5.prototype._registeredMethods[name] = [];
}
p5.prototype._registeredMethods[name].push(m);
}.bind(this);
return p5;
}({}, amdclean['shim'], amdclean['constants']);
amdclean['utilscolor_utils'] = function (require, core) {
var p5 = core;
p5.ColorUtils = {};
p5.ColorUtils.hsbaToRGBA = function (hsba) {
var h = hsba[0];
var s = hsba[1];
var v = hsba[2];
h /= 255;
s /= 255;
v /= 255;
var RGBA = [];
if (s === 0) {
RGBA = [
Math.round(v * 255),
Math.round(v * 255),
Math.round(v * 255),
hsba[3]
];
} else {
var var_h = h * 6;
if (var_h === 6) {
var_h = 0;
}
var var_i = Math.floor(var_h);
var var_1 = v * (1 - s);
var var_2 = v * (1 - s * (var_h - var_i));
var var_3 = v * (1 - s * (1 - (var_h - var_i)));
var var_r;
var var_g;
var var_b;
if (var_i === 0) {
var_r = v;
var_g = var_3;
var_b = var_1;
} else if (var_i === 1) {
var_r = var_2;
var_g = v;
var_b = var_1;
} else if (var_i === 2) {
var_r = var_1;
var_g = v;
var_b = var_3;
} else if (var_i === 3) {
var_r = var_1;
var_g = var_2;
var_b = v;
} else if (var_i === 4) {
var_r = var_3;
var_g = var_1;
var_b = v;
} else {
var_r = v;
var_g = var_1;
var_b = var_2;
}
RGBA = [
Math.round(var_r * 255),
Math.round(var_g * 255),
Math.round(var_b * 255),
hsba[3]
];
}
return RGBA;
};
p5.ColorUtils.rgbaToHSBA = function (rgba) {
var var_R = rgba[0] / 255;
var var_G = rgba[1] / 255;
var var_B = rgba[2] / 255;
var var_Min = Math.min(var_R, var_G, var_B);
var var_Max = Math.max(var_R, var_G, var_B);
var del_Max = var_Max - var_Min;
var H;
var S;
var V = var_Max;
if (del_Max === 0) {
H = 0;
S = 0;
} else {
S = del_Max / var_Max;
var del_R = ((var_Max - var_R) / 6 + del_Max / 2) / del_Max;
var del_G = ((var_Max - var_G) / 6 + del_Max / 2) / del_Max;
var del_B = ((var_Max - var_B) / 6 + del_Max / 2) / del_Max;
if (var_R === var_Max) {
H = del_B - del_G;
} else if (var_G === var_Max) {
H = 1 / 3 + del_R - del_B;
} else if (var_B === var_Max) {
H = 2 / 3 + del_G - del_R;
}
if (H < 0) {
H += 1;
}
if (H > 1) {
H -= 1;
}
}
return [
Math.round(H * 255),
Math.round(S * 255),
Math.round(V * 255),
rgba[3]
];
};
return p5.ColorUtils;
}({}, amdclean['core']);
amdclean['p5Color'] = function (require, core, utilscolor_utils, constants) {
var p5 = core;
var color_utils = utilscolor_utils;
var constants = constants;
p5.Color = function (pInst, vals) {
this.color_array = p5.Color._getFormattedColor.apply(pInst, vals);
this._normalizeColorArray(pInst);
if (pInst._colorMode === constants.HSB) {
this.hsba = this.color_array;
this.rgba = color_utils.hsbaToRGBA(this.hsba);
} else {
this.rgba = this.color_array;
this.hsba = color_utils.rgbaToHSBA(this.rgba);
}
return this;
};
p5.Color.prototype._normalizeColorArray = function (pInst) {
var isRGB = pInst._colorMode === constants.RGB;
var maxArr = isRGB ? pInst._maxRGB : pInst._maxHSB;
var arr = this.color_array;
arr[0] *= 255 / maxArr[0];
arr[1] *= 255 / maxArr[1];
arr[2] *= 255 / maxArr[2];
arr[3] *= 255 / maxArr[3];
return arr;
};
p5.Color.prototype.getHue = function () {
return this.hsba[0];
};
p5.Color.prototype.getSaturation = function () {
return this.hsba[1];
};
p5.Color.prototype.getBrightness = function () {
return this.hsba[2];
};
p5.Color.prototype.getRed = function () {
return this.rgba[0];
};
p5.Color.prototype.getGreen = function () {
return this.rgba[1];
};
p5.Color.prototype.getBlue = function () {
return this.rgba[2];
};
p5.Color.prototype.getAlpha = function () {
return this.rgba[3];
};
p5.Color.prototype.toString = function () {
var a = this.rgba;
for (var i = 0; i < 3; i++) {
a[i] = Math.floor(a[i]);
}
var alpha = typeof a[3] !== 'undefined' ? a[3] / 255 : 1;
return 'rgba(' + a[0] + ',' + a[1] + ',' + a[2] + ',' + alpha + ')';
};
p5.Color._getFormattedColor = function () {
var r, g, b, a;
if (arguments.length >= 3) {
r = arguments[0];
g = arguments[1];
b = arguments[2];
a = typeof arguments[3] === 'number' ? arguments[3] : 255;
} else {
if (this._colorMode === constants.RGB) {
r = g = b = arguments[0];
} else {
r = b = arguments[0];
g = 0;
}
a = typeof arguments[1] === 'number' ? arguments[1] : 255;
}
return [
r,
g,
b,
a
];
};
return p5.Color;
}({}, amdclean['core'], amdclean['utilscolor_utils'], amdclean['constants']);
amdclean['p5Element'] = function (require, core) {
var p5 = core;
p5.Element = function (elt, pInst) {
this.elt = elt;
this._pInst = pInst;
this._events = {};
this.width = this.elt.offsetWidth;
this.height = this.elt.offsetHeight;
};
p5.Element.prototype.parent = function (p) {
if (typeof p === 'string') {
p = document.getElementById(p);
} else if (p instanceof p5.Element) {
p = p.elt;
}
p.appendChild(this.elt);
return this;
};
p5.Element.prototype.id = function (id) {
this.elt.id = id;
return this;
};
p5.Element.prototype.class = function (c) {
this.elt.className += ' ' + c;
return this;
};
p5.Element.prototype.mousePressed = function (fxn) {
attachListener('mousedown', fxn, this);
attachListener('touchstart', fxn, this);
return this;
};
p5.Element.prototype.mouseWheel = function (fxn) {
attachListener('mousewheel', fxn, this);
return this;
};
p5.Element.prototype.mouseReleased = function (fxn) {
attachListener('mouseup', fxn, this);
attachListener('touchend', fxn, this);
return this;
};
p5.Element.prototype.mouseClicked = function (fxn) {
attachListener('click', fxn, this);
return this;
};
p5.Element.prototype.mouseMoved = function (fxn) {
attachListener('mousemove', fxn, this);
attachListener('touchmove', fxn, this);
return this;
};
p5.Element.prototype.mouseOver = function (fxn) {
attachListener('mouseover', fxn, this);
return this;
};
p5.Element.prototype.mouseOut = function (fxn) {
attachListener('mouseout', fxn, this);
return this;
};
p5.Element.prototype.touchStarted = function (fxn) {
attachListener('touchstart', fxn, this);
attachListener('mousedown', fxn, this);
return this;
};
p5.Element.prototype.touchMoved = function (fxn) {
attachListener('touchmove', fxn, this);
attachListener('mousemove', fxn, this);
return this;
};
p5.Element.prototype.touchEnded = function (fxn) {
attachListener('touchend', fxn, this);
attachListener('mouseup', fxn, this);
return this;
};
p5.Element.prototype.dragOver = function (fxn) {
attachListener('dragover', fxn, this);
return this;
};
p5.Element.prototype.dragLeave = function (fxn) {
attachListener('dragleave', fxn, this);
return this;
};
p5.Element.prototype.drop = function (callback, fxn) {
function makeLoader(theFile) {
var p5file = new p5.File(theFile);
return function (e) {
p5file.data = e.target.result;
callback(p5file);
};
}
if (window.File && window.FileReader && window.FileList && window.Blob) {
attachListener('dragover', function (evt) {
evt.stopPropagation();
evt.preventDefault();
}, this);
attachListener('dragleave', function (evt) {
evt.stopPropagation();
evt.preventDefault();
}, this);
if (arguments.length > 1) {
attachListener('drop', fxn, this);
}
attachListener('drop', function (evt) {
evt.stopPropagation();
evt.preventDefault();
var files = evt.dataTransfer.files;
for (var i = 0; i < files.length; i++) {
var f = files[i];
var reader = new FileReader();
reader.onload = makeLoader(f);
if (f.type === 'text') {
reader.readAsText(f);
} else {
reader.readAsDataURL(f);
}
}
}, this);
} else {
console.log('The File APIs are not fully supported in this browser.');
}
return this;
};
function attachListener(ev, fxn, ctx) {
var f = fxn.bind(ctx);
ctx.elt.addEventListener(ev, f, false);
ctx._events[ev] = f;
}
p5.Element.prototype._setProperty = function (prop, value) {
this[prop] = value;
};
return p5.Element;
}({}, amdclean['core']);
amdclean['p5Graphics'] = function (require, core, constants) {
var p5 = core;
var constants = constants;
p5.Graphics = function (elt, pInst, isMainCanvas) {
p5.Element.call(this, elt, pInst);
this.canvas = elt;
this.drawingContext = this.canvas.getContext('2d');
this._pInst = pInst;
if (isMainCanvas) {
this._isMainCanvas = true;
this._pInst._setProperty('_curElement', this);
this._pInst._setProperty('canvas', this.canvas);
this._pInst._setProperty('drawingContext', this.drawingContext);
this._pInst._setProperty('width', this.width);
this._pInst._setProperty('height', this.height);
} else {
this.canvas.style.display = 'none';
this._styles = [];
}
};
p5.Graphics.prototype = Object.create(p5.Element.prototype);
p5.Graphics.prototype._applyDefaults = function () {
this.drawingContext.fillStyle = '#FFFFFF';
this.drawingContext.strokeStyle = '#000000';
this.drawingContext.lineCap = constants.ROUND;
this.drawingContext.font = 'normal 12px sans-serif';
};
p5.Graphics.prototype.resize = function (w, h) {
this.width = w;
this.height = h;
this.elt.width = w * this._pInst._pixelDensity;
this.elt.height = h * this._pInst._pixelDensity;
this.elt.style.width = w + 'px';
this.elt.style.height = h + 'px';
if (this._isMainCanvas) {
this._pInst._setProperty('width', this.width);
this._pInst._setProperty('height', this.height);
}
this.drawingContext.scale(this._pInst._pixelDensity, this._pInst._pixelDensity);
};
return p5.Graphics;
}({}, amdclean['core'], amdclean['constants']);
amdclean['filters'] = function (require) {
'use strict';
var Filters = {};
Filters._toPixels = function (canvas) {
if (canvas instanceof ImageData) {
return canvas.data;
} else {
return canvas.getContext('2d').getImageData(0, 0, canvas.width, canvas.height).data;
}
};
Filters._getARGB = function (data, i) {
var offset = i * 4;
return data[offset + 3] << 24 & 4278190080 | data[offset] << 16 & 16711680 | data[offset + 1] << 8 & 65280 | data[offset + 2] & 255;
};
Filters._setPixels = function (pixels, data) {
var offset = 0;
for (var i = 0, al = pixels.length; i < al; i++) {
offset = i * 4;
pixels[offset + 0] = (data[i] & 16711680) >>> 16;
pixels[offset + 1] = (data[i] & 65280) >>> 8;
pixels[offset + 2] = data[i] & 255;
pixels[offset + 3] = (data[i] & 4278190080) >>> 24;
}
};
Filters._toImageData = function (canvas) {
if (canvas instanceof ImageData) {
return canvas;
} else {
return canvas.getContext('2d').getImageData(0, 0, canvas.width, canvas.height);
}
};
Filters._createImageData = function (width, height) {
Filters._tmpCanvas = document.createElement('canvas');
Filters._tmpCtx = Filters._tmpCanvas.getContext('2d');
return this._tmpCtx.createImageData(width, height);
};
Filters.apply = function (canvas, func, filterParam) {
var ctx = canvas.getContext('2d');
var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
var newImageData = func(imageData, filterParam);
if (newImageData instanceof ImageData) {
ctx.putImageData(newImageData, 0, 0, 0, 0, canvas.width, canvas.height);
} else {
ctx.putImageData(imageData, 0, 0, 0, 0, canvas.width, canvas.height);
}
};
Filters.threshold = function (canvas, level) {
var pixels = Filters._toPixels(canvas);
if (level === undefined) {
level = 0.5;
}
var thresh = Math.floor(level * 255);
for (var i = 0; i < pixels.length; i += 4) {
var r = pixels[i];
var g = pixels[i + 1];
var b = pixels[i + 2];
var grey = 0.2126 * r + 0.7152 * g + 0.0722 * b;
var val;
if (grey >= thresh) {
val = 255;
} else {
val = 0;
}
pixels[i] = pixels[i + 1] = pixels[i + 2] = val;
}
};
Filters.gray = function (canvas) {
var pixels = Filters._toPixels(canvas);
for (var i = 0; i < pixels.length; i += 4) {
var r = pixels[i];
var g = pixels[i + 1];
var b = pixels[i + 2];
var gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;
pixels[i] = pixels[i + 1] = pixels[i + 2] = gray;
}
};
Filters.opaque = function (canvas) {
var pixels = Filters._toPixels(canvas);
for (var i = 0; i < pixels.length; i += 4) {
pixels[i + 3] = 255;
}
return pixels;
};
Filters.invert = function (canvas) {
var pixels = Filters._toPixels(canvas);
for (var i = 0; i < pixels.length; i += 4) {
pixels[i] = 255 - pixels[i];
pixels[i + 1] = 255 - pixels[i + 1];
pixels[i + 2] = 255 - pixels[i + 2];
}
};
Filters.posterize = function (canvas, level) {
var pixels = Filters._toPixels(canvas);
if (level < 2 || level > 255) {
throw new Error('Level must be greater than 2 and less than 255 for posterize');
}
var levels1 = level - 1;
for (var i = 0; i < pixels.length; i += 4) {
var rlevel = pixels[i];
var glevel = pixels[i + 1];
var blevel = pixels[i + 2];
pixels[i] = (rlevel * level >> 8) * 255 / levels1;
pixels[i + 1] = (glevel * level >> 8) * 255 / levels1;
pixels[i + 2] = (blevel * level >> 8) * 255 / levels1;
}
};
Filters.dilate = function (canvas) {
var pixels = Filters._toPixels(canvas);
var currIdx = 0;
var maxIdx = pixels.length ? pixels.length / 4 : 0;
var out = new Int32Array(maxIdx);
var currRowIdx, maxRowIdx, colOrig, colOut, currLum;
var idxRight, idxLeft, idxUp, idxDown, colRight, colLeft, colUp, colDown, lumRight, lumLeft, lumUp, lumDown;
while (currIdx < maxIdx) {
currRowIdx = currIdx;
maxRowIdx = currIdx + canvas.width;
while (currIdx < maxRowIdx) {
colOrig = colOut = Filters._getARGB(pixels, currIdx);
idxLeft = currIdx - 1;
idxRight = currIdx + 1;
idxUp = currIdx - canvas.width;
idxDown = currIdx + canvas.width;
if (idxLeft < currRowIdx) {
idxLeft = currIdx;
}
if (idxRight >= maxRowIdx) {
idxRight = currIdx;
}
if (idxUp < 0) {
idxUp = 0;
}
if (idxDown >= maxIdx) {
idxDown = currIdx;
}
colUp = Filters._getARGB(pixels, idxUp);
colLeft = Filters._getARGB(pixels, idxLeft);
colDown = Filters._getARGB(pixels, idxDown);
colRight = Filters._getARGB(pixels, idxRight);
currLum = 77 * (colOrig >> 16 & 255) + 151 * (colOrig >> 8 & 255) + 28 * (colOrig & 255);
lumLeft = 77 * (colLeft >> 16 & 255) + 151 * (colLeft >> 8 & 255) + 28 * (colLeft & 255);
lumRight = 77 * (colRight >> 16 & 255) + 151 * (colRight >> 8 & 255) + 28 * (colRight & 255);
lumUp = 77 * (colUp >> 16 & 255) + 151 * (colUp >> 8 & 255) + 28 * (colUp & 255);
lumDown = 77 * (colDown >> 16 & 255) + 151 * (colDown >> 8 & 255) + 28 * (colDown & 255);
if (lumLeft > currLum) {
colOut = colLeft;
currLum = lumLeft;
}
if (lumRight > currLum) {
colOut = colRight;
currLum = lumRight;
}
if (lumUp > currLum) {
colOut = colUp;
currLum = lumUp;
}
if (lumDown > currLum) {
colOut = colDown;
currLum = lumDown;
}
out[currIdx++] = colOut;
}
}
Filters._setPixels(pixels, out);
};
Filters.erode = function (canvas) {
var pixels = Filters._toPixels(canvas);
var currIdx = 0;
var maxIdx = pixels.length ? pixels.length / 4 : 0;
var out = new Int32Array(maxIdx);
var currRowIdx, maxRowIdx, colOrig, colOut, currLum;
var idxRight, idxLeft, idxUp, idxDown, colRight, colLeft, colUp, colDown, lumRight, lumLeft, lumUp, lumDown;
while (currIdx < maxIdx) {
currRowIdx = currIdx;
maxRowIdx = currIdx + canvas.width;
while (currIdx < maxRowIdx) {
colOrig = colOut = Filters._getARGB(pixels, currIdx);
idxLeft = currIdx - 1;
idxRight = currIdx + 1;
idxUp = currIdx - canvas.width;
idxDown = currIdx + canvas.width;
if (idxLeft < currRowIdx) {
idxLeft = currIdx;
}
if (idxRight >= maxRowIdx) {
idxRight = currIdx;
}
if (idxUp < 0) {
idxUp = 0;
}
if (idxDown >= maxIdx) {
idxDown = currIdx;
}
colUp = Filters._getARGB(pixels, idxUp);
colLeft = Filters._getARGB(pixels, idxLeft);
colDown = Filters._getARGB(pixels, idxDown);
colRight = Filters._getARGB(pixels, idxRight);
currLum = 77 * (colOrig >> 16 & 255) + 151 * (colOrig >> 8 & 255) + 28 * (colOrig & 255);
lumLeft = 77 * (colLeft >> 16 & 255) + 151 * (colLeft >> 8 & 255) + 28 * (colLeft & 255);
lumRight = 77 * (colRight >> 16 & 255) + 151 * (colRight >> 8 & 255) + 28 * (colRight & 255);
lumUp = 77 * (colUp >> 16 & 255) + 151 * (colUp >> 8 & 255) + 28 * (colUp & 255);
lumDown = 77 * (colDown >> 16 & 255) + 151 * (colDown >> 8 & 255) + 28 * (colDown & 255);
if (lumLeft < currLum) {
colOut = colLeft;
currLum = lumLeft;
}
if (lumRight < currLum) {
colOut = colRight;
currLum = lumRight;
}
if (lumUp < currLum) {
colOut = colUp;
currLum = lumUp;
}
if (lumDown < currLum) {
colOut = colDown;
currLum = lumDown;
}
out[currIdx++] = colOut;
}
}
Filters._setPixels(pixels, out);
};
var blurRadius;
var blurKernelSize;
var blurKernel;
var blurMult;
function buildBlurKernel(r) {
var radius = r * 3.5 | 0;
radius = radius < 1 ? 1 : radius < 248 ? radius : 248;
if (blurRadius !== radius) {
blurRadius = radius;
blurKernelSize = 1 + blurRadius << 1;
blurKernel = new Int32Array(blurKernelSize);
blurMult = new Array(blurKernelSize);
for (var l = 0; l < blurKernelSize; l++) {
blurMult[l] = new Int32Array(256);
}
var bk, bki;
var bm, bmi;
for (var i = 1, radiusi = radius - 1; i < radius; i++) {
blurKernel[radius + i] = blurKernel[radiusi] = bki = radiusi * radiusi;
bm = blurMult[radius + i];
bmi = blurMult[radiusi--];
for (var j = 0; j < 256; j++) {
bm[j] = bmi[j] = bki * j;
}
}
bk = blurKernel[radius] = radius * radius;
bm = blurMult[radius];
for (var k = 0; k < 256; k++) {
bm[k] = bk * k;
}
}
}
function blurARGB(canvas, radius) {
var pixels = Filters._toPixels(canvas);
var width = canvas.width;
var height = canvas.height;
var numPackedPixels = width * height;
var argb = new Int32Array(numPackedPixels);
for (var j = 0; j < numPackedPixels; j++) {
argb[j] = Filters._getARGB(pixels, j);
}
var sum, cr, cg, cb, ca;
var read, ri, ym, ymi, bk0;
var a2 = new Int32Array(numPackedPixels);
var r2 = new Int32Array(numPackedPixels);
var g2 = new Int32Array(numPackedPixels);
var b2 = new Int32Array(numPackedPixels);
var yi = 0;
buildBlurKernel(radius);
var x, y, i;
var bm;
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
cb = cg = cr = ca = sum = 0;
read = x - blurRadius;
if (read < 0) {
bk0 = -read;
read = 0;
} else {
if (read >= width) {
break;
}
bk0 = 0;
}
for (i = bk0; i < blurKernelSize; i++) {
if (read >= width) {
break;
}
var c = argb[read + yi];
bm = blurMult[i];
ca += bm[(c & -16777216) >>> 24];
cr += bm[(c & 16711680) >> 16];
cg += bm[(c & 65280) >> 8];
cb += bm[c & 255];
sum += blurKernel[i];
read++;
}
ri = yi + x;
a2[ri] = ca / sum;
r2[ri] = cr / sum;
g2[ri] = cg / sum;
b2[ri] = cb / sum;
}
yi += width;
}
yi = 0;
ym = -blurRadius;
ymi = ym * width;
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
cb = cg = cr = ca = sum = 0;
if (ym < 0) {
bk0 = ri = -ym;
read = x;
} else {
if (ym >= height) {
break;
}
bk0 = 0;
ri = ym;
read = x + ymi;
}
for (i = bk0; i < blurKernelSize; i++) {
if (ri >= height) {
break;
}
bm = blurMult[i];
ca += bm[a2[read]];
cr += bm[r2[read]];
cg += bm[g2[read]];
cb += bm[b2[read]];
sum += blurKernel[i];
ri++;
read += width;
}
argb[x + yi] = ca / sum << 24 | cr / sum << 16 | cg / sum << 8 | cb / sum;
}
yi += width;
ymi += width;
ym++;
}
Filters._setPixels(pixels, argb);
}
Filters.blur = function (canvas, radius) {
blurARGB(canvas, radius);
};
return Filters;
}({});
amdclean['p5Image'] = function (require, core, filters) {
'use strict';
var p5 = core;
var Filters = filters;
p5.Image = function (width, height) {
this.width = width;
this.height = height;
this.canvas = document.createElement('canvas');
this.canvas.width = this.width;
this.canvas.height = this.height;
this.drawingContext = this.canvas.getContext('2d');
this.pixels = [];
};
p5.Image.prototype._setProperty = function (prop, value) {
this[prop] = value;
};
p5.Image.prototype.loadPixels = function () {
p5.prototype.loadPixels.call(this);
};
p5.Image.prototype.updatePixels = function (x, y, w, h) {
p5.prototype.updatePixels.call(this, x, y, w, h);
};
p5.Image.prototype.get = function (x, y, w, h) {
return p5.prototype.get.call(this, x, y, w, h);
};
p5.Image.prototype.set = function (x, y, imgOrCol) {
p5.prototype.set.call(this, x, y, imgOrCol);
};
p5.Image.prototype.resize = function (width, height) {
width = width || this.canvas.width;
height = height || this.canvas.height;
var tempCanvas = document.createElement('canvas');
tempCanvas.width = width;
tempCanvas.height = height;
tempCanvas.getContext('2d').drawImage(this.canvas, 0, 0, this.canvas.width, this.canvas.height, 0, 0, tempCanvas.width, tempCanvas.height);
this.canvas.width = this.width = width;
this.canvas.height = this.height = height;
this.drawingContext.drawImage(tempCanvas, 0, 0, width, height, 0, 0, width, height);
if (this.pixels.length > 0) {
this.loadPixels();
}
};
p5.Image.prototype.copy = function () {
p5.prototype.copy.apply(this, arguments);
};
p5.Image.prototype.mask = function (p5Image) {
if (p5Image === undefined) {
p5Image = this;
}
var currBlend = this.drawingContext.globalCompositeOperation;
var scaleFactor = 1;
if (p5Image instanceof p5.Graphics) {
scaleFactor = p5Image._pInst._pixelDensity;
}
var copyArgs = [
p5Image,
0,
0,
scaleFactor * p5Image.width,
scaleFactor * p5Image.height,
0,
0,
this.width,
this.height
];
this.drawingContext.globalCompositeOperation = 'destination-in';
this.copy.apply(this, copyArgs);
this.drawingContext.globalCompositeOperation = currBlend;
};
p5.Image.prototype.filter = function (operation, value) {
Filters.apply(this.canvas, Filters[operation.toLowerCase()], value);
};
p5.Image.prototype.blend = function () {
p5.prototype.blend.apply(this, arguments);
};
p5.Image.prototype.save = function (filename, extension) {
var mimeType;
if (!extension) {
extension = 'png';
mimeType = 'image/png';
} else {
switch (extension.toLowerCase()) {
case 'png':
mimeType = 'image/png';
break;
case 'jpeg':
mimeType = 'image/jpeg';
break;
case 'jpg':
mimeType = 'image/jpeg';
break;
default:
mimeType = 'image/png';
break;
}
}
var downloadMime = 'image/octet-stream';
var imageData = this.canvas.toDataURL(mimeType);
imageData = imageData.replace(mimeType, downloadMime);
p5.prototype.downloadFile(imageData, filename, extension);
};
return p5.Image;
}({}, amdclean['core'], amdclean['filters']);
amdclean['p5File'] = function (require, core) {
var p5 = core;
p5.File = function (file, pInst) {
this.file = file;
this._pInst = pInst;
var typeList = file.type.split('/');
this.type = typeList[0];
this.subtype = typeList[1];
this.name = file.name;
this.size = file.size;
this.data = undefined;
};
return p5.File;
}({}, amdclean['core']);
amdclean['polargeometry'] = function (require) {
return {
degreesToRadians: function (x) {
return 2 * Math.PI * x / 360;
},
radiansToDegrees: function (x) {
return 360 * x / (2 * Math.PI);
}
};
}({});
amdclean['p5Vector'] = function (require, core, polargeometry, constants) {
'use strict';
var p5 = core;
var polarGeometry = polargeometry;
var constants = constants;
p5.Vector = function () {
var x, y, z;
if (arguments[0] instanceof p5) {
this.p5 = arguments[0];
x = arguments[1][0] || 0;
y = arguments[1][1] || 0;
z = arguments[1][2] || 0;
} else {
x = arguments[0] || 0;
y = arguments[1] || 0;
z = arguments[2] || 0;
}
this.x = x;
this.y = y;
this.z = z;
};
p5.Vector.prototype.set = function (x, y, z) {
if (x instanceof p5.Vector) {
this.x = x.x || 0;
this.y = x.y || 0;
this.z = x.z || 0;
return this;
}
if (x instanceof Array) {
this.x = x[0] || 0;
this.y = x[1] || 0;
this.z = x[2] || 0;
return this;
}
this.x = x || 0;
this.y = y || 0;
this.z = z || 0;
return this;
};
p5.Vector.prototype.copy = function () {
if (this.p5) {
return new p5.Vector(this.p5, [
this.x,
this.y,
this.z
]);
} else {
return new p5.Vector(this.x, this.y, this.z);
}
};
p5.Vector.prototype.add = function (x, y, z) {
if (x instanceof p5.Vector) {
this.x += x.x || 0;
this.y += x.y || 0;
this.z += x.z || 0;
return this;
}
if (x instanceof Array) {
this.x += x[0] || 0;
this.y += x[1] || 0;
this.z += x[2] || 0;
return this;
}
this.x += x || 0;
this.y += y || 0;
this.z += z || 0;
return this;
};
p5.Vector.prototype.sub = function (x, y, z) {
if (x instanceof p5.Vector) {
this.x -= x.x || 0;
this.y -= x.y || 0;
this.z -= x.z || 0;
return this;
}
if (x instanceof Array) {
this.x -= x[0] || 0;
this.y -= x[1] || 0;
this.z -= x[2] || 0;
return this;
}
this.x -= x || 0;
this.y -= y || 0;
this.z -= z || 0;
return this;
};
p5.Vector.prototype.mult = function (n) {
this.x *= n || 0;
this.y *= n || 0;
this.z *= n || 0;
return this;
};
p5.Vector.prototype.div = function (n) {
this.x /= n;
this.y /= n;
this.z /= n;
return this;
};
p5.Vector.prototype.mag = function () {
return Math.sqrt(this.magSq());
};
p5.Vector.prototype.magSq = function () {
var x = this.x, y = this.y, z = this.z;
return x * x + y * y + z * z;
};
p5.Vector.prototype.dot = function (x, y, z) {
if (x instanceof p5.Vector) {
return this.dot(x.x, x.y, x.z);
}
return this.x * (x || 0) + this.y * (y || 0) + this.z * (z || 0);
};
p5.Vector.prototype.cross = function (v) {
var x = this.y * v.z - this.z * v.y;
var y = this.z * v.x - this.x * v.z;
var z = this.x * v.y - this.y * v.x;
if (this.p5) {
return new p5.Vector(this.p5, [
x,
y,
z
]);
} else {
return new p5.Vector(x, y, z);
}
};
p5.Vector.prototype.dist = function (v) {
var d = v.copy().sub(this);
return d.mag();
};
p5.Vector.prototype.normalize = function () {
return this.div(this.mag());
};
p5.Vector.prototype.limit = function (l) {
var mSq = this.magSq();
if (mSq > l * l) {
this.div(Math.sqrt(mSq));
this.mult(l);
}
return this;
};
p5.Vector.prototype.setMag = function (n) {
return this.normalize().mult(n);
};
p5.Vector.prototype.heading = function () {
var h = Math.atan2(this.y, this.x);
if (this.p5) {
if (this.p5._angleMode === constants.RADIANS) {
return h;
} else {
return polarGeometry.radiansToDegrees(h);
}
} else {
return h;
}
};
p5.Vector.prototype.rotate = function (a) {
if (this.p5) {
if (this.p5._angleMode === constants.DEGREES) {
a = polarGeometry.degreesToRadians(a);
}
}
var newHeading = this.heading() + a;
var mag = this.mag();
this.x = Math.cos(newHeading) * mag;
this.y = Math.sin(newHeading) * mag;
return this;
};
p5.Vector.prototype.lerp = function (x, y, z, amt) {
if (x instanceof p5.Vector) {
return this.lerp(x.x, x.y, x.z, y);
}
this.x += (x - this.x) * amt || 0;
this.y += (y - this.y) * amt || 0;
this.z += (z - this.z) * amt || 0;
return this;
};
p5.Vector.prototype.array = function () {
return [
this.x || 0,
this.y || 0,
this.z || 0
];
};
p5.Vector.fromAngle = function (angle) {
if (this.p5) {
if (this.p5._angleMode === constants.DEGREES) {
angle = polarGeometry.degreesToRadians(angle);
}
}
if (this.p5) {
return new p5.Vector(this.p5, [
Math.cos(angle),
Math.sin(angle),
0
]);
} else {
return new p5.Vector(Math.cos(angle), Math.sin(angle), 0);
}
};
p5.Vector.random2D = function () {
var angle;
if (this.p5) {
if (this.p5._angleMode === constants.DEGREES) {
angle = this.p5.random(360);
} else {
angle = this.p5.random(constants.TWO_PI);
}
} else {
angle = Math.random() * Math.PI * 2;
}
return this.fromAngle(angle);
};
p5.Vector.random3D = function () {
var angle, vz;
if (this.p5) {
angle = this.p5.random(0, constants.TWO_PI);
vz = this.p5.random(-1, 1);
} else {
angle = Math.random() * Math.PI * 2;
vz = Math.random() * 2 - 1;
}
var vx = Math.sqrt(1 - vz * vz) * Math.cos(angle);
var vy = Math.sqrt(1 - vz * vz) * Math.sin(angle);
if (this.p5) {
return new p5.Vector(this.p5, [
vx,
vy,
vz
]);
} else {
return new p5.Vector(vx, vy, vz);
}
};
p5.Vector.add = function (v1, v2, target) {
if (!target) {
target = v1.copy();
} else {
target.set(v1);
}
target.add(v2);
return target;
};
p5.Vector.sub = function (v1, v2, target) {
if (!target) {
target = v1.copy();
} else {
target.set(v1);
}
target.sub(v2);
return target;
};
p5.Vector.mult = function (v, n, target) {
if (!target) {
target = v.copy();
} else {
target.set(v);
}
target.mult(n);
return target;
};
p5.Vector.div = function (v, n, target) {
if (!target) {
target = v.copy();
} else {
target.set(v);
}
target.div(n);
return target;
};
p5.Vector.dot = function (v1, v2) {
return v1.dot(v2);
};
p5.Vector.cross = function (v1, v2) {
return v1.cross(v2);
};
p5.Vector.dist = function (v1, v2) {
return v1.dist(v2);
};
p5.Vector.lerp = function (v1, v2, amt, target) {
if (!target) {
target = v1.copy();
} else {
target.set(v1);
}
target.lerp(v2, amt);
return target;
};
p5.Vector.angleBetween = function (v1, v2) {
var angle = Math.acos(v1.dot(v2) / (v1.mag() * v2.mag()));
if (this.p5) {
if (this.p5._angleMode === constants.DEGREES) {
angle = polarGeometry.radiansToDegrees(angle);
}
}
return angle;
};
return p5.Vector;
}({}, amdclean['core'], amdclean['polargeometry'], amdclean['constants']);
amdclean['p5TableRow'] = function (require, core) {
'use strict';
var p5 = core;
p5.TableRow = function (str, separator) {
var arr = [];
var obj = {};
if (str) {
separator = separator || ',';
arr = str.split(separator);
}
for (var i = 0; i < arr.length; i++) {
var key = i;
var val = arr[i];
obj[key] = val;
}
this.arr = arr;
this.obj = obj;
this.table = null;
};
p5.TableRow.prototype.set = function (column, value) {
if (typeof column === 'string') {
var cPos = this.table.columns.indexOf(column);
if (cPos >= 0) {
this.obj[column] = value;
this.arr[cPos] = value;
} else {
throw 'This table has no column named "' + column + '"';
}
} else {
if (column < this.table.columns.length) {
this.arr[column] = value;
var cTitle = this.table.columns[column];
this.obj[cTitle] = value;
} else {
throw 'Column #' + column + ' is out of the range of this table';
}
}
};
p5.TableRow.prototype.setNum = function (column, value) {
var floatVal = parseFloat(value, 10);
this.set(column, floatVal);
};
p5.TableRow.prototype.setString = function (column, value) {
var stringVal = value.toString();
this.set(column, stringVal);
};
p5.TableRow.prototype.get = function (column) {
if (typeof column === 'string') {
return this.obj[column];
} else {
return this.arr[column];
}
};
p5.TableRow.prototype.getNum = function (column) {
var ret;
if (typeof column === 'string') {
ret = parseFloat(this.obj[column], 10);
} else {
ret = parseFloat(this.arr[column], 10);
}
if (ret.toString() === 'NaN') {
throw 'Error: ' + this.obj[column] + ' is NaN (Not a Number)';
}
return ret;
};
p5.TableRow.prototype.getString = function (column) {
if (typeof column === 'string') {
return this.obj[column].toString();
} else {
return this.arr[column].toString();
}
};
return p5.TableRow;
}({}, amdclean['core']);
amdclean['p5Table'] = function (require, core) {
'use strict';
var p5 = core;
p5.Table = function (rows) {
this.columns = [];
this.rows = [];
};
p5.Table.prototype.addRow = function (row) {
var r = row || new p5.TableRow();
if (typeof r.arr === 'undefined' || typeof r.obj === 'undefined') {
throw 'invalid TableRow: ' + r;
}
r.table = this;
this.rows.push(r);
return r;
};
p5.Table.prototype.removeRow = function (id) {
this.rows[id].table = null;
var chunk = this.rows.splice(id + 1, this.rows.length);
this.rows.pop();
this.rows = this.rows.concat(chunk);
};
p5.Table.prototype.getRow = function (r) {
return this.rows[r];
};
p5.Table.prototype.getRows = function () {
return this.rows;
};
p5.Table.prototype.findRow = function (value, column) {
if (typeof column === 'string') {
for (var i = 0; i < this.rows.length; i++) {
if (this.rows[i].obj[column] === value) {
return this.rows[i];
}
}
} else {
for (var j = 0; j < this.rows.length; j++) {
if (this.rows[j].arr[column] === value) {
return this.rows[j];
}
}
}
return null;
};
p5.Table.prototype.findRows = function (value, column) {
var ret = [];
if (typeof column === 'string') {
for (var i = 0; i < this.rows.length; i++) {
if (this.rows[i].obj[column] === value) {
ret.push(this.rows[i]);
}
}
} else {
for (var j = 0; j < this.rows.length; j++) {
if (this.rows[j].arr[column] === value) {
ret.push(this.rows[j]);
}
}
}
return ret;
};
p5.Table.prototype.matchRow = function (regexp, column) {
if (typeof column === 'number') {
for (var j = 0; j < this.rows.length; j++) {
if (this.rows[j].arr[column].match(regexp)) {
return this.rows[j];
}
}
} else {
for (var i = 0; i < this.rows.length; i++) {
if (this.rows[i].obj[column].match(regexp)) {
return this.rows[i];
}
}
}
return null;
};
p5.Table.prototype.matchRows = function (regexp, column) {
var ret = [];
if (typeof column === 'number') {
for (var j = 0; j < this.rows.length; j++) {
if (this.rows[j].arr[column].match(regexp)) {
ret.push(this.rows[j]);
}
}
} else {
for (var i = 0; i < this.rows.length; i++) {
if (this.rows[i].obj[column].match(regexp)) {
ret.push(this.rows[i]);
}
}
}
return ret;
};
p5.Table.prototype.getColumn = function (value) {
var ret = [];
if (typeof value === 'string') {
for (var i = 0; i < this.rows.length; i++) {
ret.push(this.rows[i].obj[value]);
}
} else {
for (var j = 0; j < this.rows.length; j++) {
ret.push(this.rows[j].arr[value]);
}
}
return ret;
};
p5.Table.prototype.clearRows = function () {
delete this.rows;
this.rows = [];
};
p5.Table.prototype.addColumn = function (title) {
var t = title || null;
this.columns.push(t);
};
p5.Table.prototype.getColumnCount = function () {
return this.columns.length;
};
p5.Table.prototype.getRowCount = function () {
return this.rows.length;
};
p5.Table.prototype.removeTokens = function (chars, column) {
var escape = function (s) {
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
};
var charArray = [];
for (var i = 0; i < chars.length; i++) {
charArray.push(escape(chars.charAt(i)));
}
var regex = new RegExp(charArray.join('|'), 'g');
if (typeof column === 'undefined') {
for (var c = 0; c < this.columns.length; c++) {
for (var d = 0; d < this.rows.length; d++) {
var s = this.rows[d].arr[c];
s = s.replace(regex, '');
this.rows[d].arr[c] = s;
this.rows[d].obj[this.columns[c]] = s;
}
}
} else if (typeof column === 'string') {
for (var j = 0; j < this.rows.length; j++) {
var val = this.rows[j].obj[column];
val = val.replace(regex, '');
this.rows[j].obj[column] = val;
var pos = this.columns.indexOf(column);
this.rows[j].arr[pos] = val;
}
} else {
for (var k = 0; k < this.rows.length; k++) {
var str = this.rows[k].arr[column];
str = str.replace(regex, '');
this.rows[k].arr[column] = str;
this.rows[k].obj[this.columns[column]] = str;
}
}
};
p5.Table.prototype.trim = function (column) {
var regex = new RegExp(' ', 'g');
if (typeof column === 'undefined') {
for (var c = 0; c < this.columns.length; c++) {
for (var d = 0; d < this.rows.length; d++) {
var s = this.rows[d].arr[c];
s = s.replace(regex, '');
this.rows[d].arr[c] = s;
this.rows[d].obj[this.columns[c]] = s;
}
}
} else if (typeof column === 'string') {
for (var j = 0; j < this.rows.length; j++) {
var val = this.rows[j].obj[column];
val = val.replace(regex, '');
this.rows[j].obj[column] = val;
var pos = this.columns.indexOf(column);
this.rows[j].arr[pos] = val;
}
} else {
for (var k = 0; k < this.rows.length; k++) {
var str = this.rows[k].arr[column];
str = str.replace(regex, '');
this.rows[k].arr[column] = str;
this.rows[k].obj[this.columns[column]] = str;
}
}
};
p5.Table.prototype.removeColumn = function (c) {
var cString;
var cNumber;
if (typeof c === 'string') {
cString = c;
cNumber = this.columns.indexOf(c);
console.log('string');
} else {
cNumber = c;
cString = this.columns[c];
}
var chunk = this.columns.splice(cNumber + 1, this.columns.length);
this.columns.pop();
this.columns = this.columns.concat(chunk);
for (var i = 0; i < this.rows.length; i++) {
var tempR = this.rows[i].arr;
var chip = tempR.splice(cNumber + 1, tempR.length);
tempR.pop();
this.rows[i].arr = tempR.concat(chip);
delete this.rows[i].obj[cString];
}
};
p5.Table.prototype.set = function (row, column, value) {
this.rows[row].set(column, value);
};
p5.Table.prototype.setNum = function (row, column, value) {
this.rows[row].set(column, value);
};
p5.Table.prototype.setString = function (row, column, value) {
this.rows[row].set(column, value);
};
p5.Table.prototype.get = function (row, column) {
return this.rows[row].get(column);
};
p5.Table.prototype.getNum = function (row, column) {
return this.rows[row].getNum(column);
};
p5.Table.prototype.getString = function (row, column) {
return this.rows[row].getString(column);
};
return p5.Table;
}({}, amdclean['core']);
amdclean['colorcreating_reading'] = function (require, core, p5Color) {
'use strict';
var p5 = core;
p5.prototype.alpha = function (c) {
if (c instanceof p5.Color || c instanceof Array) {
return this.color(c).getAlpha();
} else {
throw new Error('Needs p5.Color or pixel array as argument.');
}
};
p5.prototype.blue = function (c) {
if (c instanceof p5.Color || c instanceof Array) {
return this.color(c).getBlue();
} else {
throw new Error('Needs p5.Color or pixel array as argument.');
}
};
p5.prototype.brightness = function (c) {
if (!c instanceof p5.Color) {
throw new Error('Needs p5.Color as argument.');
}
return c.getBrightness();
};
p5.prototype.color = function () {
if (arguments[0] instanceof p5.Color) {
return arguments[0];
} else if (arguments[0] instanceof Array) {
return new p5.Color(this, arguments[0]);
} else {
var args = Array.prototype.slice.call(arguments);
return new p5.Color(this, args);
}
};
p5.prototype.green = function (c) {
if (c instanceof p5.Color || c instanceof Array) {
return this.color(c).getGreen();
} else {
throw new Error('Needs p5.Color or pixel array as argument.');
}
};
p5.prototype.hue = function (c) {
if (!c instanceof p5.Color) {
throw new Error('Needs p5.Color as argument.');
}
return c.getHue();
};
p5.prototype.lerpColor = function (c1, c2, amt) {
if (c1 instanceof Array) {
var c = [];
for (var i = 0; i < c1.length; i++) {
c.push(p5.prototype.lerp(c1[i], c2[i], amt));
}
return c;
} else if (c1 instanceof p5.Color) {
var pc = [];
for (var j = 0; j < 4; j++) {
pc.push(p5.prototype.lerp(c1.rgba[j], c2.rgba[j], amt));
}
return new p5.Color(this, pc);
} else {
return p5.prototype.lerp(c1, c2, amt);
}
};
p5.prototype.red = function (c) {
if (c instanceof p5.Color || c instanceof Array) {
return this.color(c).getRed();
} else {
throw new Error('Needs p5.Color or pixel array as argument.');
}
};
p5.prototype.saturation = function (c) {
if (!c instanceof p5.Color) {
throw new Error('Needs p5.Color as argument.');
}
return c.getSaturation();
};
return p5;
}({}, amdclean['core'], amdclean['p5Color']);
amdclean['colorsetting'] = function (require, core, constants, p5Color) {
'use strict';
var p5 = core;
var constants = constants;
p5.prototype._doStroke = true;
p5.prototype._doFill = true;
p5.prototype._colorMode = constants.RGB;
p5.prototype._maxRGB = [
255,
255,
255,
255
];
p5.prototype._maxHSB = [
255,
255,
255,
255
];
p5.prototype.background = function () {
this.drawingContext.save();
this.drawingContext.setTransform(1, 0, 0, 1, 0, 0);
this.drawingContext.scale(this._pixelDensity, this._pixelDensity);
if (arguments[0] instanceof p5.Image) {
this.image(arguments[0], 0, 0, this.width, this.height);
} else {
var curFill = this.drawingContext.fillStyle;
var color = this.color.apply(this, arguments);
var newFill = color.toString();
this.drawingContext.fillStyle = newFill;
this.drawingContext.fillRect(0, 0, this.width, this.height);
this.drawingContext.fillStyle = curFill;
}
this.drawingContext.restore();
};
p5.prototype.clear = function () {
this.drawingContext.clearRect(0, 0, this.width, this.height);
};
p5.prototype.colorMode = function () {
if (arguments[0] === constants.RGB || arguments[0] === constants.HSB) {
this._colorMode = arguments[0];
var isRGB = this._colorMode === constants.RGB;
var maxArr = isRGB ? this._maxRGB : this._maxHSB;
if (arguments.length === 2) {
maxArr[0] = arguments[1];
maxArr[1] = arguments[1];
maxArr[2] = arguments[1];
maxArr[3] = arguments[1];
} else if (arguments.length > 2) {
maxArr[0] = arguments[1];
maxArr[1] = arguments[2];
maxArr[2] = arguments[3];
}
if (arguments.length === 5) {
maxArr[3] = arguments[4];
}
}
};
p5.prototype.fill = function () {
this._setProperty('_doFill', true);
var ctx = this.drawingContext;
var color = this.color.apply(this, arguments);
ctx.fillStyle = color.toString();
};
p5.prototype.noFill = function () {
this._setProperty('_doFill', false);
};
p5.prototype.noStroke = function () {
this._setProperty('_doStroke', false);
};
p5.prototype.stroke = function () {
this._setProperty('_doStroke', true);
var ctx = this.drawingContext;
var color = this.color.apply(this, arguments);
ctx.strokeStyle = color.toString();
};
return p5;
}({}, amdclean['core'], amdclean['constants'], amdclean['p5Color']);
amdclean['dataconversion'] = function (require, core) {
'use strict';
var p5 = core;
p5.prototype.float = function (str) {
return parseFloat(str);
};
p5.prototype.int = function (n, radix) {
if (typeof n === 'string') {
radix = radix || 10;
return parseInt(n, radix);
} else if (typeof n === 'number') {
return n | 0;
} else if (typeof n === 'boolean') {
return n ? 1 : 0;
} else if (n instanceof Array) {
return n.map(p5.prototype.int);
}
};
return p5;
}({}, amdclean['core']);
amdclean['dataarray_functions'] = function (require, core) {
'use strict';
var p5 = core;
p5.prototype.append = function (array, value) {
array.push(value);
return array;
};
p5.prototype.arrayCopy = function (src, srcPosition, dst, dstPosition, length) {
var start, end;
if (typeof length !== 'undefined') {
end = Math.min(length, src.length);
start = dstPosition;
src = src.slice(srcPosition, end + srcPosition);
} else {
if (typeof dst !== 'undefined') {
end = dst;
end = Math.min(end, src.length);
} else {
end = src.length;
}
start = 0;
dst = srcPosition;
src = src.slice(0, end);
}
Array.prototype.splice.apply(dst, [
start,
end
].concat(src));
};
p5.prototype.concat = function (list0, list1) {
return list0.concat(list1);
};
p5.prototype.reverse = function (list) {
return list.reverse();
};
p5.prototype.shorten = function (list) {
list.pop();
return list;
};
p5.prototype.shuffle = function (arr, bool) {
arr = bool || ArrayBuffer.isView(arr) ? arr : arr.slice();
var rnd, tmp, idx = arr.length;
while (idx > 1) {
rnd = Math.random() * idx | 0;
tmp = arr[--idx];
arr[idx] = arr[rnd];
arr[rnd] = tmp;
}
return arr;
};
p5.prototype.sort = function (list, count) {
var arr = count ? list.slice(0, Math.min(count, list.length)) : list;
var rest = count ? list.slice(Math.min(count, list.length)) : [];
if (typeof arr[0] === 'string') {
arr = arr.sort();
} else {
arr = arr.sort(function (a, b) {
return a - b;
});
}
return arr.concat(rest);
};
p5.prototype.splice = function (list, value, index) {
Array.prototype.splice.apply(list, [
index,
0
].concat(value));
return list;
};
p5.prototype.subset = function (list, start, count) {
if (typeof count !== 'undefined') {
return list.slice(start, start + count);
} else {
return list.slice(start, list.length);
}
};
return p5;
}({}, amdclean['core']);
amdclean['datastring_functions'] = function (require, core) {
'use strict';
var p5 = core;
p5.prototype.join = function (list, separator) {
return list.join(separator);
};
p5.prototype.match = function (str, reg) {
return str.match(reg);
};
p5.prototype.matchAll = function (str, reg) {
var re = new RegExp(reg, 'g');
var match = re.exec(str);
var matches = [];
while (match !== null) {
matches.push(match);
match = re.exec(str);
}
return matches;
};
p5.prototype.nf = function () {
if (arguments[0] instanceof Array) {
var a = arguments[1];
var b = arguments[2];
return arguments[0].map(function (x) {
return doNf(x, a, b);
});
} else {
return doNf.apply(this, arguments);
}
};
function doNf() {
var num = arguments[0];
var neg = num < 0;
var n = neg ? num.toString().substring(1) : num.toString();
var decimalInd = n.indexOf('.');
var intPart = decimalInd !== -1 ? n.substring(0, decimalInd) : n;
var decPart = decimalInd !== -1 ? n.substring(decimalInd + 1) : '';
var str = neg ? '-' : '';
if (arguments.length === 3) {
for (var i = 0; i < arguments[1] - intPart.length; i++) {
str += '0';
}
str += intPart;
str += '.';
str += decPart;
for (var j = 0; j < arguments[2] - decPart.length; j++) {
str += '0';
}
return str;
} else {
for (var k = 0; k < Math.max(arguments[1] - intPart.length, 0); k++) {
str += '0';
}
str += n;
return str;
}
}
p5.prototype.nfc = function () {
if (arguments[0] instanceof Array) {
var a = arguments[1];
return arguments[0].map(function (x) {
return doNfc(x, a);
});
} else {
return doNfc.apply(this, arguments);
}
};
function doNfc() {
var num = arguments[0].toString();
var dec = num.indexOf('.');
var rem = dec !== -1 ? num.substring(dec) : '';
var n = dec !== -1 ? num.substring(0, dec) : num;
n = n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
if (arguments[1] === 0) {
rem = '';
}
if (arguments.length > 1) {
rem = rem.substring(0, arguments[1] + 1);
}
return n + rem;
}
p5.prototype.nfp = function () {
var nfRes = this.nf(arguments);
if (nfRes instanceof Array) {
return nfRes.map(addNfp);
} else {
return addNfp(nfRes);
}
};
function addNfp() {
return parseFloat(arguments[0]) > 0 ? '+' + arguments[0].toString() : arguments[0].toString();
}
p5.prototype.nfs = function () {
var nfRes = this.nf(arguments);
if (nfRes instanceof Array) {
return nfRes.map(addNfs);
} else {
return addNfs(nfRes);
}
};
function addNfs() {
return parseFloat(arguments[0]) > 0 ? ' ' + arguments[0].toString() : arguments[0].toString();
}
p5.prototype.split = function (str, delim) {
return str.split(delim);
};
p5.prototype.splitTokens = function () {
var d = arguments.length > 0 ? arguments[1] : /\s/g;
return arguments[0].split(d).filter(function (n) {
return n;
});
};
p5.prototype.trim = function (str) {
if (str instanceof Array) {
return str.map(this.trim);
} else {
return str.trim();
}
};
return p5;
}({}, amdclean['core']);
amdclean['environment'] = function (require, core, constants) {
'use strict';
var p5 = core;
var C = constants;
var standardCursors = [
C.ARROW,
C.CROSS,
C.HAND,
C.MOVE,
C.TEXT,
C.WAIT
];
p5.prototype._frameRate = 0;
p5.prototype._lastFrameTime = new Date().getTime();
p5.prototype._targetFrameRate = 60;
p5.prototype.frameCount = 0;
p5.prototype.focused = true;
p5.prototype.cursor = function (type, x, y) {
var cursor = 'auto';
var canvas = this._curElement.elt;
if (standardCursors.indexOf(type) > -1) {
cursor = type;
} else if (typeof type === 'string') {
var coords = '';
if (x && y && (typeof x === 'number' && typeof y === 'number')) {
coords = x + ' ' + y;
}
if (type.substring(0, 6) !== 'http://') {
cursor = 'url(' + type + ') ' + coords + ', auto';
} else if (/\.(cur|jpg|jpeg|gif|png|CUR|JPG|JPEG|GIF|PNG)$/.test(type)) {
cursor = 'url(' + type + ') ' + coords + ', auto';
} else {
cursor = type;
}
}
canvas.style.cursor = cursor;
};
p5.prototype.frameRate = function (fps) {
if (typeof fps === 'undefined') {
return this._frameRate;
} else {
this._setProperty('_targetFrameRate', fps);
this._runFrames();
return this;
}
};
p5.prototype.getFrameRate = function () {
return this.frameRate();
};
p5.prototype.setFrameRate = function (fps) {
return this.frameRate(fps);
};
p5.prototype.noCursor = function () {
this._curElement.elt.style.cursor = 'none';
};
p5.prototype.displayWidth = screen.width;
p5.prototype.displayHeight = screen.height;
p5.prototype.windowWidth = window.innerWidth;
p5.prototype.windowHeight = window.innerHeight;
p5.prototype._onresize = function (e) {
this._setProperty('windowWidth', window.innerWidth);
this._setProperty('windowHeight', window.innerHeight);
var context = this._isGlobal ? window : this;
var executeDefault;
if (typeof context.windowResized === 'function') {
executeDefault = context.windowResized(e);
if (executeDefault !== undefined && !executeDefault) {
e.preventDefault();
}
}
};
p5.prototype.width = 0;
p5.prototype.height = 0;
p5.prototype.fullscreen = function (val) {
if (typeof val === 'undefined') {
return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement;
} else {
if (val) {
launchFullscreen(document.documentElement);
} else {
exitFullscreen();
}
}
};
p5.prototype.devicePixelScaling = function (val) {
if (val) {
if (typeof val === 'number') {
this._pixelDensity = val;
} else {
this._pixelDensity = window.devicePixelRatio || 1;
}
} else {
this._pixelDensity = 1;
}
this.resizeCanvas(this.width, this.height, true);
};
function launchFullscreen(element) {
var enabled = document.fullscreenEnabled || document.webkitFullscreenEnabled || document.mozFullScreenEnabled || document.msFullscreenEnabled;
if (!enabled) {
throw new Error('Fullscreen not enabled in this browser.');
}
if (element.requestFullscreen) {
element.requestFullscreen();
} else if (element.mozRequestFullScreen) {
element.mozRequestFullScreen();
} else if (element.webkitRequestFullscreen) {
element.webkitRequestFullscreen();
} else if (element.msRequestFullscreen) {
element.msRequestFullscreen();
}
}
function exitFullscreen() {
if (document.exitFullscreen) {
document.exitFullscreen();
} else if (document.mozCancelFullScreen) {
document.mozCancelFullScreen();
} else if (document.webkitExitFullscreen) {
document.webkitExitFullscreen();
} else if (document.msExitFullscreen) {
document.msExitFullscreen();
}
}
p5.prototype.getURL = function () {
return location.href;
};
p5.prototype.getURLPath = function () {
return location.pathname.split('/').filter(function (v) {
return v !== '';
});
};
p5.prototype.getURLParams = function () {
var re = /[?&]([^&=]+)(?:[&=])([^&=]+)/gim;
var m;
var v = {};
while ((m = re.exec(location.search)) != null) {
if (m.index === re.lastIndex) {
re.lastIndex++;
}
v[m[1]] = m[2];
}
return v;
};
return p5;
}({}, amdclean['core'], amdclean['constants']);
amdclean['imageimage'] = function (require, core, constants) {
'use strict';
var p5 = core;
var constants = constants;
p5.prototype._imageMode = constants.CORNER;
p5.prototype._tint = null;
p5.prototype.createImage = function (width, height) {
return new p5.Image(width, height);
};
return p5;
}({}, amdclean['core'], amdclean['constants']);
amdclean['canvas'] = function (require, constants) {
var constants = constants;
return {
modeAdjust: function (a, b, c, d, mode) {
if (mode === constants.CORNER) {
return {
x: a,
y: b,
w: c,
h: d
};
} else if (mode === constants.CORNERS) {
return {
x: a,
y: b,
w: c - a,
h: d - b
};
} else if (mode === constants.RADIUS) {
return {
x: a - c,
y: b - d,
w: 2 * c,
h: 2 * d
};
} else if (mode === constants.CENTER) {
return {
x: a - c * 0.5,
y: b - d * 0.5,
w: c,
h: d
};
}
},
arcModeAdjust: function (a, b, c, d, mode) {
if (mode === constants.CORNER) {
return {
x: a + c * 0.5,
y: b + d * 0.5,
w: c,
h: d
};
} else if (mode === constants.CORNERS) {
return {
x: a,
y: b,
w: c + a,
h: d + b
};
} else if (mode === constants.RADIUS) {
return {
x: a,
y: b,
w: 2 * c,
h: 2 * d
};
} else if (mode === constants.CENTER) {
return {
x: a,
y: b,
w: c,
h: d
};
}
}
};
}({}, amdclean['constants']);
amdclean['imageloading_displaying'] = function (require, core, filters, canvas, constants) {
'use strict';
var p5 = core;
var Filters = filters;
var canvas = canvas;
var constants = constants;
p5.prototype.loadImage = function (path, successCallback, failureCallback) {
var img = new Image();
var pImg = new p5.Image(1, 1, this);
img.onload = function () {
pImg.width = pImg.canvas.width = img.width;
pImg.height = pImg.canvas.height = img.height;
pImg.canvas.getContext('2d').drawImage(img, 0, 0);
if (typeof successCallback === 'function') {
successCallback(pImg);
}
};
img.onerror = function (e) {
if (typeof failureCallback === 'function') {
failureCallback(e);
}
};
if (path.indexOf('data:image/') !== 0) {
img.crossOrigin = 'Anonymous';
}
img.src = path;
return pImg;
};
p5.prototype.image = function (img, x, y, width, height) {
var frame = img.canvas || img.elt;
x = x || 0;
y = y || 0;
width = width || img.width;
height = height || img.height;
var vals = canvas.modeAdjust(x, y, width, height, this._imageMode);
try {
if (this._tint && img.canvas) {
this.drawingContext.drawImage(this._getTintedImageCanvas(img), vals.x, vals.y, vals.w, vals.h);
} else {
this.drawingContext.drawImage(frame, vals.x, vals.y, vals.w, vals.h);
}
} catch (e) {
if (e.name !== 'NS_ERROR_NOT_AVAILABLE') {
throw e;
}
}
};
p5.prototype.tint = function () {
var c = this.color.apply(this, arguments);
this._tint = c.rgba;
};
p5.prototype.noTint = function () {
this._tint = null;
};
p5.prototype._getTintedImageCanvas = function (img) {
if (!img.canvas) {
return img;
}
var pixels = Filters._toPixels(img.canvas);
var tmpCanvas = document.createElement('canvas');
tmpCanvas.width = img.canvas.width;
tmpCanvas.height = img.canvas.height;
var tmpCtx = tmpCanvas.getContext('2d');
var id = tmpCtx.createImageData(img.canvas.width, img.canvas.height);
var newPixels = id.data;
for (var i = 0; i < pixels.length; i += 4) {
var r = pixels[i];
var g = pixels[i + 1];
var b = pixels[i + 2];
var a = pixels[i + 3];
newPixels[i] = r * this._tint[0] / 255;
newPixels[i + 1] = g * this._tint[1] / 255;
newPixels[i + 2] = b * this._tint[2] / 255;
newPixels[i + 3] = a * this._tint[3] / 255;
}
tmpCtx.putImageData(id, 0, 0);
return tmpCanvas;
};
p5.prototype.imageMode = function (m) {
if (m === constants.CORNER || m === constants.CORNERS || m === constants.CENTER) {
this._imageMode = m;
}
};
return p5;
}({}, amdclean['core'], amdclean['filters'], amdclean['canvas'], amdclean['constants']);
amdclean['imagepixels'] = function (require, core, filters, p5Color) {
'use strict';
var p5 = core;
var Filters = filters;
p5.prototype.pixels = [];
p5.prototype.blend = function () {
var currBlend = this.drawingContext.globalCompositeOperation;
var blendMode = arguments[arguments.length - 1];
var copyArgs = Array.prototype.slice.call(arguments, 0, arguments.length - 1);
this.drawingContext.globalCompositeOperation = blendMode;
this.copy.apply(this, copyArgs);
this.drawingContext.globalCompositeOperation = currBlend;
};
p5.prototype.copy = function () {
var srcImage, sx, sy, sw, sh, dx, dy, dw, dh;
if (arguments.length === 9) {
srcImage = arguments[0];
sx = arguments[1];
sy = arguments[2];
sw = arguments[3];
sh = arguments[4];
dx = arguments[5];
dy = arguments[6];
dw = arguments[7];
dh = arguments[8];
} else if (arguments.length === 8) {
sx = arguments[0];
sy = arguments[1];
sw = arguments[2];
sh = arguments[3];
dx = arguments[4];
dy = arguments[5];
dw = arguments[6];
dh = arguments[7];
srcImage = this;
} else {
throw new Error('Signature not supported');
}
var s = srcImage.canvas.width / srcImage.width;
this.drawingContext.drawImage(srcImage.canvas, s * sx, s * sy, s * sw, s * sh, dx, dy, dw, dh);
};
p5.prototype.filter = function (operation, value) {
Filters.apply(this.canvas, Filters[operation.toLowerCase()], value);
};
p5.prototype.get = function (x, y, w, h) {
if (x === undefined && y === undefined && w === undefined && h === undefined) {
x = 0;
y = 0;
w = this.width;
h = this.height;
} else if (w === undefined && h === undefined) {
w = 1;
h = 1;
}
if (x > this.width || y > this.height || x < 0 || y < 0) {
return [
0,
0,
0,
255
];
}
var imageData = this.drawingContext.getImageData(x, y, w, h);
var data = imageData.data;
if (w === 1 && h === 1) {
var pixels = [];
for (var i = 0; i < data.length; i += 4) {
pixels.push(data[i], data[i + 1], data[i + 2], data[i + 3]);
}
return pixels;
} else {
w = Math.min(w, this.width);
h = Math.min(h, this.height);
var region = new p5.Image(w, h);
region.canvas.getContext('2d').putImageData(imageData, 0, 0, 0, 0, w, h);
return region;
}
};
p5.prototype.loadPixels = function () {
var width = this.width;
var height = this.height;
var imageData = this.drawingContext.getImageData(0, 0, width, height);
this._setProperty('imageData', imageData);
this._setProperty('pixels', imageData.data);
};
p5.prototype.set = function (x, y, imgOrCol) {
if (imgOrCol instanceof p5.Image) {
this.drawingContext.save();
this.drawingContext.setTransform(1, 0, 0, 1, 0, 0);
this.drawingContext.scale(this._pixelDensity, this._pixelDensity);
this.drawingContext.drawImage(imgOrCol.canvas, x, y);
this.loadPixels.call(this);
this.drawingContext.restore();
} else {
var idx = 4 * (y * this.width + x);
if (!this.imageData) {
this.loadPixels.call(this);
}
if (typeof imgOrCol === 'number') {
if (idx < this.pixels.length) {
this.pixels[idx] = imgOrCol;
this.pixels[idx + 1] = imgOrCol;
this.pixels[idx + 2] = imgOrCol;
this.pixels[idx + 3] = 255;
}
} else if (imgOrCol instanceof Array) {
if (imgOrCol.length < 4) {
throw new Error('pixel array must be of the form [R, G, B, A]');
}
if (idx < this.pixels.length) {
this.pixels[idx] = imgOrCol[0];
this.pixels[idx + 1] = imgOrCol[1];
this.pixels[idx + 2] = imgOrCol[2];
this.pixels[idx + 3] = imgOrCol[3];
}
} else if (imgOrCol instanceof p5.Color) {
if (idx < this.pixels.length) {
this.pixels[idx] = imgOrCol.rgba[0];
this.pixels[idx + 1] = imgOrCol.rgba[1];
this.pixels[idx + 2] = imgOrCol.rgba[2];
this.pixels[idx + 3] = imgOrCol.rgba[3];
}
}
}
};
p5.prototype.updatePixels = function (x, y, w, h) {
if (x === undefined && y === undefined && w === undefined && h === undefined) {
x = 0;
y = 0;
w = this.width;
h = this.height;
}
this.drawingContext.putImageData(this.imageData, x, y, 0, 0, w, h);
};
return p5;
}({}, amdclean['core'], amdclean['filters'], amdclean['p5Color']);
!function (name, context, definition) {
if (typeof module != 'undefined' && module.exports)
module.exports = definition();
else if (typeof define == 'function' && define.amd)
define('reqwest', definition);
else
context[name] = definition();
}('reqwest', amdclean, function () {
var win = window, doc = document, httpsRe = /^http/, protocolRe = /(^\w+):\/\//, twoHundo = /^(20\d|1223)$/, byTag = 'getElementsByTagName', readyState = 'readyState', contentType = 'Content-Type', requestedWith = 'X-Requested-With', head = doc[byTag]('head')[0], uniqid = 0, callbackPrefix = 'reqwest_' + +new Date(), lastValue, xmlHttpRequest = 'XMLHttpRequest', xDomainRequest = 'XDomainRequest', noop = function () {
}, isArray = typeof Array.isArray == 'function' ? Array.isArray : function (a) {
return a instanceof Array;
}, defaultHeaders = {
'contentType': 'application/x-www-form-urlencoded',
'requestedWith': xmlHttpRequest,
'accept': {
'*': 'text/javascript, text/html, application/xml, text/xml, */*',
'xml': 'application/xml, text/xml',
'html': 'text/html',
'text': 'text/plain',
'json': 'application/json, text/javascript',
'js': 'application/javascript, text/javascript'
}
}, xhr = function (o) {
if (o['crossOrigin'] === true) {
var xhr = win[xmlHttpRequest] ? new XMLHttpRequest() : null;
if (xhr && 'withCredentials' in xhr) {
return xhr;
} else if (win[xDomainRequest]) {
return new XDomainRequest();
} else {
throw new Error('Browser does not support cross-origin requests');
}
} else if (win[xmlHttpRequest]) {
return new XMLHttpRequest();
} else {
return new ActiveXObject('Microsoft.XMLHTTP');
}
}, globalSetupOptions = {
dataFilter: function (data) {
return data;
}
};
function succeed(r) {
var protocol = protocolRe.exec(r.url);
protocol = protocol && protocol[1] || window.location.protocol;
return httpsRe.test(protocol) ? twoHundo.test(r.request.status) : !!r.request.response;
}
function handleReadyState(r, success, error) {
return function () {
if (r._aborted)
return error(r.request);
if (r._timedOut)
return error(r.request, 'Request is aborted: timeout');
if (r.request && r.request[readyState] == 4) {
r.request.onreadystatechange = noop;
if (succeed(r))
success(r.request);
else
error(r.request);
}
};
}
function setHeaders(http, o) {
var headers = o['headers'] || {}, h;
headers['Accept'] = headers['Accept'] || defaultHeaders['accept'][o['type']] || defaultHeaders['accept']['*'];
var isAFormData = typeof FormData === 'function' && o['data'] instanceof FormData;
if (!o['crossOrigin'] && !headers[requestedWith])
headers[requestedWith] = defaultHeaders['requestedWith'];
if (!headers[contentType] && !isAFormData)
headers[contentType] = o['contentType'] || defaultHeaders['contentType'];
for (h in headers)
headers.hasOwnProperty(h) && 'setRequestHeader' in http && http.setRequestHeader(h, headers[h]);
}
function setCredentials(http, o) {
if (typeof o['withCredentials'] !== 'undefined' && typeof http.withCredentials !== 'undefined') {
http.withCredentials = !!o['withCredentials'];
}
}
function generalCallback(data) {
lastValue = data;
}
function urlappend(url, s) {
return url + (/\?/.test(url) ? '&' : '?') + s;
}
function handleJsonp(o, fn, err, url) {
var reqId = uniqid++, cbkey = o['jsonpCallback'] || 'callback', cbval = o['jsonpCallbackName'] || reqwest.getcallbackPrefix(reqId), cbreg = new RegExp('((^|\\?|&)' + cbkey + ')=([^&]+)'), match = url.match(cbreg), script = doc.createElement('script'), loaded = 0, isIE10 = navigator.userAgent.indexOf('MSIE 10.0') !== -1;
if (match) {
if (match[3] === '?') {
url = url.replace(cbreg, '$1=' + cbval);
} else {
cbval = match[3];
}
} else {
url = urlappend(url, cbkey + '=' + cbval);
}
win[cbval] = generalCallback;
script.type = 'text/javascript';
script.src = url;
script.async = true;
if (typeof script.onreadystatechange !== 'undefined' && !isIE10) {
script.htmlFor = script.id = '_reqwest_' + reqId;
}
script.onload = script.onreadystatechange = function () {
if (script[readyState] && script[readyState] !== 'complete' && script[readyState] !== 'loaded' || loaded) {
return false;
}
script.onload = script.onreadystatechange = null;
script.onclick && script.onclick();
fn(lastValue);
lastValue = undefined;
head.removeChild(script);
loaded = 1;
};
head.appendChild(script);
return {
abort: function () {
script.onload = script.onreadystatechange = null;
err({}, 'Request is aborted: timeout', {});
lastValue = undefined;
head.removeChild(script);
loaded = 1;
}
};
}
function getRequest(fn, err) {
var o = this.o, method = (o['method'] || 'GET').toUpperCase(), url = typeof o === 'string' ? o : o['url'], data = o['processData'] !== false && o['data'] && typeof o['data'] !== 'string' ? reqwest.toQueryString(o['data']) : o['data'] || null, http, sendWait = false;
if ((o['type'] == 'jsonp' || method == 'GET') && data) {
url = urlappend(url, data);
data = null;
}
if (o['type'] == 'jsonp')
return handleJsonp(o, fn, err, url);
http = o.xhr && o.xhr(o) || xhr(o);
http.open(method, url, o['async'] === false ? false : true);
setHeaders(http, o);
setCredentials(http, o);
if (win[xDomainRequest] && http instanceof win[xDomainRequest]) {
http.onload = fn;
http.onerror = err;
http.onprogress = function () {
};
sendWait = true;
} else {
http.onreadystatechange = handleReadyState(this, fn, err);
}
o['before'] && o['before'](http);
if (sendWait) {
setTimeout(function () {
http.send(data);
}, 200);
} else {
http.send(data);
}
return http;
}
function Reqwest(o, fn) {
this.o = o;
this.fn = fn;
init.apply(this, arguments);
}
function setType(header) {
if (header.match('json'))
return 'json';
if (header.match('javascript'))
return 'js';
if (header.match('text'))
return 'html';
if (header.match('xml'))
return 'xml';
}
function init(o, fn) {
this.url = typeof o == 'string' ? o : o['url'];
this.timeout = null;
this._fulfilled = false;
this._successHandler = function () {
};
this._fulfillmentHandlers = [];
this._errorHandlers = [];
this._completeHandlers = [];
this._erred = false;
this._responseArgs = {};
var self = this;
fn = fn || function () {
};
if (o['timeout']) {
this.timeout = setTimeout(function () {
timedOut();
}, o['timeout']);
}
if (o['success']) {
this._successHandler = function () {
o['success'].apply(o, arguments);
};
}
if (o['error']) {
this._errorHandlers.push(function () {
o['error'].apply(o, arguments);
});
}
if (o['complete']) {
this._completeHandlers.push(function () {
o['complete'].apply(o, arguments);
});
}
function complete(resp) {
o['timeout'] && clearTimeout(self.timeout);
self.timeout = null;
while (self._completeHandlers.length > 0) {
self._completeHandlers.shift()(resp);
}
}
function success(resp) {
var type = o['type'] || resp && setType(resp.getResponseHeader('Content-Type'));
resp = type !== 'jsonp' ? self.request : resp;
var filteredResponse = globalSetupOptions.dataFilter(resp.responseText, type), r = filteredResponse;
try {
resp.responseText = r;
} catch (e) {
}
if (r) {
switch (type) {
case 'json':
try {
resp = win.JSON ? win.JSON.parse(r) : eval('(' + r + ')');
} catch (err) {
return error(resp, 'Could not parse JSON in response', err);
}
break;
case 'js':
resp = eval(r);
break;
case 'html':
resp = r;
break;
case 'xml':
resp = resp.responseXML && resp.responseXML.parseError && resp.responseXML.parseError.errorCode && resp.responseXML.parseError.reason ? null : resp.responseXML;
break;
}
}
self._responseArgs.resp = resp;
self._fulfilled = true;
fn(resp);
self._successHandler(resp);
while (self._fulfillmentHandlers.length > 0) {
resp = self._fulfillmentHandlers.shift()(resp);
}
complete(resp);
}
function timedOut() {
self._timedOut = true;
self.request.abort();
}
function error(resp, msg, t) {
resp = self.request;
self._responseArgs.resp = resp;
self._responseArgs.msg = msg;
self._responseArgs.t = t;
self._erred = true;
while (self._errorHandlers.length > 0) {
self._errorHandlers.shift()(resp, msg, t);
}
complete(resp);
}
this.request = getRequest.call(this, success, error);
}
Reqwest.prototype = {
abort: function () {
this._aborted = true;
this.request.abort();
},
retry: function () {
init.call(this, this.o, this.fn);
},
then: function (success, fail) {
success = success || function () {
};
fail = fail || function () {
};
if (this._fulfilled) {
this._responseArgs.resp = success(this._responseArgs.resp);
} else if (this._erred) {
fail(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t);
} else {
this._fulfillmentHandlers.push(success);
this._errorHandlers.push(fail);
}
return this;
},
always: function (fn) {
if (this._fulfilled || this._erred) {
fn(this._responseArgs.resp);
} else {
this._completeHandlers.push(fn);
}
return this;
},
fail: function (fn) {
if (this._erred) {
fn(this._responseArgs.resp, this._responseArgs.msg, this._responseArgs.t);
} else {
this._errorHandlers.push(fn);
}
return this;
},
'catch': function (fn) {
return this.fail(fn);
}
};
function reqwest(o, fn) {
return new Reqwest(o, fn);
}
function normalize(s) {
return s ? s.replace(/\r?\n/g, '\r\n') : '';
}
function serial(el, cb) {
var n = el.name, t = el.tagName.toLowerCase(), optCb = function (o) {
if (o && !o['disabled'])
cb(n, normalize(o['attributes']['value'] && o['attributes']['value']['specified'] ? o['value'] : o['text']));
}, ch, ra, val, i;
if (el.disabled || !n)
return;
switch (t) {
case 'input':
if (!/reset|button|image|file/i.test(el.type)) {
ch = /checkbox/i.test(el.type);
ra = /radio/i.test(el.type);
val = el.value;
(!(ch || ra) || el.checked) && cb(n, normalize(ch && val === '' ? 'on' : val));
}
break;
case 'textarea':
cb(n, normalize(el.value));
break;
case 'select':
if (el.type.toLowerCase() === 'select-one') {
optCb(el.selectedIndex >= 0 ? el.options[el.selectedIndex] : null);
} else {
for (i = 0; el.length && i < el.length; i++) {
el.options[i].selected && optCb(el.options[i]);
}
}
break;
}
}
function eachFormElement() {
var cb = this, e, i, serializeSubtags = function (e, tags) {
var i, j, fa;
for (i = 0; i < tags.length; i++) {
fa = e[byTag](tags[i]);
for (j = 0; j < fa.length; j++)
serial(fa[j], cb);
}
};
for (i = 0; i < arguments.length; i++) {
e = arguments[i];
if (/input|select|textarea/i.test(e.tagName))
serial(e, cb);
serializeSubtags(e, [
'input',
'select',
'textarea'
]);
}
}
function serializeQueryString() {
return reqwest.toQueryString(reqwest.serializeArray.apply(null, arguments));
}
function serializeHash() {
var hash = {};
eachFormElement.apply(function (name, value) {
if (name in hash) {
hash[name] && !isArray(hash[name]) && (hash[name] = [hash[name]]);
hash[name].push(value);
} else
hash[name] = value;
}, arguments);
return hash;
}
reqwest.serializeArray = function () {
var arr = [];
eachFormElement.apply(function (name, value) {
arr.push({
name: name,
value: value
});
}, arguments);
return arr;
};
reqwest.serialize = function () {
if (arguments.length === 0)
return '';
var opt, fn, args = Array.prototype.slice.call(arguments, 0);
opt = args.pop();
opt && opt.nodeType && args.push(opt) && (opt = null);
opt && (opt = opt.type);
if (opt == 'map')
fn = serializeHash;
else if (opt == 'array')
fn = reqwest.serializeArray;
else
fn = serializeQueryString;
return fn.apply(null, args);
};
reqwest.toQueryString = function (o, trad) {
var prefix, i, traditional = trad || false, s = [], enc = encodeURIComponent, add = function (key, value) {
value = 'function' === typeof value ? value() : value == null ? '' : value;
s[s.length] = enc(key) + '=' + enc(value);
};
if (isArray(o)) {
for (i = 0; o && i < o.length; i++)
add(o[i]['na