oxjs/source/Ox.Image/Ox.Image.js

797 lines
29 KiB
JavaScript
Raw Normal View History

2011-11-05 16:46:53 +00:00
'use strict';
2011-06-19 15:40:53 +00:00
Ox.load.Image = function(options, callback) {
2011-09-08 21:39:07 +00:00
//@ Image ------------------------------------------------------------------
/*@
Ox.Image <f> Generic image object
To render the image as an image element, use its <code>src()</code>
method, to render it as a canvas, use its <code>canvas</code> property.
2011-09-08 21:39:07 +00:00
(src, callback) -> <u> undefined
(width, height, callback) -> <u> undefined
(width, height, background, callback) -> <u> undefined
src <s> Image source (local, remote or data URL)
width <n> Width in px
image <n> Height in px
background <[n]> Background color (RGB or RGBA)
@*/
2011-06-19 15:40:53 +00:00
Ox.Image = function() {
var self = {},
that = {};
self.callback = arguments[arguments.length - 1];
2011-06-19 15:40:53 +00:00
if (arguments.length == 2) {
self.src = arguments[0];
self.image = new Image();
self.image.onload = init;
self.image.src = self.src;
2011-06-19 15:40:53 +00:00
} else {
self.width = arguments[0];
self.height = arguments[1];
self.background = arguments.length == 4
? arguments[2] : [0, 0, 0, 0];
init();
2011-06-19 15:40:53 +00:00
}
function error(mode) {
throw new RangeError('PNG codec can\'t ' + mode + ' ' + (
mode == 'encode' ? 'data' : 'image'
));
}
function getCapacity(bpb) {
var capacity = 0;
that.forEach(function(rgba) {
2011-09-08 12:27:40 +00:00
capacity += rgba[3] == 255 ? bpb * 3/8 : 0;
});
return capacity;
}
2012-04-14 09:46:23 +00:00
function getIndex(xy) {
return (
Ox.mod(xy[0], self.width)
+ Ox.mod(xy[1] * self.width, self.width * self.height)
) * 4;
2011-06-21 09:16:23 +00:00
}
function getXY(index) {
index /= 4;
return [index % self.width, Math.floor(index / self.width)];
}
function init() {
if (self.image) {
self.width = self.image.width;
self.height = self.image.height;
2011-06-21 09:16:23 +00:00
}
that.canvas = Ox.$('<canvas>').attr({
width: self.width,
height: self.height
});
that.context = that.canvas[0].getContext('2d');
if (self.image) {
that.context.drawImage(self.image, 0, 0);
} else if (Ox.sum(self.background)) {
that.context.fillStyle(self.background);
that.context.fillRect(0, 0, self.width, self.height);
2011-06-19 15:40:53 +00:00
}
self.imageData = that.context.getImageData(
0, 0, self.width, self.height
);
self.data = self.imageData.data;
self.callback(that);
}
2011-06-19 15:40:53 +00:00
2012-04-14 09:46:23 +00:00
function parseDrawOptions(options) {
options = options || {};
that.context.strokeStyle = options.width === 0
? 'rgba(0, 0, 0, 0)' : options.color || 'rgb(0, 0, 0)';
that.context.fillStyle = options.fill || 'rgba(0, 0, 0, 0)';
that.context.lineWidthWidth = options.width !== void 0
? options.width : 1;
}
function setSL(sl, d) {
var c = sl == 's' ? 1 : 2;
return that.map(function(rgba) {
2012-05-24 07:45:33 +00:00
var hsl = Ox.hsl([rgba[0], rgba[1], rgba[2]]);
2011-06-19 15:40:53 +00:00
hsl[c] = d < 0 ? hsl[c] * (d + 1) : hsl[c] + (1 - hsl[c]) * d;
2012-05-24 07:45:33 +00:00
return Ox.rgb(hsl).concat(rgba[3]);
2011-06-19 15:40:53 +00:00
});
}
/*@
blur <f> Apply blur filter
(val) -> <o> The image object
val <n> Amount of blur (1 to 5, more is slow)
@*/
2011-06-21 09:16:23 +00:00
that.blur = function(val) {
2011-09-08 21:39:07 +00:00
var filter = [],
2012-01-02 06:21:36 +00:00
size = val * 2 + 1,
2011-09-08 21:39:07 +00:00
sum = 0
Ox.loop(size, function(x) {
Ox.loop(size, function(y) {
var isInCircle = +(Math.sqrt(
Math.pow(x - val, 2) + Math.pow(y - val, 2)
) <= val);
sum += isInCircle;
filter.push(isInCircle)
});
});
filter = filter.map(function(val) {
return val / sum;
});
2011-09-08 21:39:07 +00:00
return that.filter(filter);
2011-06-19 15:40:53 +00:00
};
/*@
channel <f> Reduce the image to one channel
(channel) -> <o> The image object
channel <str> 'r', 'g', 'b', 'a', 'h', 's' or 'l'
@*/
that.channel = function(str) {
str = str[0].toLowerCase();
return that.map(function(rgba) {
var i = ['r', 'g', 'b', 'a'].indexOf(str), rgb, val;
if (i > -1) {
return Ox.map(rgba, function(v, c) {
return str == 'a'
? (c < 3 ? rgba[3] : 255)
: (c == i || c == 3 ? v : 0);
});
} else {
i = ['h', 's', 'l'].indexOf(str);
val = Ox.hsl([rgba[0], rgba[1], rgba[2]])[i];
rgb = i == 0
? Ox.rgb([val, 1, 0.5])
2012-05-22 14:29:37 +00:00
: Ox.range(3).map(function() {
return parseInt(val * 255);
});
2012-05-24 07:45:33 +00:00
return rgb.concat(rgba[3]);
}
2011-06-19 15:40:53 +00:00
});
}
//@ context <o> 2D drawing context
/*@
contour <f> Apply contour filter
() -> <o> The image object
@*/
2011-06-21 09:16:23 +00:00
that.contour = function(val) {
return that.filter([
2011-06-21 09:16:23 +00:00
+1, +1, +1,
+1, -7, +1,
+1, +1, +1
]);
};
/*@
depth <f> Reduce the bit depth
(depth) -> <o> The image object
depth <n> Bits per channel (1 to 7)
@*/
2011-09-08 21:39:07 +00:00
that.depth = function(val) {
var pow = Math.pow(2, 8 - val);
return that.map(function(rgba) {
return rgba.map(function(v, i) {
return i < 3 ? Math.floor(v / pow) * pow/* * 255 / val*/ : v;
2011-09-08 21:39:07 +00:00
});
});
};
2011-09-08 21:39:07 +00:00
/*@
drawCircle <f> Draws a circle
(point, radius, options) -> <o> The image object
point <[n]> Center (<code>[x, y]</code>)
radius <n> Radius in px
options <o> Options
color <s|'rgb(0, 0, 0)'> CSS color
fill <s|'rgba(0, 0, 0, 0)'> CSS color
width <n|1> Line width in px
@*/
that.drawCircle = function(point, radius, options) {
2012-04-14 09:46:23 +00:00
parseDrawOptions(options);
that.context.beginPath();
that.context.arc(point[0], point[1], radius, 0, 2 * Math.PI);
that.context.fill();
that.context.stroke();
return that;
};
/*@
drawLine <f> Draws a line
(points, options) -> <o> The image object
points <[a]> End points (<code>[[x1, y1], [x2, y2]]</code>)
options <o> Options
color <s|'rgb(0, 0, 0)'> CSS color
width <n|1> Line width in px
@*/
that.drawLine = function(points, options, isPath) {
2012-04-14 09:46:23 +00:00
parseDrawOptions(options);
!isPath && that.context.beginPath();
!isPath && that.context.moveTo(points[0][0], points[0][1]);
that.context.lineTo(points[1][0], points[1][1]);
!isPath && that.context.stroke();
return that;
};
/*@
drawPath <f> Draws a path
(points, options) -> <o> The image object
points <[a]> Points (<code>[[x1, y2], [x2, y2], ...]</code>)
options <o> Options
color <s|'rgb(0, 0, 0)'> CSS color
fill <s|'rgba(0, 0, 0, 0)'> CSS color
width <n|1> Line width in px
@*/
that.drawPath = function(points, options) {
var n = points.length;
2012-04-14 09:46:23 +00:00
parseDrawOptions(options);
that.context.beginPath();
that.context.moveTo(points[0][0], points[0][1]);
Ox.loop(options.close ? n : n - 1, function(i) {
that.drawLine([points[i], points[(i + 1) % n]], options, true);
});
that.context.fill();
that.context.stroke();
return that;
};
/*@
drawRectangle <f> Draws a rectangle
(point, size, options) -> <o> The image object
point <[n]> Top left corner (<code>[x, y]</code>)
size <[n]> Width and height in px (<code>[w, h]</code>)
options <o> Options
color <s|'rgb(0, 0, 0)'> CSS color
fill <s|'rgba(0, 0, 0, 0)'> CSS color
width <n|1> Line width in px
@*/
that.drawRectangle = function(point, size, options) {
2012-04-14 09:46:23 +00:00
parseDrawOptions(options);
that.context.fillRect(point[0], point[1], size[0], size[1]);
that.context.strokeRect(point[0], point[1], size[0], size[1]);
return that;
};
/*@
drawText <f> Draws text
(text, point, options) -> <o> The image object
text <s> Text
point <[n]> Top left corner (<code>[x, y]</code>)
options <o> Options
color <s|'rgb(0, 0, 0)'> CSS color
font <s|'10px sans-serif'> CSS font
outline <s|'0px rgba(0, 0, 0, 0)'> CSS border
textAlign <n|'start'> CSS text-align
@*/
that.drawText = function(text, point, options) {
options = options || {};
var match = (
options.outline || '0px rgba(0, 0, 0, 0)'
).match(/^([\d\.]+)px (.+)$/),
outlineWidth = match[1],
outlineColor = match[2];
that.context.fillStyle = options.color || 'rgb(0, 0, 0)';
that.context.font = options.font || '10px sans-serif';
that.context.strokeStyle = outlineColor;
that.context.lineWidth = outlineWidth;
that.context.textAlign = options.textAlign || 'start';
that.context.fillText(text, point[0], point[1])
that.context.strokeText(text, point[0], point[1])
return that;
};
/*@
edges <f> Apply edges filter
() -> <o> The image object
@*/
2011-06-21 09:16:23 +00:00
that.edges = function(val) {
return that.filter([
2011-06-21 09:16:23 +00:00
-1, -1, -1,
-1, +8, -1,
-1, -1, -1
]).saturation(-1);
2011-06-21 09:16:23 +00:00
};
/*@
emboss <f> Apply emboss filter
() -> <o> The image object
@*/
2011-06-21 09:16:23 +00:00
that.emboss = function(val) {
return that.filter([
2012-04-14 09:46:23 +00:00
-1, -1, 0,
-1, 0, +1,
0, +1, +1
], 128).saturation(-1);
};
2011-09-08 21:39:07 +00:00
/*@
encode <f> Encodes a string into the image
For most purposes, deflate and mode should be omitted, since the
defaults make the existence of the message harder to detect. A valid
use case for deflate and mode would be to first encode a more easily
detected decoy string, and only then the secret string: <code>
2011-09-08 21:39:07 +00:00
image.encode(decoy, false, 1, function(image) { image.encode(secret,
-1, callback); })</code>.
(str, callback) -> <o> The image object (unmodified)
(str, deflate, callback) -> <o> The image object (unmodified)
(str, mode, callback) -> <o> The image object (unmodified)
(str, deflate, mode, callback) -> <o> The image object (unmodified)
(str, mode, deflate, callback) -> <o> The image object (unmodified)
str <s> The string to be encoded
callback <f> Callback function
image <o> The image object (modified)
deflate <b|true> If true, encode the string with deflate
2011-09-08 21:39:07 +00:00
mode <n|0> Encoding mode
If mode is between -7 and 0, the string will be encoded one bit
per byte, as the number of bits within that byte set to 1,
modulo 2, by flipping, if necessary, the most (mode -7) to least
(mode 0) significant bit. If mode is between 1 and 255, the
string will be encoded bitwise into all bits per byte that, in
mode, are set to 1.
@*/
that.encode = function(str) {
var callback = arguments[arguments.length - 1],
deflate = Ox.isBoolean(arguments[1]) ? arguments[1]
2011-09-08 21:39:07 +00:00
: Ox.isBoolean(arguments[2]) ? arguments[2] : true,
mode = Ox.isNumber(arguments[1]) ? arguments[1]
: Ox.isNumber(arguments[2]) ? arguments[2] : 0,
b = 0, bin,
// Array of bits per byte to be modified (0 is LSB)
2012-05-22 14:29:37 +00:00
bits = mode < 1 ? [-mode] : Ox.filter(Ox.range(8), function(i) {
return mode & 1 << i;
2012-05-23 15:13:38 +00:00
}),
cap = getCapacity(bits.length), len;
// Compress the string
str = Ox[deflate ? 'encodeDeflate' : 'encodeUTF8'](str);
len = str.length;
// Prefix the string with its length, as a four-byte value
2011-09-08 21:39:07 +00:00
str = Ox.pad(Ox.encodeBase256(len), 4, '\u0000') + str;
str.length > cap && error('encode');
while (str.length < cap) {
str += str.substr(4, len);
}
2012-05-24 09:47:33 +00:00
str = str.slice(0, Math.ceil(cap));
// Create an array of bit values
2012-05-24 06:56:42 +00:00
bin = Ox.flatten(Ox.map(str.split(''), function(chr) {
2012-05-22 14:29:37 +00:00
return Ox.range(8).map(function(i) {
return chr.charCodeAt(0) >> 7 - i & 1;
});
2012-05-24 06:56:42 +00:00
}));
b = 0;
that.forEach(function(rgba, xy, index) {
2011-09-08 21:39:07 +00:00
// If alpha is not 255, the RGB values may not be preserved
if (rgba[3] == 255) {
Ox.loop(3, function(c) {
// fixme: use: var data = that.context.imageData.data[i + c]
var i = index + c;
Ox.forEach(bits, function(bit) {
if ((
mode < 1
// If the number of bits set to 1, mod 2
? Ox.sum(Ox.range(8).map(function(bit) {
2011-09-08 12:27:40 +00:00
return +!!(self.data[i] & 1 << bit);
})) % 2
// or the one bit in question
2011-09-08 12:27:40 +00:00
: +!!(self.data[i] & 1 << bit)
// is not equal to the data bit
) != bin[b++]) {
// then flip the bit
self.data[i] ^= 1 << bit;
}
2011-09-08 12:27:40 +00:00
});
});
}
}, function() {
that.context.putImageData(self.imageData, 0, 0);
callback(that);
});
2011-09-08 21:39:07 +00:00
return that;
};
/*@
decode <f> Decode encoded string
(callback) -> <o> The image object (unmodified)
(deflate, callback) -> <o> The image object (unmodified)
(mode, callback) -> <o> The image object (unmodified)
(deflate, mode, callback) -> <o> The image object (unmodified)
(mode, deflate, callback) -> <o> The image object (unmodified)
deflate <b|true> If true, decode the string with deflate
mode <n|0> See encode method
callback <f> Callback function
image <o> The image object (modified)
@*/
2011-09-08 21:39:07 +00:00
that.decode = function() {
var callback = arguments[arguments.length - 1],
deflate = Ox.isBoolean(arguments[0]) ? arguments[0]
: Ox.isBoolean(arguments[1]) ? arguments[1] : true,
mode = Ox.isNumber(arguments[0]) ? arguments[0]
: Ox.isNumber(arguments[1]) ? arguments[1] : 0,
bin = '',
// Array of bits per byte to be modified (0 is LSB)
2012-05-22 14:29:37 +00:00
bits = mode < 1 ? [-mode] : Ox.range(8).filter(function(i) {
return mode & 1 << i;
2011-09-08 21:39:07 +00:00
}),
2012-01-02 06:21:36 +00:00
done = 0, len = 4, str = '';
that.forEach(function(rgba, xy, index) {
2011-09-08 21:39:07 +00:00
if (rgba[3] == 255) {
Ox.loop(3, function(c) {
var i = index + c;
Ox.forEach(bits, function(bit) {
bin += mode < 1
// Read the number of bits set to 1, mod 2
2011-09-08 21:39:07 +00:00
? Ox.sum(Ox.range(8).map(function(bit) {
return +!!(self.data[i] & 1 << bit);
})) % 2
// or the one bit in question
2011-09-08 21:39:07 +00:00
: +!!(self.data[i] & 1 << bit);
if (bin.length == 8) {
// Every 8 bits, add one byte to the string
2011-09-08 21:39:07 +00:00
str += Ox.char(parseInt(bin, 2));
bin = '';
if (str.length == len) {
if (++done == 1) {
// After 4 bytes, parse string as length
2011-09-08 21:39:07 +00:00
len = Ox.decodeBase256(str);
if (
len <= 0 ||
len > getCapacity(bits.length) - 4
) {
error('decode');
}
2011-09-08 21:39:07 +00:00
str = '';
} else {
// After length more bytes, break
2012-05-24 17:20:29 +00:00
Ox.Break()();
2011-09-08 21:39:07 +00:00
}
}
}
});
2012-05-24 17:20:29 +00:00
done == 2 && Ox.Break()();
2011-09-08 21:39:07 +00:00
});
2012-05-24 17:20:29 +00:00
done == 2 && Ox.Break()();
2011-09-08 21:39:07 +00:00
}
}, function() {
try {
if (deflate) {
Ox.decodeDeflate(str, callback);
} else {
callback(Ox.decodeUTF8(str));
}
} catch (e) {
error('decode');
2011-09-08 21:39:07 +00:00
}
});
return that;
2011-09-08 21:39:07 +00:00
}
/*@
filter <f> Pixel-wise filter function
Undocumented, see source code
(filter) -> <o> The image object
(filter, bias) -> <o> The image object
filter <[n]> Filter matrix
bias <n> Bias
@*/
that.filter = function(filter, bias) {
bias = bias || 0;
var filterSize = Math.sqrt(filter.length),
d = (filterSize - 1) / 2,
imageData = that.context.createImageData(self.width, self.height),
data = [];
self.imageData = that.context.getImageData(0, 0, self.width, self.height);
self.data = self.imageData.data;
Ox.loop(0, self.data.length, 4, function(i) {
var filterIndex = 0,
xy = getXY(i);
Ox.loop(3, function(c) {
data[i + c] = 0;
});
Ox.loop(-d, d + 1, function(x) {
Ox.loop(-d, d + 1, function(y) {
2012-04-14 09:46:23 +00:00
var pixelIndex = getIndex([xy[0] + x, xy[1] + y]);
Ox.loop(3, function(c) {
data[i + c] += self.data[pixelIndex + c] * filter[filterIndex];
});
filterIndex++;
});
});
});
Ox.loop(0, self.data.length, 4, function(i) {
Ox.loop(4, function(c) {
imageData.data[i + c] = c < 3
? Ox.limit(Math.round(data[i + c] + bias), 0, 255)
: self.data[i + c];
});
});
that.context.putImageData(imageData, 0, 0);
self.imageData = imageData;
self.data = data;
2011-06-21 09:16:23 +00:00
return that;
};
/*@
forEach <f> Pixel-wise forEach loop
(fn) -> <o> The image object
(fn, callback) -> <o> The image object
fn <f> Iterator function
rgba <[n]> RGBA values
xy <[n]> XY coordinates
i <n> Pixel index
callback <f> Callback function (if present, forEach is async)
@*/
that.forEach = function(iterator, callback) {
var data = self.data,
forEach = callback ? Ox.nonblockingForEach : Ox.forEach;
2012-05-23 15:45:20 +00:00
forEach(Ox.range(0, data.length, 4), function(i) {
2012-05-24 06:56:42 +00:00
iterator([
2012-05-23 15:45:20 +00:00
data[i], data[i + 1], data[i + 2], data[i + 3]
], getXY(i), i);
}, callback);
return that;
};
/*@
getSize <f> Returns width and height
() -> <o> Image size
width <n> Width in px
height <n> Height in px
@*/
that.getSize = function() {
return {width: self.width, height: self.height};
};
/*@
hue <f> Change the hue of the image
(val) -> <o> The image object
val <n> Hue, in degrees
@*/
2011-06-19 15:40:53 +00:00
that.hue = function(val) {
return that.map(function(rgba) {
2012-05-24 07:45:33 +00:00
var hsl = Ox.hsl([rgba[0], rgba[1], rgba[2]]);
2011-06-19 15:40:53 +00:00
hsl[0] = (hsl[0] + val) % 360;
2012-05-24 07:45:33 +00:00
return Ox.rgb(hsl).concat(rgba[3]);
2011-06-19 15:40:53 +00:00
});
};
/*@
imageData <f> Get or set image data
() -> <o> ImageData object
data <a> CanvasPixelArray
height <n> Height in px
width <n> Width in px
(imageData) -> <o> Image object with new image data
imageData <o> ImageData object
@*/
that.imageData = function() {
if (arguments.length == 0) {
return self.imageData;
} else {
self.imageData = self.context.createImageData(arguments[0]);
}
};
/*@
invert <f> Apply invert filter
() -> <o> The image object
@*/
2011-06-19 15:40:53 +00:00
that.invert = function() {
return that.map(function(rgba) {
2011-06-19 15:40:53 +00:00
return [255 - rgba[0], 255 - rgba[1], 255 - rgba[2], rgba[3]];
});
};
/*@
lightness <f> Apply lightness filter
(val) -> <o> The image object
val <n> Amount, from -1 (darkest) to 1 (lightest)
@*/
that.lightness = function(val) {
return setSL('l', val);
};
/*@
map <f> Pixel-wise map function
(fn) -> <o> The image object
fn <f> Iterator function
rgba <[n]> RGBA values
xy <[n]> XY coordinates
i <n> Pixel index
@*/
that.map = function(fn, callback) {
self.imageData = that.context.getImageData(0, 0, self.width, self.height);
self.data = self.imageData.data;
that.forEach(function(rgba, xy, i) {
fn(rgba, xy, i).forEach(function(val, c) {
self.data[i + c] = val;
});
});
that.context.putImageData(self.imageData, 0, 0);
2011-06-21 09:16:23 +00:00
return that;
};
/*@
mosaic <f> Apply mosaic filter
(size) -> <o> The image object
size <n> Mosaic size
@*/
that.mosaic = function(size) {
that.forEach(function(rgba, xy) {
if (xy[0] % size == 0 && xy[1] % size == 0) {
Ox.loop(size, function(x) {
Ox.loop(size, function(y) {
2012-04-14 09:46:23 +00:00
var hsl, rgb, xy_ = [xy[0] + x, xy[1] + y];
if (
(x == 0 || y == 0)
&& !(x == size - 1 || y == size - 1)
) {
that.pixel(xy_, rgba.map(function(c, i) {
return i < 3 ? Math.min(c + 16, 255) : c;
}));
2012-04-14 09:46:23 +00:00
} else if (
(x == size - 1 || y == size - 1)
&& !(x == 0 || y == 0)
) {
that.pixel(xy_, rgba.map(function(c, i) {
return i < 3 ? Math.max(c - 16, 0) : c;
}));
} else {
2012-04-14 09:46:23 +00:00
that.pixel(xy_, rgba);
}
});
});
}
});
that.context.putImageData(self.imageData, 0, 0);
return that;
}
/*@
motionBlur <f> Apply motion blur filter
() -> <o> The image object
@*/
2011-06-21 09:16:23 +00:00
that.motionBlur = function() {
return that.filter([
2011-06-21 09:16:23 +00:00
0.2, 0.0, 0.0, 0.0, 0.0,
0.0, 0.2, 0.0, 0.0, 0.0,
0.0, 0.0, 0.2, 0.0, 0.0,
0.0, 0.0, 0.0, 0.2, 0.0,
0.0, 0.0, 0.0, 0.0, 0.2
]);
};
/*@
photocopy <f> Apply photocopy filter
() -> <o> The image object
@*/
that.photocopy = function(val) {
return that.saturation(-1).depth(1).blur(1);
};
/*@
pixel <f> Get or set pixel values
(x, y) -> <[n]> RGBA values
(x, y, val) -> <o> The image object
x <n> X coordinate
y <n> Y coordinate
val <[n]> RGBA values
@*/
2012-04-14 09:46:23 +00:00
that.pixel = function(xy, val) {
var i = getIndex(xy), ret;
if (!val) {
2012-04-14 09:46:23 +00:00
ret = Ox.range(4).map(function(c) {
return self.data[i + c];
});
} else {
val.forEach(function(v, c) {
self.data[i + c] = v;
});
2012-04-14 09:46:23 +00:00
that.context.putImageData(self.imageData, 0, 0);
ret = that;
}
2012-04-14 09:46:23 +00:00
return ret;
}
/*@
posterize <f> Apply posterize filter
() -> <o> The image object
@*/
2011-06-21 09:16:23 +00:00
that.posterize = function() {
return that.blur(3).map(function(rgba) {
2011-06-21 09:16:23 +00:00
return [
Math.floor(rgba[0] / 64) * 64,
Math.floor(rgba[1] / 64) * 64,
Math.floor(rgba[2] / 64) * 64,
rgba[3]
];
});
2011-06-19 15:40:53 +00:00
};
that.resize = function(width, height) {
// fixme: doesn't work this way
that.canvas.attr({
width: width,
height: height
});
2011-06-21 09:16:23 +00:00
return that;
}
/*@
saturation <f> Apply saturation filter
(val) -> <o> The image object
val <n> Amount, from -1 (lowest) to 1 (highest)
@*/
that.saturation = function(val) {
return setSL('s', val);
2011-06-21 09:16:23 +00:00
};
/*@
sharpen <f> Apply sharpen filter
() -> <o> The image object
@*/
2011-06-21 09:16:23 +00:00
that.sharpen = function(val) {
return that.filter([
2011-06-21 09:16:23 +00:00
-1, -1, -1,
-1, +9, -1,
-1, -1, -1
]);
2011-06-19 15:40:53 +00:00
};
/*@
solarize <f> Apply solarize filter
() -> <o> The image object
@*/
2011-06-21 09:16:23 +00:00
that.solarize = function() {
return that.map(function(rgba) {
2011-06-21 09:16:23 +00:00
return [
rgba[0] < 128 ? rgba[0] : 255 - rgba[0],
rgba[1] < 128 ? rgba[1] : 255 - rgba[1],
rgba[2] < 128 ? rgba[2] : 255 - rgba[2],
rgba[3]
];
});
}
/*@
src <f> Get or set the image source
() -> <s> Data URL
(src) -> <o> Image object with new source
src <s> Image source (local, remote or data URL)
@*/
that.src = function() {
var ret;
if (arguments.length == 0) {
ret = that.canvas[0].toDataURL();
} else {
var callback = arguments[1];
self.src = arguments[0];
self.image = new Image();
self.image.onload = function() {
self.width = self.image.width;
self.height = self.image.height;
that.canvas.attr({
width: self.width,
height: self.height
});
that.context.drawImage(self.image, 0, 0);
self.imageData = that.context.getImageData(0, 0, self.width, self.height);
self.data = self.imageData.data;
callback && callback(that);
}
self.image.src = self.src;
ret = that;
}
return ret;
2011-06-19 15:40:53 +00:00
};
};
callback(true);
}