js2/mwEmbed/libClipEdit/pixastic-editor/pixastic.all.js

   1 /*
   2  * Pixastic Lib - Core Functions - v0.1.3
   3  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
   4  * License: [http://www.pixastic.com/lib/license.txt]
   5  */
   6
   7 var Pixastic = (function() {
   8
   9
  10         function addEvent(el, event, handler) {
  11                 if (el.addEventListener)
  12                         el.addEventListener(event, handler, false);
  13                 else if (el.attachEvent)
  14                         el.attachEvent("on" + event, handler);
  15         }
  16
  17         function onready(handler) {
  18                 var handlerDone = false;
  19                 var execHandler = function() {
  20                         if (!handlerDone) {
  21                                 handlerDone = true;
  22                                 handler();
  23                         }
  24                 }
  25                 document.write("<"+"script defer src=\"//:\" id=\"__onload_ie_sumbox__\"></"+"script>");
  26                 var script = document.getElementById("__onload_ie_sumbox__");
  27                 script.onreadystatechange = function() {
  28                         if (script.readyState == "complete") {
  29                                 script.parentNode.removeChild(script);
  30                                 execHandler();
  31                         }
  32                 }
  33                 if (document.addEventListener)
  34                         document.addEventListener("DOMContentLoaded", execHandler, false);
  35                 addEvent(window, "load", execHandler);
  36         }
  37
  38         function init() {
  39                 if (!Pixastic.parseOnLoad) return;
  40                 var imgEls = getElementsByClass("pixastic", null, "img");
  41                 var canvasEls = getElementsByClass("pixastic", null, "canvas");
  42                 var elements = imgEls.concat(canvasEls);
  43                 for (var i=0;i<elements.length;i++) {
  44                         (function() {
  45
  46                         var el = elements[i];
  47                         var actions = [];
  48                         var classes = el.className.split(" ");
  49                         for (var c=0;c<classes.length;c++) {
  50                                 var cls = classes[c];
  51                                 if (cls.substring(0,9) == "pixastic-") {
  52                                         var actionName = cls.substring(9);
  53                                         if (actionName != "")
  54                                                 actions.push(actionName);
  55                                 }
  56                         }
  57                         if (actions.length) {
  58                                 if (el.tagName.toLowerCase() == "img") {
  59                                         var dataImg = new Image();
  60                                         dataImg.src = el.src;
  61                                         if (dataImg.complete) {
  62                                                 for (var a=0;a<actions.length;a++) {
  63                                                         var res = Pixastic.applyAction(el, el, actions[a], null);
  64                                                         if (res)
  65                                                                 el = res;
  66                                                 }
  67                                         } else {
  68                                                 dataImg.onload = function() {
  69                                                         for (var a=0;a<actions.length;a++) {
  70                                                                 var res = Pixastic.applyAction(el, el, actions[a], null)
  71                                                                 if (res)
  72                                                                         el = res;
  73                                                         }
  74                                                 }
  75                                         }
  76                                 } else {
  77                                         setTimeout(function() {
  78                                                 for (var a=0;a<actions.length;a++) {
  79                                                         var res = Pixastic.applyAction(
  80                                                                 el, el, actions[a], null
  81                                                         );
  82                                                         if (res)
  83                                                                 el = res;
  84                                                 }
  85                                         },1);
  86                                 }
  87                         }
  88
  89                         })();
  90                 }
  91         }
  92
  93 //      if (typeof pixastic_no_onready == "undefined") // yuck.
  94 //              onready(init);
  95
  96         // getElementsByClass by Dustin Diaz, http://www.dustindiaz.com/getelementsbyclass/
  97         function getElementsByClass(searchClass,node,tag) {
  98                 var classElements = new Array();
  99                 if ( node == null )
 100                         node = document;
 101                 if ( tag == null )
 102                         tag = '*';
 103
 104                 var els = node.getElementsByTagName(tag);
 105                 var elsLen = els.length;
 106                 var pattern = new RegExp("(^|\\s)"+searchClass+"(\\s|$)");
 107                 for (i = 0, j = 0; i < elsLen; i++) {
 108                         if ( pattern.test(els[i].className) ) {
 109                                 classElements[j] = els[i];
 110                                 j++;
 111                         }
 112                 }
 113                 return classElements;
 114         }
 115
 116         var debugElement;
 117
 118         function writeDebug(text, level) {
 119                 if (!Pixastic.debug) return;
 120                 try {
 121                         switch (level) {
 122                                 case "warn" :
 123                                         console.warn("Pixastic:", text);
 124                                         break;
 125                                 case "error" :
 126                                         console.error("Pixastic:", text);
 127                                         break;
 128                                 default:
 129                                         console.log("Pixastic:", text);
 130                         }
 131                 } catch(e) {
 132                 }
 133                 if (!debugElement) {
 134
 135                 }
 136         }
 137
 138
 139         return {
 140
 141                 parseOnLoad : false,
 142
 143                 debug : false,
 144
 145                 applyAction : function(img, dataImg, actionName, options) {
 146
 147                         options = options || {};
 148
 149                         var imageIsCanvas = (img.tagName.toLowerCase() == "canvas");
 150                         if (imageIsCanvas && Pixastic.Client.isIE()) {
 151                                 if (Pixastic.debug) writeDebug("Tried to process a canvas element but browser is IE.");
 152                                 return false;
 153                         }
 154
 155                         var canvas, ctx;
 156                         if (Pixastic.Client.hasCanvas()) {
 157                                 canvas = document.createElement("canvas");
 158                                 ctx = canvas.getContext("2d");
 159                         }
 160
 161                         var w = parseInt(img.offsetWidth);
 162                         var h = parseInt(img.offsetHeight);
 163
 164                         if (imageIsCanvas) {
 165                                 w = img.width;
 166                                 h = img.height;
 167                         }
 168
 169                         if (actionName.indexOf("(") > -1) {
 170                                 var tmp = actionName;
 171                                 actionName = tmp.substr(0, tmp.indexOf("("));
 172                                 var arg = tmp.match(/\((.*?)\)/);
 173                                 if (arg[1]) {
 174                                         arg = arg[1].split(";");
 175                                         for (var a=0;a<arg.length;a++) {
 176                                                 thisArg = arg[a].split("=");
 177                                                 if (thisArg.length == 2) {
 178                                                         if (thisArg[0] == "rect") {
 179                                                                 var rectVal = thisArg[1].split(",");
 180                                                                 options[thisArg[0]] = {
 181                                                                         left : parseInt(rectVal[0],10)||0,
 182                                                                         top : parseInt(rectVal[1],10)||0,
 183                                                                         width : parseInt(rectVal[2],10)||0,
 184                                                                         height : parseInt(rectVal[3],10)||0
 185                                                                 }
 186                                                         } else {
 187                                                                 options[thisArg[0]] = thisArg[1];
 188                                                         }
 189                                                 }
 190                                         }
 191                                 }
 192                         }
 193
 194                         if (!options.rect) {
 195                                 options.rect = {
 196                                         left : 0, top : 0, width : w, height : h
 197                                 };
 198                         }
 199                         var validAction = false;
 200                         if (Pixastic.Actions[actionName] && typeof Pixastic.Actions[actionName].process == "function") {
 201                                 validAction = true;
 202                         }
 203                         if (!validAction) {
 204                                 if (Pixastic.debug) writeDebug("Invalid action \"" + actionName + "\". Maybe file not included?");
 205                                 return false;
 206                         }
 207                         if (!Pixastic.Actions[actionName].checkSupport()) {
 208                                 if (Pixastic.debug) writeDebug("Action \"" + actionName + "\" not supported by this browser.");
 209                                 return false;
 210                         }
 211
 212                         if (Pixastic.Client.hasCanvas()) {
 213                                 canvas.width = w;
 214                                 canvas.height = h;
 215                                 canvas.style.width = w+"px";
 216                                 canvas.style.height = h+"px";
 217                                 ctx.drawImage(dataImg,0,0,w,h);
 218
 219                                 if (!img.__pixastic_org_image) {
 220                                         canvas.__pixastic_org_image = img;
 221                                         canvas.__pixastic_org_width = w;
 222                                         canvas.__pixastic_org_height = h;
 223                                 } else {
 224                                         canvas.__pixastic_org_image = img.__pixastic_org_image;
 225                                         canvas.__pixastic_org_width = img.__pixastic_org_width;
 226                                         canvas.__pixastic_org_height = img.__pixastic_org_height;
 227                                 }
 228
 229                         } else if (Pixastic.Client.isIE() && typeof img.__pixastic_org_style == "undefined") {
 230                                 img.__pixastic_org_style = img.style.cssText;
 231                         }
 232
 233                         var params = {
 234                                 image : img,
 235                                 canvas : canvas,
 236                                 width : w,
 237                                 height : h,
 238                                 useData : true,
 239                                 options : options
 240                         }
 241
 242                         // Ok, let's do it!
 243
 244                         var res = Pixastic.Actions[actionName].process(params);
 245
 246                         if (!res) {
 247                                 return false;
 248                         }
 249
 250                         if (Pixastic.Client.hasCanvas()) {
 251                                 if (params.useData) {
 252                                         if (Pixastic.Client.hasCanvasImageData()) {
 253                                                 canvas.getContext("2d").putImageData(params.canvasData, options.rect.left, options.rect.top);
 254
 255                                                 // Opera doesn't seem to update the canvas until we draw something on it, lets draw a 0x0 rectangle.
 256                                                 canvas.getContext("2d").fillRect(0,0,0,0);
 257                                         }
 258                                 }
 259
 260                                 if (!options.leaveDOM) {
 261                                         // copy properties and stuff from the source image
 262                                         canvas.title = img.title;
 263                                         canvas.imgsrc = img.imgsrc;
 264                                         if (!imageIsCanvas) canvas.alt  = img.alt;
 265                                         if (!imageIsCanvas) canvas.imgsrc = img.src;
 266                                         canvas.className = img.className;
 267                                         canvas.style.cssText = img.style.cssText;
 268                                         canvas.name = img.name;
 269                                         canvas.tabIndex = img.tabIndex;
 270                                         canvas.id = img.id;
 271                                         if (img.parentNode && img.parentNode.replaceChild) {
 272                                                 img.parentNode.replaceChild(canvas, img);
 273                                         }
 274                                 }
 275
 276                                 options.resultCanvas = canvas;
 277
 278                                 return canvas;
 279                         }
 280
 281                         return img;
 282                 },
 283
 284                 prepareData : function(params, getCopy) {
 285                         var ctx = params.canvas.getContext("2d");
 286                         var rect = params.options.rect;
 287                         var dataDesc = ctx.getImageData(rect.left, rect.top, rect.width, rect.height);
 288                         var data = dataDesc.data;
 289                         if (!getCopy) params.canvasData = dataDesc;
 290                         return data;
 291                 },
 292
 293                 // load the image file
 294                 process : function(img, actionName, options, callback)
 295                 {
 296                         if (img.tagName.toLowerCase() == "img") {
 297                                 var dataImg = new Image();
 298                                 dataImg.src = img.src;
 299                                 if (dataImg.complete) {
 300                                         var res = Pixastic.applyAction(img, dataImg, actionName, options);
 301                                         if (callback) callback(res);
 302                                         return res;
 303                                 } else {
 304                                         dataImg.onload = function() {
 305                                                 var res = Pixastic.applyAction(img, dataImg, actionName, options)
 306                                                 if (callback) callback(res);
 307                                         }
 308                                 }
 309                         }
 310                         if (img.tagName.toLowerCase() == "canvas") {
 311                                 var res = Pixastic.applyAction(img, img, actionName, options);
 312                                 if (callback) callback(res);
 313                                 return res;
 314                         }
 315                 },
 316
 317                 revert : function(img) {
 318                         if (Pixastic.Client.hasCanvas()) {
 319                                 if (img.tagName.toLowerCase() == "canvas" && img.__pixastic_org_image) {
 320                                         img.width = img.__pixastic_org_width;
 321                                         img.height = img.__pixastic_org_height;
 322                                         img.getContext("2d").drawImage(img.__pixastic_org_image, 0, 0);
 323
 324                                         if (img.parentNode && img.parentNode.replaceChild) {
 325                                                 img.parentNode.replaceChild(img.__pixastic_org_image, img);
 326                                         }
 327
 328                                         return img;
 329                                 }
 330                         } else if (Pixastic.Client.isIE() && typeof img.__pixastic_org_style != "undefined") {
 331                                 img.style.cssText = img.__pixastic_org_style;
 332                         }
 333                 },
 334
 335                 Client : {
 336                         hasCanvas : (function() {
 337                                 var c = document.createElement("canvas");
 338                                 var val = false;
 339                                 try {
 340                                         val = !!((typeof c.getContext == "function") && c.getContext("2d"));
 341                                 } catch(e) {}
 342                                 return function() {
 343                                         return val;
 344                                 }
 345                         })(),
 346
 347                         hasCanvasImageData : (function() {
 348                                 var c = document.createElement("canvas");
 349                                 var val = false;
 350                                 var ctx;
 351                                 try {
 352                                         if (typeof c.getContext == "function" && (ctx = c.getContext("2d"))) {
 353                                                 val = (typeof ctx.getImageData == "function");
 354                                         }
 355                                 } catch(e) {}
 356                                 return function() {
 357                                         return val;
 358                                 }
 359                         })(),
 360
 361                         isIE : function() {
 362                                 return !!document.all && !!window.attachEvent && !window.opera;
 363                         }
 364                 },
 365
 366                 Actions : {}
 367         }
 368
 369
 370 })();
 371 /*
 372  * Pixastic Lib - jQuery plugin
 373  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
 374  * License: [http://www.pixastic.com/lib/license.txt]
 375  */
 376
 377 if (typeof jQuery != "undefined" && jQuery && jQuery.fn) {
 378         jQuery.fn.pixastic = function(action, options) {
 379                 var newElements = [];
 380                 this.each(
 381                         function () {
 382                                 if (this.tagName.toLowerCase() == "img" && !this.complete) {
 383                                         return;
 384                                 }
 385                                 var res = Pixastic.process(this, action, options);
 386                                 if (res) {
 387                                         newElements.push(res);
 388                                 }
 389                         }
 390                 );
 391                 if (newElements.length > 0)
 392                         return jQuery(newElements);
 393                 else
 394                         return this;
 395         };
 396
 397 };
 398 /*
 399  * Pixastic Lib - Blend - v0.1.1
 400  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
 401  * License: [http://www.pixastic.com/lib/license.txt]
 402  */
 403
 404 Pixastic.Actions.blend = {
 405
 406         process : function(params) {
 407                 var amount = parseFloat(params.options.amount);
 408                 var mode = (params.options.mode || "normal").toLowerCase();
 409                 var image = params.options.image;
 410
 411                 amount = Math.max(0,Math.min(1,amount));
 412
 413                 if (!image) return false;
 414
 415                 if (Pixastic.Client.hasCanvasImageData()) {
 416                         var rect = params.options.rect;
 417                         var data = Pixastic.prepareData(params);
 418                         var w = rect.width;
 419                         var h = rect.height;
 420
 421                         params.useData = false;
 422
 423                         var otherCanvas = document.createElement("canvas");
 424                         otherCanvas.width = params.canvas.width;
 425                         otherCanvas.height = params.canvas.height;
 426                         var otherCtx = otherCanvas.getContext("2d");
 427                         otherCtx.drawImage(image,0,0);
 428
 429                         var params2 = {canvas:otherCanvas,options:params.options};
 430                         var data2 = Pixastic.prepareData(params2);
 431                         var dataDesc2 = params2.canvasData;
 432
 433                         var p = w*h;
 434                         var pix = p*4;
 435                         var pix1, pix2;
 436                         var r1, g1, b1;
 437                         var r2, g2, b2;
 438                         var r3, g3, b3;
 439                         var r4, g4, b4;
 440
 441                         var dataChanged = false;
 442
 443                         switch (mode) {
 444                                 case "normal" :
 445                                         //while (p--) {
 446                                         //      data2[pix-=4] = data2[pix];
 447                                         //      data2[pix1=pix+1] = data2[pix1];
 448                                         //      data2[pix2=pix+2] = data2[pix2];
 449                                         //}
 450                                         break;
 451
 452                                 case "multiply" :
 453                                         while (p--) {
 454                                                 data2[pix-=4] = data[pix] * data2[pix] / 255;
 455                                                 data2[pix1=pix+1] = data[pix1] * data2[pix1] / 255;
 456                                                 data2[pix2=pix+2] = data[pix2] * data2[pix2] / 255;
 457                                         }
 458                                         dataChanged = true;
 459                                         break;
 460
 461                                 case "lighten" :
 462                                         while (p--) {
 463                                                 if ((r1 = data[pix-=4]) > data2[pix])
 464                                                         data2[pix] = r1;
 465                                                 if ((g1 = data[pix1=pix+1]) > data2[pix1])
 466                                                         data2[pix1] = g1;
 467                                                 if ((b1 = data[pix2=pix+2]) > data2[pix2])
 468                                                         data2[pix2] = b1;
 469                                         }
 470                                         dataChanged = true;
 471                                         break;
 472
 473                                 case "darken" :
 474                                         while (p--) {
 475                                                 if ((r1 = data[pix-=4]) < data2[pix])
 476                                                         data2[pix] = r1;
 477                                                 if ((g1 = data[pix1=pix+1]) < data2[pix1])
 478                                                         data2[pix1] = g1;
 479                                                 if ((b1 = data[pix2=pix+2]) < data2[pix2])
 480                                                         data2[pix2] = b1;
 481
 482                                         }
 483                                         dataChanged = true;
 484                                         break;
 485
 486                                 case "darkercolor" :
 487                                         while (p--) {
 488                                                 if (((r1 = data[pix-=4])*0.3+(g1 = data[pix1=pix+1])*0.59+(b1 = data[pix2=pix+2])*0.11) <= (data2[pix]*0.3+data2[pix1]*0.59+data2[pix2]*0.11)) {
 489                                                         data2[pix] = r1;
 490                                                         data2[pix1] = g1;
 491                                                         data2[pix2] = b1;
 492                                                 }
 493                                         }
 494                                         dataChanged = true;
 495                                         break;
 496
 497                                 case "lightercolor" :
 498                                         while (p--) {
 499                                                 if (((r1 = data[pix-=4])*0.3+(g1 = data[pix1=pix+1])*0.59+(b1 = data[pix2=pix+2])*0.11) > (data2[pix]*0.3+data2[pix1]*0.59+data2[pix2]*0.11)) {
 500                                                         data2[pix] = r1;
 501                                                         data2[pix1] = g1;
 502                                                         data2[pix2] = b1;
 503                                                 }
 504                                         }
 505                                         dataChanged = true;
 506                                         break;
 507
 508                                 case "lineardodge" :
 509                                         otherCtx.globalCompositeOperation = "source-over";
 510                                         otherCtx.drawImage(params.canvas, 0, 0);
 511                                         otherCtx.globalCompositeOperation = "lighter";
 512                                         otherCtx.drawImage(image, 0, 0);
 513
 514                                         /*
 515                                         while (p--) {
 516                                                 if ((r3 = data[pix-=4] + data2[pix]) > 255)
 517                                                         data2[pix] = 255;
 518                                                 else
 519                                                         data2[pix] = r3;
 520                                                 if ((g3 = data[pix1=pix+1] + data2[pix1]) > 255)
 521                                                         data2[pix1] = 255;
 522                                                 else
 523                                                         data2[pix1] = g3;
 524                                                 if ((b3 = data[pix2=pix+2] + data2[pix2]) > 255)
 525                                                         data2[pix2] = 255;
 526                                                 else
 527                                                         data2[pix2] = b3;
 528                                         }
 529                                         dataChanged = true;
 530                                         */
 531
 532                                         break;
 533
 534                                 case "linearburn" :
 535                                         while (p--) {
 536                                                 if ((r3 = data[pix-=4] + data2[pix]) < 255)
 537                                                         data2[pix] = 0;
 538                                                 else
 539                                                         data2[pix] = (r3 - 255);
 540                                                 if ((g3 = data[pix1=pix+1] + data2[pix1]) < 255)
 541                                                         data2[pix1] = 0;
 542                                                 else
 543                                                         data2[pix1] = (g3 - 255);
 544                                                 if ((b3 = data[pix2=pix+2] + data2[pix2]) < 255)
 545                                                         data2[pix2] = 0;
 546                                                 else
 547                                                         data2[pix2] = (b3 - 255);
 548                                         }
 549                                         dataChanged = true;
 550                                         break;
 551
 552                                 case "difference" :
 553                                         while (p--) {
 554                                                 if ((r3 = data[pix-=4] - data2[pix]) < 0)
 555                                                         data2[pix] = -r3;
 556                                                 else
 557                                                         data2[pix] = r3;
 558                                                 if ((g3 = data[pix1=pix+1] - data2[pix1]) < 0)
 559                                                         data2[pix1] = -g3;
 560                                                 else
 561                                                         data2[pix1] = g3;
 562                                                 if ((b3 = data[pix2=pix+2] - data2[pix2]) < 0)
 563                                                         data2[pix2] = -b3;
 564                                                 else
 565                                                         data2[pix2] = b3;
 566                                         }
 567                                         dataChanged = true;
 568                                         break;
 569
 570                                 case "screen" :
 571                                         while (p--) {
 572                                                 data2[pix-=4] = (255 - ( ((255-data2[pix])*(255-data[pix])) >> 8));
 573                                                 data2[pix1=pix+1] = (255 - ( ((255-data2[pix1])*(255-data[pix1])) >> 8));
 574                                                 data2[pix2=pix+2] = (255 - ( ((255-data2[pix2])*(255-data[pix2])) >> 8));
 575                                         }
 576                                         dataChanged = true;
 577                                         break;
 578
 579                                 case "exclusion" :
 580                                         var div_2_255 = 2 / 255;
 581                                         while (p--) {
 582                                                 data2[pix-=4] = (r1 = data[pix]) - (r1 * div_2_255 - 1) * data2[pix];
 583                                                 data2[pix1=pix+1] = (g1 = data[pix1]) - (g1 * div_2_255 - 1) * data2[pix1];
 584                                                 data2[pix2=pix+2] = (b1 = data[pix2]) - (b1 * div_2_255 - 1) * data2[pix2];
 585                                         }
 586                                         dataChanged = true;
 587                                         break;
 588
 589                                 case "overlay" :
 590                                         var div_2_255 = 2 / 255;
 591                                         while (p--) {
 592                                                 if ((r1 = data[pix-=4]) < 128)
 593                                                         data2[pix] = data2[pix]*r1*div_2_255;
 594                                                 else
 595                                                         data2[pix] = 255 - (255-data2[pix])*(255-r1)*div_2_255;
 596
 597                                                 if ((g1 = data[pix1=pix+1]) < 128)
 598                                                         data2[pix1] = data2[pix1]*g1*div_2_255;
 599                                                 else
 600                                                         data2[pix1] = 255 - (255-data2[pix1])*(255-g1)*div_2_255;
 601
 602                                                 if ((b1 = data[pix2=pix+2]) < 128)
 603                                                         data2[pix2] = data2[pix2]*b1*div_2_255;
 604                                                 else
 605                                                         data2[pix2] = 255 - (255-data2[pix2])*(255-b1)*div_2_255;
 606
 607                                         }
 608                                         dataChanged = true;
 609                                         break;
 610
 611                                 case "softlight" :
 612                                         var div_2_255 = 2 / 255;
 613                                         while (p--) {
 614                                                 if ((r1 = data[pix-=4]) < 128)
 615                                                         data2[pix] = ((data2[pix]>>1) + 64) * r1 * div_2_255;
 616                                                 else
 617                                                         data2[pix] = 255 - (191 - (data2[pix]>>1)) * (255-r1) * div_2_255;
 618
 619                                                 if ((g1 = data[pix1=pix+1]) < 128)
 620                                                         data2[pix1] = ((data2[pix1]>>1)+64) * g1 * div_2_255;
 621                                                 else
 622                                                         data2[pix1] = 255 - (191 - (data2[pix1]>>1)) * (255-g1) * div_2_255;
 623
 624                                                 if ((b1 = data[pix2=pix+2]) < 128)
 625                                                         data2[pix2] = ((data2[pix2]>>1)+64) * b1 * div_2_255;
 626                                                 else
 627                                                         data2[pix2] = 255 - (191 - (data2[pix2]>>1)) * (255-b1) * div_2_255;
 628
 629                                         }
 630                                         dataChanged = true;
 631                                         break;
 632
 633                                 case "hardlight" :
 634                                         var div_2_255 = 2 / 255;
 635                                         while (p--) {
 636                                                 if ((r2 = data2[pix-=4]) < 128)
 637                                                         data2[pix] = data[pix] * r2 * div_2_255;
 638                                                 else
 639                                                         data2[pix] = 255 - (255-data[pix]) * (255-r2) * div_2_255;
 640
 641                                                 if ((g2 = data2[pix1=pix+1]) < 128)
 642                                                         data2[pix1] = data[pix1] * g2 * div_2_255;
 643                                                 else
 644                                                         data2[pix1] = 255 - (255-data[pix1]) * (255-g2) * div_2_255;
 645
 646                                                 if ((b2 = data2[pix2=pix+2]) < 128)
 647                                                         data2[pix2] = data[pix2] * b2 * div_2_255;
 648                                                 else
 649                                                         data2[pix2] = 255 - (255-data[pix2]) * (255-b2) * div_2_255;
 650
 651                                         }
 652                                         dataChanged = true;
 653                                         break;
 654
 655                                 case "colordodge" :
 656                                         while (p--) {
 657                                                 if ((r3 = (data[pix-=4]<<8)/(255-(r2 = data2[pix]))) > 255 || r2 == 255)
 658                                                         data2[pix] = 255;
 659                                                 else
 660                                                         data2[pix] = r3;
 661
 662                                                 if ((g3 = (data[pix1=pix+1]<<8)/(255-(g2 = data2[pix1]))) > 255 || g2 == 255)
 663                                                         data2[pix1] = 255;
 664                                                 else
 665                                                         data2[pix1] = g3;
 666
 667                                                 if ((b3 = (data[pix2=pix+2]<<8)/(255-(b2 = data2[pix2]))) > 255 || b2 == 255)
 668                                                         data2[pix2] = 255;
 669                                                 else
 670                                                         data2[pix2] = b3;
 671                                         }
 672                                         dataChanged = true;
 673                                         break;
 674
 675                                 case "colorburn" :
 676                                         while (p--) {
 677                                                 if ((r3 = 255-((255-data[pix-=4])<<8)/data2[pix]) < 0 || data2[pix] == 0)
 678                                                         data2[pix] = 0;
 679                                                 else
 680                                                         data2[pix] = r3;
 681
 682                                                 if ((g3 = 255-((255-data[pix1=pix+1])<<8)/data2[pix1]) < 0 || data2[pix1] == 0)
 683                                                         data2[pix1] = 0;
 684                                                 else
 685                                                         data2[pix1] = g3;
 686
 687                                                 if ((b3 = 255-((255-data[pix2=pix+2])<<8)/data2[pix2]) < 0 || data2[pix2] == 0)
 688                                                         data2[pix2] = 0;
 689                                                 else
 690                                                         data2[pix2] = b3;
 691                                         }
 692                                         dataChanged = true;
 693                                         break;
 694
 695                                 case "linearlight" :
 696                                         while (p--) {
 697                                                 if ( ((r3 = 2*(r2=data2[pix-=4])+data[pix]-256) < 0) || (r2 < 128 && r3 < 0)) {
 698                                                         data2[pix] = 0
 699                                                 } else {
 700                                                         if (r3 > 255)
 701                                                                 data2[pix] = 255;
 702                                                         else
 703                                                                 data2[pix] = r3;
 704                                                 }
 705                                                 if ( ((g3 = 2*(g2=data2[pix1=pix+1])+data[pix1]-256) < 0) || (g2 < 128 && g3 < 0)) {
 706                                                         data2[pix1] = 0
 707                                                 } else {
 708                                                         if (g3 > 255)
 709                                                                 data2[pix1] = 255;
 710                                                         else
 711                                                                 data2[pix1] = g3;
 712                                                 }
 713                                                 if ( ((b3 = 2*(b2=data2[pix2=pix+2])+data[pix2]-256) < 0) || (b2 < 128 && b3 < 0)) {
 714                                                         data2[pix2] = 0
 715                                                 } else {
 716                                                         if (b3 > 255)
 717                                                                 data2[pix2] = 255;
 718                                                         else
 719                                                                 data2[pix2] = b3;
 720                                                 }
 721                                         }
 722                                         dataChanged = true;
 723                                         break;
 724
 725                                 case "vividlight" :
 726                                         while (p--) {
 727                                                 if ((r2=data2[pix-=4]) < 128) {
 728                                                         if (r2) {
 729                                                                 if ((r3 = 255 - ((255-data[pix])<<8) / (2*r2)) < 0)
 730                                                                         data2[pix] = 0;
 731                                                                 else
 732                                                                         data2[pix] = r3
 733                                                         } else {
 734                                                                 data2[pix] = 0;
 735                                                         }
 736                                                 } else if ((r3 = (r4=2*r2-256)) < 255) {
 737                                                         if ((r3 = (data[pix]<<8)/(255-r4)) > 255)
 738                                                                 data2[pix] = 255;
 739                                                         else
 740                                                                 data2[pix] = r3;
 741                                                 } else {
 742                                                         if (r3 < 0)
 743                                                                 data2[pix] = 0;
 744                                                         else
 745                                                                 data2[pix] = r3
 746                                                 }
 747
 748                                                 if ((g2=data2[pix1=pix+1]) < 128) {
 749                                                         if (g2) {
 750                                                                 if ((g3 = 255 - ((255-data[pix1])<<8) / (2*g2)) < 0)
 751                                                                         data2[pix1] = 0;
 752                                                                 else
 753                                                                         data2[pix1] = g3;
 754                                                         } else {
 755                                                                 data2[pix1] = 0;
 756                                                         }
 757                                                 } else if ((g3 = (g4=2*g2-256)) < 255) {
 758                                                         if ((g3 = (data[pix1]<<8)/(255-g4)) > 255)
 759                                                                 data2[pix1] = 255;
 760                                                         else
 761                                                                 data2[pix1] = g3;
 762                                                 } else {
 763                                                         if (g3 < 0)
 764                                                                 data2[pix1] = 0;
 765                                                         else
 766                                                                 data2[pix1] = g3;
 767                                                 }
 768
 769                                                 if ((b2=data2[pix2=pix+2]) < 128) {
 770                                                         if (b2) {
 771                                                                 if ((b3 = 255 - ((255-data[pix2])<<8) / (2*b2)) < 0)
 772                                                                         data2[pix2] = 0;
 773                                                                 else
 774                                                                         data2[pix2] = b3;
 775                                                         } else {
 776                                                                 data2[pix2] = 0;
 777                                                         }
 778                                                 } else if ((b3 = (b4=2*b2-256)) < 255) {
 779                                                         if ((b3 = (data[pix2]<<8)/(255-b4)) > 255)
 780                                                                 data2[pix2] = 255;
 781                                                         else
 782                                                                 data2[pix2] = b3;
 783                                                 } else {
 784                                                         if (b3 < 0)
 785                                                                 data2[pix2] = 0;
 786                                                         else
 787                                                                 data2[pix2] = b3;
 788                                                 }
 789                                         }
 790                                         dataChanged = true;
 791                                         break;
 792
 793                                 case "pinlight" :
 794                                         while (p--) {
 795                                                 if ((r2=data2[pix-=4]) < 128)
 796                                                         if ((r1=data[pix]) < (r4=2*r2))
 797                                                                 data2[pix] = r1;
 798                                                         else
 799                                                                 data2[pix] = r4;
 800                                                 else
 801                                                         if ((r1=data[pix]) > (r4=2*r2-256))
 802                                                                 data2[pix] = r1;
 803                                                         else
 804                                                                 data2[pix] = r4;
 805
 806                                                 if ((g2=data2[pix1=pix+1]) < 128)
 807                                                         if ((g1=data[pix1]) < (g4=2*g2))
 808                                                                 data2[pix1] = g1;
 809                                                         else
 810                                                                 data2[pix1] = g4;
 811                                                 else
 812                                                         if ((g1=data[pix1]) > (g4=2*g2-256))
 813                                                                 data2[pix1] = g1;
 814                                                         else
 815                                                                 data2[pix1] = g4;
 816
 817                                                 if ((r2=data2[pix2=pix+2]) < 128)
 818                                                         if ((r1=data[pix2]) < (r4=2*r2))
 819                                                                 data2[pix2] = r1;
 820                                                         else
 821                                                                 data2[pix2] = r4;
 822                                                 else
 823                                                         if ((r1=data[pix2]) > (r4=2*r2-256))
 824                                                                 data2[pix2] = r1;
 825                                                         else
 826                                                                 data2[pix2] = r4;
 827                                         }
 828                                         dataChanged = true;
 829                                         break;
 830
 831                                 case "hardmix" :
 832                                         while (p--) {
 833                                                 if ((r2 = data2[pix-=4]) < 128)
 834                                                         if (255 - ((255-data[pix])<<8)/(2*r2) < 128 || r2 == 0)
 835                                                                 data2[pix] = 0;
 836                                                         else
 837                                                                 data2[pix] = 255;
 838                                                 else if ((r4=2*r2-256) < 255 && (data[pix]<<8)/(255-r4) < 128)
 839                                                         data2[pix] = 0;
 840                                                 else
 841                                                         data2[pix] = 255;
 842
 843                                                 if ((g2 = data2[pix1=pix+1]) < 128)
 844                                                         if (255 - ((255-data[pix1])<<8)/(2*g2) < 128 || g2 == 0)
 845                                                                 data2[pix1] = 0;
 846                                                         else
 847                                                                 data2[pix1] = 255;
 848                                                 else if ((g4=2*g2-256) < 255 && (data[pix1]<<8)/(255-g4) < 128)
 849                                                         data2[pix1] = 0;
 850                                                 else
 851                                                         data2[pix1] = 255;
 852
 853                                                 if ((b2 = data2[pix2=pix+2]) < 128)
 854                                                         if (255 - ((255-data[pix2])<<8)/(2*b2) < 128 || b2 == 0)
 855                                                                 data2[pix2] = 0;
 856                                                         else
 857                                                                 data2[pix2] = 255;
 858                                                 else if ((b4=2*b2-256) < 255 && (data[pix2]<<8)/(255-b4) < 128)
 859                                                         data2[pix2] = 0;
 860                                                 else
 861                                                         data2[pix2] = 255;
 862                                         }
 863                                         dataChanged = true;
 864                                         break;
 865                         }
 866
 867                         if (dataChanged)
 868                                 otherCtx.putImageData(dataDesc2,0,0);
 869
 870                         var ctx = params.canvas.getContext("2d");
 871                         ctx.save();
 872                         ctx.globalAlpha = amount;
 873                         ctx.drawImage(
 874                                 otherCanvas,
 875                                 0,0,rect.width,rect.height,
 876                                 rect.left,rect.top,rect.width,rect.height
 877                         );
 878                         ctx.globalAlpha = 1;
 879                         ctx.restore();
 880
 881                         return true;
 882                 }
 883         },
 884         checkSupport : function() {
 885                 return Pixastic.Client.hasCanvasImageData();
 886         }
 887 }/*
 888  * Pixastic Lib - Blur filter - v0.1.0
 889  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
 890  * License: [http://www.pixastic.com/lib/license.txt]
 891  */
 892
 893 Pixastic.Actions.blur = {
 894         process : function(params) {
 895
 896                 if (typeof params.options.fixMargin == "undefined")
 897                         params.options.fixMargin = true;
 898
 899                 if (Pixastic.Client.hasCanvasImageData()) {
 900                         var data = Pixastic.prepareData(params);
 901                         var dataCopy = Pixastic.prepareData(params, true)
 902
 903                         /*
 904                         var kernel = [
 905                                 [0.5,   1,      0.5],
 906                                 [1,     2,      1],
 907                                 [0.5,   1,      0.5]
 908                         ];
 909                         */
 910
 911                         var kernel = [
 912                                 [0,     1,      0],
 913                                 [1,     2,      1],
 914                                 [0,     1,      0]
 915                         ];
 916
 917                         var weight = 0;
 918                         for (var i=0;i<3;i++) {
 919                                 for (var j=0;j<3;j++) {
 920                                         weight += kernel[i][j];
 921                                 }
 922                         }
 923
 924                         weight = 1 / (weight*2);
 925
 926                         var rect = params.options.rect;
 927                         var w = rect.width;
 928                         var h = rect.height;
 929
 930                         var w4 = w*4;
 931                         var y = h;
 932                         do {
 933                                 var offsetY = (y-1)*w4;
 934
 935                                 var prevY = (y == 1) ? 0 : y-2;
 936                                 var nextY = (y == h) ? y - 1 : y;
 937
 938                                 var offsetYPrev = prevY*w*4;
 939                                 var offsetYNext = nextY*w*4;
 940
 941                                 var x = w;
 942                                 do {
 943                                         var offset = offsetY + (x*4-4);
 944
 945                                         var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
 946                                         var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
 947
 948                                         data[offset] = (
 949                                                 /*
 950                                                 dataCopy[offsetPrev - 4]
 951                                                 + dataCopy[offsetPrev+4]
 952                                                 + dataCopy[offsetNext - 4]
 953                                                 + dataCopy[offsetNext+4]
 954                                                 +
 955                                                 */
 956                                                 (dataCopy[offsetPrev]
 957                                                 + dataCopy[offset-4]
 958                                                 + dataCopy[offset+4]
 959                                                 + dataCopy[offsetNext])         * 2
 960                                                 + dataCopy[offset]              * 4
 961                                                 ) * weight;
 962
 963                                         data[offset+1] = (
 964                                                 /*
 965                                                 dataCopy[offsetPrev - 3]
 966                                                 + dataCopy[offsetPrev+5]
 967                                                 + dataCopy[offsetNext - 3]
 968                                                 + dataCopy[offsetNext+5]
 969                                                 +
 970                                                 */
 971                                                 (dataCopy[offsetPrev+1]
 972                                                 + dataCopy[offset-3]
 973                                                 + dataCopy[offset+5]
 974                                                 + dataCopy[offsetNext+1])       * 2
 975                                                 + dataCopy[offset+1]            * 4
 976                                                 ) * weight;
 977
 978                                         data[offset+2] = (
 979                                                 /*
 980                                                 dataCopy[offsetPrev - 2]
 981                                                 + dataCopy[offsetPrev+6]
 982                                                 + dataCopy[offsetNext - 2]
 983                                                 + dataCopy[offsetNext+6]
 984                                                 +
 985                                                 */
 986                                                 (dataCopy[offsetPrev+2]
 987                                                 + dataCopy[offset-2]
 988                                                 + dataCopy[offset+6]
 989                                                 + dataCopy[offsetNext+2])       * 2
 990                                                 + dataCopy[offset+2]            * 4
 991                                                 ) * weight;
 992
 993                                 } while (--x);
 994                         } while (--y);
 995
 996                         return true;
 997
 998                 } else if (Pixastic.Client.isIE()) {
 999                         params.image.style.filter += " progid:DXImageTransform.Microsoft.Blur(pixelradius=1.5)";
1000
1001                         if (params.options.fixMargin) {
1002                                 params.image.style.marginLeft = (parseInt(params.image.style.marginLeft,10)||0) - 2 + "px";
1003                                 params.image.style.marginTop = (parseInt(params.image.style.marginTop,10)||0) - 2 + "px";
1004                         }
1005
1006                         return true;
1007                 }
1008         },
1009         checkSupport : function() {
1010                 return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
1011         }
1012 }/*
1013  * Pixastic Lib - Blur Fast - v0.1.1
1014  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1015  * License: [http://www.pixastic.com/lib/license.txt]
1016  */
1017
1018 Pixastic.Actions.blurfast = {
1019         process : function(params) {
1020
1021                 var amount = parseFloat(params.options.amount)||0;
1022                 var clear = !!(params.options.clear && params.options.clear != "false");
1023
1024                 amount = Math.max(0,Math.min(5,amount));
1025
1026                 if (Pixastic.Client.hasCanvas()) {
1027                         var rect = params.options.rect;
1028
1029                         var ctx = params.canvas.getContext("2d");
1030                         ctx.save();
1031                         ctx.beginPath();
1032                         ctx.rect(rect.left, rect.top, rect.width, rect.height);
1033                         ctx.clip();
1034
1035                         var scale = 2;
1036                         var smallWidth = Math.round(params.width / scale);
1037                         var smallHeight = Math.round(params.height / scale);
1038
1039                         var copy = document.createElement("canvas");
1040                         copy.width = smallWidth;
1041                         copy.height = smallHeight;
1042
1043                         var clear = false;
1044                         var steps = Math.round(amount * 20);
1045
1046                         var copyCtx = copy.getContext("2d");
1047                         for (var i=0;i<steps;i++) {
1048                                 var scaledWidth = Math.max(1,Math.round(smallWidth - i));
1049                                 var scaledHeight = Math.max(1,Math.round(smallHeight - i));
1050
1051                                 copyCtx.clearRect(0,0,smallWidth,smallHeight);
1052
1053                                 copyCtx.drawImage(
1054                                         params.canvas,
1055                                         0,0,params.width,params.height,
1056                                         0,0,scaledWidth,scaledHeight
1057                                 );
1058
1059                                 if (clear)
1060                                         ctx.clearRect(rect.left,rect.top,rect.width,rect.height);
1061
1062                                 ctx.drawImage(
1063                                         copy,
1064                                         0,0,scaledWidth,scaledHeight,
1065                                         0,0,params.width,params.height
1066                                 );
1067                         }
1068
1069                         ctx.restore();
1070
1071                         params.useData = false;
1072                         return true;
1073                 } else if (Pixastic.Client.isIE()) {
1074                         var radius = 10 * amount;
1075                         params.image.style.filter += " progid:DXImageTransform.Microsoft.Blur(pixelradius=" + radius + ")";
1076
1077                         if (params.options.fixMargin || 1) {
1078                                 params.image.style.marginLeft = (parseInt(params.image.style.marginLeft,10)||0) - Math.round(radius) + "px";
1079                                 params.image.style.marginTop = (parseInt(params.image.style.marginTop,10)||0) - Math.round(radius) + "px";
1080                         }
1081
1082                         return true;
1083                 }
1084         },
1085         checkSupport : function() {
1086                 return (Pixastic.Client.hasCanvas() || Pixastic.Client.isIE());
1087         }
1088 }
1089 /*
1090  * Pixastic Lib - Brightness/Contrast filter - v0.1.1
1091  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1092  * License: [http://www.pixastic.com/lib/license.txt]
1093  */
1094
1095 Pixastic.Actions.brightness = {
1096
1097         process : function(params) {
1098
1099                 var brightness = parseInt(params.options.brightness,10) || 0;
1100                 var contrast = parseFloat(params.options.contrast)||0;
1101                 var legacy = !!(params.options.legacy && params.options.legacy != "false");
1102
1103                 if (legacy) {
1104                         brightness = Math.min(150,Math.max(-150,brightness));
1105                 } else {
1106                         var brightMul = 1 + Math.min(150,Math.max(-150,brightness)) / 150;
1107                 }
1108                 contrast = Math.max(0,contrast+1);
1109
1110                 if (Pixastic.Client.hasCanvasImageData()) {
1111                         var data = Pixastic.prepareData(params);
1112                         var rect = params.options.rect;
1113                         var w = rect.width;
1114                         var h = rect.height;
1115
1116                         var p = w*h;
1117                         var pix = p*4, pix1, pix2;
1118
1119                         var mul, add;
1120                         if (contrast != 1) {
1121                                 if (legacy) {
1122                                         mul = contrast;
1123                                         add = (brightness - 128) * contrast + 128;
1124                                 } else {
1125                                         mul = brightMul * contrast;
1126                                         add = - contrast * 128 + 128;
1127                                 }
1128                         } else {  // this if-then is not necessary anymore, is it?
1129                                 if (legacy) {
1130                                         mul = 1;
1131                                         add = brightness;
1132                                 } else {
1133                                         mul = brightMul;
1134                                         add = 0;
1135                                 }
1136                         }
1137                         var r, g, b;
1138                         while (p--) {
1139                                 if ((r = data[pix-=4] * mul + add) > 255 )
1140                                         data[pix] = 255;
1141                                 else if (r < 0)
1142                                         data[pix] = 0;
1143                                 else
1144                                         data[pix] = r;
1145
1146                                 if ((g = data[pix1=pix+1] * mul + add) > 255 )
1147                                         data[pix1] = 255;
1148                                 else if (g < 0)
1149                                         data[pix1] = 0;
1150                                 else
1151                                         data[pix1] = g;
1152
1153                                 if ((b = data[pix2=pix+2] * mul + add) > 255 )
1154                                         data[pix2] = 255;
1155                                 else if (b < 0)
1156                                         data[pix2] = 0;
1157                                 else
1158                                         data[pix2] = b;
1159                         }
1160                         return true;
1161                 }
1162         },
1163         checkSupport : function() {
1164                 return Pixastic.Client.hasCanvasImageData();
1165         }
1166 }
1167
1168 /*
1169  * Pixastic Lib - Color adjust filter - v0.1.1
1170  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1171  * License: [http://www.pixastic.com/lib/license.txt]
1172  */
1173
1174 Pixastic.Actions.coloradjust = {
1175
1176         process : function(params) {
1177                 var red = parseFloat(params.options.red) || 0;
1178                 var green = parseFloat(params.options.green) || 0;
1179                 var blue = parseFloat(params.options.blue) || 0;
1180
1181                 red = Math.round(red*255);
1182                 green = Math.round(green*255);
1183                 blue = Math.round(blue*255);
1184
1185                 if (Pixastic.Client.hasCanvasImageData()) {
1186                         var data = Pixastic.prepareData(params);
1187                         var rect = params.options.rect;
1188
1189                         var p = rect.width*rect.height;
1190                         var pix = p*4, pix1, pix2;
1191
1192                         var r, g, b;
1193                         while (p--) {
1194                                 pix -= 4;
1195
1196                                 if (red) {
1197                                         if ((r = data[pix] + red) < 0 )
1198                                                 data[pix] = 0;
1199                                         else if (r > 255 )
1200                                                 data[pix] = 255;
1201                                         else
1202                                                 data[pix] = r;
1203                                 }
1204
1205                                 if (green) {
1206                                         if ((g = data[pix1=pix+1] + green) < 0 )
1207                                                 data[pix1] = 0;
1208                                         else if (g > 255 )
1209                                                 data[pix1] = 255;
1210                                         else
1211                                                 data[pix1] = g;
1212                                 }
1213
1214                                 if (blue) {
1215                                         if ((b = data[pix2=pix+2] + blue) < 0 )
1216                                                 data[pix2] = 0;
1217                                         else if (b > 255 )
1218                                                 data[pix2] = 255;
1219                                         else
1220                                                 data[pix2] = b;
1221                                 }
1222                         }
1223                         return true;
1224                 }
1225         },
1226         checkSupport : function() {
1227                 return (Pixastic.Client.hasCanvasImageData());
1228         }
1229 }
1230 /*
1231  * Pixastic Lib - Histogram - v0.1.0
1232  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1233  * License: [http://www.pixastic.com/lib/license.txt]
1234  */
1235
1236
1237 Pixastic.Actions.colorhistogram = {
1238
1239         array256 : function(default_value) {
1240                 arr = [];
1241                 for (var i=0; i<256; i++) { arr[i] = default_value; }
1242                 return arr
1243         },
1244
1245         process : function(params) {
1246                 var values = [];
1247                 if (typeof params.options.returnValue != "object") {
1248                         params.options.returnValue = {rvals:[], gvals:[], bvals:[]};
1249                 }
1250                 var paint = !!(params.options.paint);
1251
1252                 var returnValue = params.options.returnValue;
1253                 if (typeof returnValue.values != "array") {
1254                         returnValue.rvals = [];
1255                         returnValue.gvals = [];
1256                         returnValue.bvals = [];
1257                 }
1258
1259                 if (Pixastic.Client.hasCanvasImageData()) {
1260                         var data = Pixastic.prepareData(params);
1261                         params.useData = false;
1262
1263                         var rvals = this.array256(0);
1264                         var gvals = this.array256(0);
1265                         var bvals = this.array256(0);
1266
1267                         var rect = params.options.rect;
1268
1269                         var p = rect.width*rect.height;
1270                         var pix = p*4;
1271                         while (p--) {
1272                                 rvals[data[pix-=4]]++;
1273                                 gvals[data[pix+1]]++;
1274                                 bvals[data[pix+2]]++;
1275                         }
1276
1277                         returnValue.rvals = rvals;
1278                         returnValue.gvals = gvals;
1279                         returnValue.bvals = bvals;
1280
1281                         if (paint) {
1282                                 var ctx = params.canvas.getContext("2d");
1283                                 var vals = [rvals, gvals, bvals];
1284                                 for (var v=0;v<3;v++) {
1285                                         var yoff = (v+1) * params.height / 3;
1286                                         var maxValue = 0;
1287                                         for (var i=0;i<256;i++) {
1288                                                 if (vals[v][i] > maxValue)
1289                                                         maxValue = vals[v][i];
1290                                         }
1291                                         var heightScale = params.height / 3 / maxValue;
1292                                         var widthScale = params.width / 256;
1293                                         if (v==0) ctx.fillStyle = "rgba(255,0,0,0.5)";
1294                                         else if (v==1) ctx.fillStyle = "rgba(0,255,0,0.5)";
1295                                         else if (v==2) ctx.fillStyle = "rgba(0,0,255,0.5)";
1296                                         for (var i=0;i<256;i++) {
1297                                                 ctx.fillRect(
1298                                                         i * widthScale, params.height - heightScale * vals[v][i] - params.height + yoff,
1299                                                         widthScale, vals[v][i] * heightScale
1300                                                 );
1301                                         }
1302                                 }
1303                         }
1304                         return true;
1305                 }
1306         },
1307
1308         checkSupport : function() {
1309                 return Pixastic.Client.hasCanvasImageData();
1310         }
1311 }/*
1312  * Pixastic Lib - Crop - v0.1.1
1313  * Copyright (c) 2008-2009 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1314  * License: [http://www.pixastic.com/lib/license.txt]
1315  */
1316
1317 Pixastic.Actions.crop = {
1318         process : function(params) {
1319                 if (Pixastic.Client.hasCanvas()) {
1320                         var rect = params.options.rect;
1321
1322                         var width = rect.width;
1323                         var height = rect.height;
1324                         var top = rect.top;
1325                         var left = rect.left;
1326
1327                         if (typeof params.options.left != "undefined")
1328                                 left = parseInt(params.options.left,10);
1329                         if (typeof params.options.top != "undefined")
1330                                 top = parseInt(params.options.top,10);
1331                         if (typeof params.options.height != "undefined")
1332                                 width = parseInt(params.options.width,10);
1333                         if (typeof params.options.height != "undefined")
1334                                 height = parseInt(params.options.height,10);
1335
1336                         if (left < 0) left = 0;
1337                         if (left > params.width-1) left = params.width-1;
1338
1339                         if (top < 0) top = 0;
1340                         if (top > params.height-1) top = params.height-1;
1341
1342                         if (width < 1) width = 1;
1343                         if (left + width > params.width)
1344                                 width = params.width - left;
1345
1346                         if (height < 1) height = 1;
1347                         if (top + height > params.height)
1348                                 height = params.height - top;
1349
1350                         var copy = document.createElement("canvas");
1351                         copy.width = params.width;
1352                         copy.height = params.height;
1353                         copy.getContext("2d").drawImage(params.canvas,0,0);
1354
1355                         params.canvas.width = width;
1356                         params.canvas.height = height;
1357                         params.canvas.getContext("2d").clearRect(0,0,width,height);
1358
1359                         params.canvas.getContext("2d").drawImage(copy,
1360                                 left,top,width,height,
1361                                 0,0,width,height
1362                         );
1363
1364                         params.useData = false;
1365                         return true;
1366                 }
1367         },
1368         checkSupport : function() {
1369                 return Pixastic.Client.hasCanvas();
1370         }
1371 }
1372
1373
1374 /*
1375  * Pixastic Lib - Desaturation filter - v0.1.1
1376  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1377  * License: [http://www.pixastic.com/lib/license.txt]
1378  */
1379
1380 Pixastic.Actions.desaturate = {
1381
1382         process : function(params) {
1383                 var useAverage = !!(params.options.average && params.options.average != "false");
1384
1385                 if (Pixastic.Client.hasCanvasImageData()) {
1386                         var data = Pixastic.prepareData(params);
1387                         var rect = params.options.rect;
1388                         var w = rect.width;
1389                         var h = rect.height;
1390
1391                         var p = w*h;
1392                         var pix = p*4, pix1, pix2;
1393
1394                         if (useAverage) {
1395                                 while (p--)
1396                                         data[pix-=4] = data[pix1=pix+1] = data[pix2=pix+2] = (data[pix]+data[pix1]+data[pix2])/3
1397                         } else {
1398                                 while (p--)
1399                                         data[pix-=4] = data[pix1=pix+1] = data[pix2=pix+2] = (data[pix]*0.3 + data[pix1]*0.59 + data[pix2]*0.11);
1400                         }
1401                         return true;
1402                 } else if (Pixastic.Client.isIE()) {
1403                         params.image.style.filter += " gray";
1404                         return true;
1405                 }
1406         },
1407         checkSupport : function() {
1408                 return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
1409         }
1410 }/*
1411  * Pixastic Lib - Edge detection filter - v0.1.1
1412  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1413  * License: [http://www.pixastic.com/lib/license.txt]
1414  */
1415
1416 Pixastic.Actions.edges = {
1417         process : function(params) {
1418
1419                 var mono = !!(params.options.mono && params.options.mono != "false");
1420                 var invert = !!(params.options.invert && params.options.invert != "false");
1421
1422                 if (Pixastic.Client.hasCanvasImageData()) {
1423                         var data = Pixastic.prepareData(params);
1424                         var dataCopy = Pixastic.prepareData(params, true)
1425
1426                         var c = -1/8;
1427                         var kernel = [
1428                                 [c,     c,      c],
1429                                 [c,     1,      c],
1430                                 [c,     c,      c]
1431                         ];
1432
1433                         weight = 1/c;
1434
1435                         var rect = params.options.rect;
1436                         var w = rect.width;
1437                         var h = rect.height;
1438
1439                         var w4 = w*4;
1440                         var y = h;
1441                         do {
1442                                 var offsetY = (y-1)*w4;
1443
1444                                 var nextY = (y == h) ? y - 1 : y;
1445                                 var prevY = (y == 1) ? 0 : y-2;
1446
1447                                 var offsetYPrev = prevY*w*4;
1448                                 var offsetYNext = nextY*w*4;
1449
1450                                 var x = w;
1451                                 do {
1452                                         var offset = offsetY + (x*4-4);
1453
1454                                         var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
1455                                         var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
1456
1457                                         var r = ((dataCopy[offsetPrev-4]
1458                                                 + dataCopy[offsetPrev]
1459                                                 + dataCopy[offsetPrev+4]
1460                                                 + dataCopy[offset-4]
1461                                                 + dataCopy[offset+4]
1462                                                 + dataCopy[offsetNext-4]
1463                                                 + dataCopy[offsetNext]
1464                                                 + dataCopy[offsetNext+4]) * c
1465                                                 + dataCopy[offset]
1466                                                 )
1467                                                 * weight;
1468
1469                                         var g = ((dataCopy[offsetPrev-3]
1470                                                 + dataCopy[offsetPrev+1]
1471                                                 + dataCopy[offsetPrev+5]
1472                                                 + dataCopy[offset-3]
1473                                                 + dataCopy[offset+5]
1474                                                 + dataCopy[offsetNext-3]
1475                                                 + dataCopy[offsetNext+1]
1476                                                 + dataCopy[offsetNext+5]) * c
1477                                                 + dataCopy[offset+1])
1478                                                 * weight;
1479
1480                                         var b = ((dataCopy[offsetPrev-2]
1481                                                 + dataCopy[offsetPrev+2]
1482                                                 + dataCopy[offsetPrev+6]
1483                                                 + dataCopy[offset-2]
1484                                                 + dataCopy[offset+6]
1485                                                 + dataCopy[offsetNext-2]
1486                                                 + dataCopy[offsetNext+2]
1487                                                 + dataCopy[offsetNext+6]) * c
1488                                                 + dataCopy[offset+2])
1489                                                 * weight;
1490
1491                                         if (mono) {
1492                                                 var brightness = (r*0.3 + g*0.59 + b*0.11)||0;
1493                                                 if (invert) brightness = 255 - brightness;
1494                                                 if (brightness < 0 ) brightness = 0;
1495                                                 if (brightness > 255 ) brightness = 255;
1496                                                 r = g = b = brightness;
1497                                         } else {
1498                                                 if (invert) {
1499                                                         r = 255 - r;
1500                                                         g = 255 - g;
1501                                                         b = 255 - b;
1502                                                 }
1503                                                 if (r < 0 ) r = 0;
1504                                                 if (g < 0 ) g = 0;
1505                                                 if (b < 0 ) b = 0;
1506                                                 if (r > 255 ) r = 255;
1507                                                 if (g > 255 ) g = 255;
1508                                                 if (b > 255 ) b = 255;
1509                                         }
1510
1511                                         data[offset] = r;
1512                                         data[offset+1] = g;
1513                                         data[offset+2] = b;
1514
1515                                 } while (--x);
1516                         } while (--y);
1517
1518                         return true;
1519                 }
1520         },
1521         checkSupport : function() {
1522                 return Pixastic.Client.hasCanvasImageData();
1523         }
1524 }/*
1525  * Pixastic Lib - Edge detection 2 - v0.1.0
1526  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1527  * License: [http://www.pixastic.com/lib/license.txt]
1528  *
1529  * Contribution by Oliver Hunt (http://nerget.com/, http://nerget.com/canvas/edgeDetection.js). Thanks Oliver!
1530  *
1531  */
1532
1533 Pixastic.Actions.edges2 = {
1534         process : function(params) {
1535
1536                 if (Pixastic.Client.hasCanvasImageData()) {
1537                         var data = Pixastic.prepareData(params);
1538                         var dataCopy = Pixastic.prepareData(params, true)
1539
1540                         var rect = params.options.rect;
1541                         var w = rect.width;
1542                         var h = rect.height;
1543
1544                         var w4 = w * 4;
1545                         var pixel = w4 + 4; // Start at (1,1)
1546                         var hm1 = h - 1;
1547                         var wm1 = w - 1;
1548                         for (var y = 1; y < hm1; ++y) {
1549                                 // Prepare initial cached values for current row
1550                                 var centerRow = pixel - 4;
1551                                 var priorRow = centerRow - w4;
1552                                 var nextRow = centerRow + w4;
1553
1554                                 var r1 = - dataCopy[priorRow]   - dataCopy[centerRow]   - dataCopy[nextRow];
1555                                 var g1 = - dataCopy[++priorRow] - dataCopy[++centerRow] - dataCopy[++nextRow];
1556                                 var b1 = - dataCopy[++priorRow] - dataCopy[++centerRow] - dataCopy[++nextRow];
1557
1558                                 var rp = dataCopy[priorRow += 2];
1559                                 var gp = dataCopy[++priorRow];
1560                                 var bp = dataCopy[++priorRow];
1561
1562                                 var rc = dataCopy[centerRow += 2];
1563                                 var gc = dataCopy[++centerRow];
1564                                 var bc = dataCopy[++centerRow];
1565
1566                                 var rn = dataCopy[nextRow += 2];
1567                                 var gn = dataCopy[++nextRow];
1568                                 var bn = dataCopy[++nextRow];
1569
1570                                 var r2 = - rp - rc - rn;
1571                                 var g2 = - gp - gc - gn;
1572                                 var b2 = - bp - bc - bn;
1573
1574                                 // Main convolution loop
1575                                 for (var x = 1; x < wm1; ++x) {
1576                                         centerRow = pixel + 4;
1577                                         priorRow = centerRow - w4;
1578                                         nextRow = centerRow + w4;
1579
1580                                         var r = 127 + r1 - rp - (rc * -8) - rn;
1581                                         var g = 127 + g1 - gp - (gc * -8) - gn;
1582                                         var b = 127 + b1 - bp - (bc * -8) - bn;
1583
1584                                         r1 = r2;
1585                                         g1 = g2;
1586                                         b1 = b2;
1587
1588                                         rp = dataCopy[  priorRow];
1589                                         gp = dataCopy[++priorRow];
1590                                         bp = dataCopy[++priorRow];
1591
1592                                         rc = dataCopy[  centerRow];
1593                                         gc = dataCopy[++centerRow];
1594                                         bc = dataCopy[++centerRow];
1595
1596                                         rn = dataCopy[  nextRow];
1597                                         gn = dataCopy[++nextRow];
1598                                         bn = dataCopy[++nextRow];
1599
1600                                         r += (r2 = - rp - rc - rn);
1601                                         g += (g2 = - gp - gc - gn);
1602                                         b += (b2 = - bp - bc - bn);
1603
1604                                         if (r > 255) r = 255;
1605                                         if (g > 255) g = 255;
1606                                         if (b > 255) b = 255;
1607                                         if (r < 0) r = 0;
1608                                         if (g < 0) g = 0;
1609                                         if (b < 0) b = 0;
1610
1611                                         data[pixel] = r;
1612                                         data[++pixel] = g;
1613                                         data[++pixel] = b;
1614                                         //data[++pixel] = 255; // alpha
1615
1616                                         pixel+=2;
1617                                 }
1618                                 pixel += 8;
1619                         }
1620                         return true;
1621                 }
1622         },
1623         checkSupport : function() {
1624                 return Pixastic.Client.hasCanvasImageData();
1625         }
1626 }/*
1627  * Pixastic Lib - Emboss filter - v0.1.0
1628  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1629  * License: [http://www.pixastic.com/lib/license.txt]
1630  */
1631
1632 Pixastic.Actions.emboss = {
1633         process : function(params) {
1634
1635                 var strength = parseFloat(params.options.strength)||1;
1636                 var greyLevel = typeof params.options.greyLevel != "undefined" ? parseInt(params.options.greyLevel) : 180;
1637                 var direction = params.options.direction||"topleft";
1638                 var blend = !!(params.options.blend && params.options.blend != "false");
1639
1640                 var dirY = 0;
1641                 var dirX = 0;
1642
1643                 switch (direction) {
1644                         case "topleft":                 // top left
1645                                 dirY = -1;
1646                                 dirX = -1;
1647                                 break;
1648                         case "top":                     // top
1649                                 dirY = -1;
1650                                 dirX = 0;
1651                                 break;
1652                         case "topright":                        // top right
1653                                 dirY = -1;
1654                                 dirX = 1;
1655                                 break;
1656                         case "right":                   // right
1657                                 dirY = 0;
1658                                 dirX = 1;
1659                                 break;
1660                         case "bottomright":                     // bottom right
1661                                 dirY = 1;
1662                                 dirX = 1;
1663                                 break;
1664                         case "bottom":                  // bottom
1665                                 dirY = 1;
1666                                 dirX = 0;
1667                                 break;
1668                         case "bottomleft":                      // bottom left
1669                                 dirY = 1;
1670                                 dirX = -1;
1671                                 break;
1672                         case "left":                    // left
1673                                 dirY = 0;
1674                                 dirX = -1;
1675                                 break;
1676                 }
1677
1678                 if (Pixastic.Client.hasCanvasImageData()) {
1679                         var data = Pixastic.prepareData(params);
1680                         var dataCopy = Pixastic.prepareData(params, true)
1681
1682                         var invertAlpha = !!params.options.invertAlpha;
1683                         var rect = params.options.rect;
1684                         var w = rect.width;
1685                         var h = rect.height;
1686
1687                         var w4 = w*4;
1688                         var y = h;
1689                         do {
1690                                 var offsetY = (y-1)*w4;
1691
1692                                 var otherY = dirY;
1693                                 if (y + otherY < 1) otherY = 0;
1694                                 if (y + otherY > h) otherY = 0;
1695
1696                                 var offsetYOther = (y-1+otherY)*w*4;
1697
1698                                 var x = w;
1699                                 do {
1700                                                 var offset = offsetY + (x-1)*4;
1701
1702                                                 var otherX = dirX;
1703                                                 if (x + otherX < 1) otherX = 0;
1704                                                 if (x + otherX > w) otherX = 0;
1705
1706                                                 var offsetOther = offsetYOther + (x-1+otherX)*4;
1707
1708                                                 var dR = dataCopy[offset] - dataCopy[offsetOther];
1709                                                 var dG = dataCopy[offset+1] - dataCopy[offsetOther+1];
1710                                                 var dB = dataCopy[offset+2] - dataCopy[offsetOther+2];
1711
1712                                                 var dif = dR;
1713                                                 var absDif = dif > 0 ? dif : -dif;
1714
1715                                                 var absG = dG > 0 ? dG : -dG;
1716                                                 var absB = dB > 0 ? dB : -dB;
1717
1718                                                 if (absG > absDif) {
1719                                                         dif = dG;
1720                                                 }
1721                                                 if (absB > absDif) {
1722                                                         dif = dB;
1723                                                 }
1724
1725                                                 dif *= strength;
1726
1727                                                 if (blend) {
1728                                                         var r = data[offset] + dif;
1729                                                         var g = data[offset+1] + dif;
1730                                                         var b = data[offset+2] + dif;
1731
1732                                                         data[offset] = (r > 255) ? 255 : (r < 0 ? 0 : r);
1733                                                         data[offset+1] = (g > 255) ? 255 : (g < 0 ? 0 : g);
1734                                                         data[offset+2] = (b > 255) ? 255 : (b < 0 ? 0 : b);
1735                                                 } else {
1736                                                         var grey = greyLevel - dif;
1737                                                         if (grey < 0) {
1738                                                                 grey = 0;
1739                                                         } else if (grey > 255) {
1740                                                                 grey = 255;
1741                                                         }
1742
1743                                                         data[offset] = data[offset+1] = data[offset+2] = grey;
1744                                                 }
1745
1746                                 } while (--x);
1747                         } while (--y);
1748                         return true;
1749
1750                 } else if (Pixastic.Client.isIE()) {
1751                         params.image.style.filter += " progid:DXImageTransform.Microsoft.emboss()";
1752                         return true;
1753                 }
1754         },
1755         checkSupport : function() {
1756                 return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
1757         }
1758
1759 }
1760 /*
1761  * Pixastic Lib - Flip - v0.1.0
1762  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1763  * License: [http://www.pixastic.com/lib/license.txt]
1764  */
1765
1766 Pixastic.Actions.flip = {
1767         process : function(params) {
1768                 var rect = params.options.rect;
1769                 var copyCanvas = document.createElement("canvas");
1770                 copyCanvas.width = rect.width;
1771                 copyCanvas.height = rect.height;
1772                 copyCanvas.getContext("2d").drawImage(params.image, rect.left, rect.top, rect.width, rect.height, 0, 0, rect.width, rect.height);
1773
1774                 var ctx = params.canvas.getContext("2d");
1775                 ctx.clearRect(rect.left, rect.top, rect.width, rect.height);
1776
1777                 if (params.options.axis == "horizontal") {
1778                         ctx.scale(-1,1);
1779                         ctx.drawImage(copyCanvas, -rect.left-rect.width, rect.top, rect.width, rect.height)
1780                 } else {
1781                         ctx.scale(1,-1);
1782                         ctx.drawImage(copyCanvas, rect.left, -rect.top-rect.height, rect.width, rect.height)
1783                 }
1784
1785                 params.useData = false;
1786
1787                 return true;
1788         },
1789         checkSupport : function() {
1790                 return Pixastic.Client.hasCanvas();
1791         }
1792 }
1793
1794 /*
1795  * Pixastic Lib - Horizontal flip - v0.1.0
1796  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1797  * License: [http://www.pixastic.com/lib/license.txt]
1798  */
1799
1800 Pixastic.Actions.fliph = {
1801         process : function(params) {
1802                 if (Pixastic.Client.hasCanvas()) {
1803                         var rect = params.options.rect;
1804                         var copyCanvas = document.createElement("canvas");
1805                         copyCanvas.width = rect.width;
1806                         copyCanvas.height = rect.height;
1807                         copyCanvas.getContext("2d").drawImage(params.image, rect.left, rect.top, rect.width, rect.height, 0, 0, rect.width, rect.height);
1808
1809                         var ctx = params.canvas.getContext("2d");
1810                         ctx.clearRect(rect.left, rect.top, rect.width, rect.height);
1811                         ctx.scale(-1,1);
1812                         ctx.drawImage(copyCanvas, -rect.left-rect.width, rect.top, rect.width, rect.height)
1813                         params.useData = false;
1814
1815                         return true;
1816
1817                 } else if (Pixastic.Client.isIE()) {
1818                         params.image.style.filter += " fliph";
1819                         return true;
1820                 }
1821         },
1822         checkSupport : function() {
1823                 return (Pixastic.Client.hasCanvas() || Pixastic.Client.isIE());
1824         }
1825 }
1826
1827 /*
1828  * Pixastic Lib - Vertical flip - v0.1.0
1829  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1830  * License: [http://www.pixastic.com/lib/license.txt]
1831  */
1832
1833 Pixastic.Actions.flipv = {
1834         process : function(params) {
1835                 if (Pixastic.Client.hasCanvas()) {
1836                         var rect = params.options.rect;
1837                         var copyCanvas = document.createElement("canvas");
1838                         copyCanvas.width = rect.width;
1839                         copyCanvas.height = rect.height;
1840                         copyCanvas.getContext("2d").drawImage(params.image, rect.left, rect.top, rect.width, rect.height, 0, 0, rect.width, rect.height);
1841
1842                         var ctx = params.canvas.getContext("2d");
1843                         ctx.clearRect(rect.left, rect.top, rect.width, rect.height);
1844                         ctx.scale(1,-1);
1845                         ctx.drawImage(copyCanvas, rect.left, -rect.top-rect.height, rect.width, rect.height)
1846                         params.useData = false;
1847
1848                         return true;
1849
1850                 } else if (Pixastic.Client.isIE()) {
1851                         params.image.style.filter += " flipv";
1852                         return true;
1853                 }
1854         },
1855         checkSupport : function() {
1856                 return (Pixastic.Client.hasCanvas() || Pixastic.Client.isIE());
1857         }
1858 }
1859
1860 /*
1861  * Pixastic Lib - Glow - v0.1.0
1862  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1863  * License: [http://www.pixastic.com/lib/license.txt]
1864  */
1865
1866
1867 Pixastic.Actions.glow = {
1868         process : function(params) {
1869
1870                 var amount = (parseFloat(params.options.amount)||0);
1871                 var blurAmount = parseFloat(params.options.radius)||0;
1872
1873                 amount = Math.min(1,Math.max(0,amount));
1874                 blurAmount = Math.min(5,Math.max(0,blurAmount));
1875
1876                 if (Pixastic.Client.hasCanvasImageData()) {
1877                         var rect = params.options.rect;
1878
1879                         var blurCanvas = document.createElement("canvas");
1880                         blurCanvas.width = params.width;
1881                         blurCanvas.height = params.height;
1882                         var blurCtx = blurCanvas.getContext("2d");
1883                         blurCtx.drawImage(params.canvas,0,0);
1884
1885                         var scale = 2;
1886                         var smallWidth = Math.round(params.width / scale);
1887                         var smallHeight = Math.round(params.height / scale);
1888
1889                         var copy = document.createElement("canvas");
1890                         copy.width = smallWidth;
1891                         copy.height = smallHeight;
1892
1893                         var clear = true;
1894                         var steps = Math.round(blurAmount * 20);
1895
1896                         var copyCtx = copy.getContext("2d");
1897                         for (var i=0;i<steps;i++) {
1898                                 var scaledWidth = Math.max(1,Math.round(smallWidth - i));
1899                                 var scaledHeight = Math.max(1,Math.round(smallHeight - i));
1900
1901                                 copyCtx.clearRect(0,0,smallWidth,smallHeight);
1902
1903                                 copyCtx.drawImage(
1904                                         blurCanvas,
1905                                         0,0,params.width,params.height,
1906                                         0,0,scaledWidth,scaledHeight
1907                                 );
1908
1909                                 blurCtx.clearRect(0,0,params.width,params.height);
1910
1911                                 blurCtx.drawImage(
1912                                         copy,
1913                                         0,0,scaledWidth,scaledHeight,
1914                                         0,0,params.width,params.height
1915                                 );
1916                         }
1917
1918                         var data = Pixastic.prepareData(params);
1919                         var blurData = Pixastic.prepareData({canvas:blurCanvas,options:params.options});
1920                         var w = rect.width;
1921                         var h = rect.height;
1922                         var w4 = w*4;
1923                         var y = h;
1924                         do {
1925                                 var offsetY = (y-1)*w4;
1926                                 var x = w;
1927                                 do {
1928                                         var offset = offsetY + (x*4-4);
1929
1930                                         var r = data[offset] + amount * blurData[offset];
1931                                         var g = data[offset+1] + amount * blurData[offset+1];
1932                                         var b = data[offset+2] + amount * blurData[offset+2];
1933
1934                                         if (r > 255) r = 255;
1935                                         if (g > 255) g = 255;
1936                                         if (b > 255) b = 255;
1937                                         if (r < 0) r = 0;
1938                                         if (g < 0) g = 0;
1939                                         if (b < 0) b = 0;
1940
1941                                         data[offset] = r;
1942                                         data[offset+1] = g;
1943                                         data[offset+2] = b;
1944
1945                                 } while (--x);
1946                         } while (--y);
1947
1948                         return true;
1949                 }
1950         },
1951         checkSupport : function() {
1952                 return Pixastic.Client.hasCanvasImageData();
1953         }
1954 }
1955
1956
1957
1958 /*
1959  * Pixastic Lib - Histogram - v0.1.0
1960  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
1961  * License: [http://www.pixastic.com/lib/license.txt]
1962  */
1963
1964 Pixastic.Actions.histogram = {
1965         process : function(params) {
1966
1967                 var average = !!(params.options.average && params.options.average != "false");
1968                 var paint = !!(params.options.paint && params.options.paint != "false");
1969                 var color = params.options.color || "rgba(255,255,255,0.5)";
1970                 var values = [];
1971                 if (typeof params.options.returnValue != "object") {
1972                         params.options.returnValue = {values:[]};
1973                 }
1974                 var returnValue = params.options.returnValue;
1975                 if (typeof returnValue.values != "array") {
1976                         returnValue.values = [];
1977                 }
1978                 values = returnValue.values;
1979
1980                 if (Pixastic.Client.hasCanvasImageData()) {
1981                         var data = Pixastic.prepareData(params);
1982                         params.useData = false;
1983
1984                         for (var i=0;i<256;i++) {
1985                                 values[i] = 0;
1986                         }
1987
1988                         var rect = params.options.rect;
1989                         var w = rect.width;
1990                         var h = rect.height;
1991                         var w4 = w*4;
1992                         var y = h;
1993                         do {
1994                                 var offsetY = (y-1)*w4;
1995                                 var x = w;
1996                                 do {
1997                                         var offset = offsetY + (x*4-4);
1998                                         var brightness = average ?
1999                                                 Math.round((data[offset]+data[offset+1]+data[offset+2])/3)
2000                                                 : Math.round(data[offset]*0.3 + data[offset+1]*0.59 + data[offset+2]*0.11);
2001                                         values[brightness]++;
2002
2003                                 } while (--x);
2004                         } while (--y);
2005
2006                         if (paint) {
2007                                 var maxValue = 0;
2008                                 for (var i=0;i<256;i++) {
2009                                         if (values[i] > maxValue) {
2010                                                 maxValue = values[i];
2011                                         }
2012                                 }
2013                                 var heightScale = params.height / maxValue;
2014                                 var widthScale = params.width / 256;
2015                                 var ctx = params.canvas.getContext("2d");
2016                                 ctx.fillStyle = color;
2017                                 for (var i=0;i<256;i++) {
2018                                         ctx.fillRect(
2019                                                 i * widthScale, params.height - heightScale * values[i],
2020                                                 widthScale, values[i] * heightScale
2021                                         );
2022                                 }
2023                         }
2024
2025                         returnValue.values = values;
2026
2027                         return true;
2028                 }
2029         },
2030         checkSupport : function() {
2031                 return Pixastic.Client.hasCanvasImageData();
2032         }
2033 }
2034 /*
2035  * Pixastic Lib - HSL Adjust  - v0.1.0
2036  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2037  * License: [http://www.pixastic.com/lib/license.txt]
2038  */
2039
2040 Pixastic.Actions.hsl = {
2041         process : function(params) {
2042
2043                 var hue = parseInt(params.options.hue,10)||0;
2044                 var saturation = (parseInt(params.options.saturation,10)||0) / 100;
2045                 var lightness = (parseInt(params.options.lightness,10)||0) / 100;
2046
2047
2048                 // this seems to give the same result as Photoshop
2049                 if (saturation < 0) {
2050                         var satMul = 1+saturation;
2051                 } else {
2052                         var satMul = 1+saturation*2;
2053                 }
2054
2055                 hue = (hue%360) / 360;
2056                 var hue6 = hue * 6;
2057
2058                 var rgbDiv = 1 / 255;
2059
2060                 var light255 = lightness * 255;
2061                 var lightp1 = 1 + lightness;
2062                 var lightm1 = 1 - lightness;
2063                 if (Pixastic.Client.hasCanvasImageData()) {
2064                         var data = Pixastic.prepareData(params);
2065
2066                         var rect = params.options.rect;
2067                         var w = rect.width;
2068                         var h = rect.height;
2069
2070                         var w4 = w*4;
2071                         var y = h;
2072
2073                         do {
2074                                 var offsetY = (y-1)*w4;
2075                                 var x = w;
2076                                 do {
2077                                         var offset = offsetY + (x*4-4);
2078
2079                                         var r = data[offset];
2080                                         var g = data[offset+1];
2081                                         var b = data[offset+2];
2082
2083                                         if (hue != 0 || saturation != 0) {
2084                                                 // ok, here comes rgb to hsl + adjust + hsl to rgb, all in one jumbled mess.
2085                                                 // It's not so pretty, but it's been optimized to get somewhat decent performance.
2086                                                 // The transforms were originally adapted from the ones found in Graphics Gems, but have been heavily modified.
2087                                                 var vs = r;
2088                                                 if (g > vs) vs = g;
2089                                                 if (b > vs) vs = b;
2090                                                 var ms = r;
2091                                                 if (g < ms) ms = g;
2092                                                 if (b < ms) ms = b;
2093                                                 var vm = (vs-ms);
2094                                                 var l = (ms+vs)/255 * 0.5;
2095                                                 if (l > 0) {
2096                                                         if (vm > 0) {
2097                                                                 if (l <= 0.5) {
2098                                                                         var s = vm / (vs+ms) * satMul;
2099                                                                         if (s > 1) s = 1;
2100                                                                         var v = (l * (1+s));
2101                                                                 } else {
2102                                                                         var s = vm / (510-vs-ms) * satMul;
2103                                                                         if (s > 1) s = 1;
2104                                                                         var v = (l+s - l*s);
2105                                                                 }
2106                                                                 if (r == vs) {
2107                                                                         if (g == ms)
2108                                                                                 var h = 5 + ((vs-b)/vm) + hue6;
2109                                                                         else
2110                                                                                 var h = 1 - ((vs-g)/vm) + hue6;
2111                                                                 } else if (g == vs) {
2112                                                                         if (b == ms)
2113                                                                                 var h = 1 + ((vs-r)/vm) + hue6;
2114                                                                         else
2115                                                                                 var h = 3 - ((vs-b)/vm) + hue6;
2116                                                                 } else {
2117                                                                         if (r == ms)
2118                                                                                 var h = 3 + ((vs-g)/vm) + hue6;
2119                                                                         else
2120                                                                                 var h = 5 - ((vs-r)/vm) + hue6;
2121                                                                 }
2122                                                                 if (h < 0) h+=6;
2123                                                                 if (h >= 6) h-=6;
2124                                                                 var m = (l+l-v);
2125                                                                 var sextant = h>>0;
2126                                                                 switch (sextant) {
2127                                                                         case 0: r = v*255; g = (m+((v-m)*(h-sextant)))*255; b = m*255; break;
2128                                                                         case 1: r = (v-((v-m)*(h-sextant)))*255; g = v*255; b = m*255; break;
2129                                                                         case 2: r = m*255; g = v*255; b = (m+((v-m)*(h-sextant)))*255; break;
2130                                                                         case 3: r = m*255; g = (v-((v-m)*(h-sextant)))*255; b = v*255; break;
2131                                                                         case 4: r = (m+((v-m)*(h-sextant)))*255; g = m*255; b = v*255; break;
2132                                                                         case 5: r = v*255; g = m*255; b = (v-((v-m)*(h-sextant)))*255; break;
2133                                                                 }
2134                                                         }
2135                                                 }
2136                                         }
2137
2138                                         if (lightness < 0) {
2139                                                 r *= lightp1;
2140                                                 g *= lightp1;
2141                                                 b *= lightp1;
2142                                         } else if (lightness > 0) {
2143                                                 r = r * lightm1 + light255;
2144                                                 g = g * lightm1 + light255;
2145                                                 b = b * lightm1 + light255;
2146                                         }
2147
2148                                         if (r < 0) r = 0;
2149                                         if (g < 0) g = 0;
2150                                         if (b < 0) b = 0;
2151                                         if (r > 255) r = 255;
2152                                         if (g > 255) g = 255;
2153                                         if (b > 255) b = 255;
2154
2155                                         data[offset] = r;
2156                                         data[offset+1] = g;
2157                                         data[offset+2] = b;
2158
2159                                 } while (--x);
2160                         } while (--y);
2161                         return true;
2162                 }
2163         },
2164         checkSupport : function() {
2165                 return Pixastic.Client.hasCanvasImageData();
2166         }
2167
2168 }
2169 /*
2170  * Pixastic Lib - Invert filter - v0.1.0
2171  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2172  * License: [http://www.pixastic.com/lib/license.txt]
2173  */
2174
2175 Pixastic.Actions.invert = {
2176         process : function(params) {
2177                 if (Pixastic.Client.hasCanvasImageData()) {
2178                         var data = Pixastic.prepareData(params);
2179
2180                         var invertAlpha = !!params.options.invertAlpha;
2181                         var rect = params.options.rect;
2182                         var w = rect.width;
2183                         var h = rect.height;
2184
2185                         var w4 = w*4;
2186                         var y = h;
2187                         do {
2188                                 var offsetY = (y-1)*w4;
2189                                 var x = w;
2190                                 do {
2191                                         var offset = offsetY + (x-1)*4;
2192                                         data[offset] = 255 - data[offset];
2193                                         data[offset+1] = 255 - data[offset+1];
2194                                         data[offset+2] = 255 - data[offset+2];
2195                                         if (invertAlpha) data[offset+3] = 255 - data[offset+3];
2196                                 } while (--x);
2197                         } while (--y);
2198
2199                         return true;
2200                 } else if (Pixastic.Client.isIE()) {
2201                         params.image.style.filter += " invert";
2202                         return true;
2203                 }
2204         },
2205         checkSupport : function() {
2206                 return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
2207         }
2208 }
2209 /*
2210  * Pixastic Lib - Laplace filter - v0.1.0
2211  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2212  * License: [http://www.pixastic.com/lib/license.txt]
2213  */
2214
2215 Pixastic.Actions.laplace = {
2216         process : function(params) {
2217
2218                 var strength = 1.0;
2219                 var invert = !!(params.options.invert && params.options.invert != "false");
2220                 var contrast = parseFloat(params.options.edgeStrength)||0;
2221
2222                 var greyLevel = parseInt(params.options.greyLevel)||0;
2223
2224                 contrast = -contrast;
2225
2226                 if (Pixastic.Client.hasCanvasImageData()) {
2227                         var data = Pixastic.prepareData(params);
2228                         var dataCopy = Pixastic.prepareData(params, true)
2229
2230                         var kernel = [
2231                                 [-1,    -1,     -1],
2232                                 [-1,    8,      -1],
2233                                 [-1,    -1,     -1]
2234                         ];
2235
2236                         var weight = 1/8;
2237
2238                         var rect = params.options.rect;
2239                         var w = rect.width;
2240                         var h = rect.height;
2241
2242                         var w4 = w*4;
2243                         var y = h;
2244                         do {
2245                                 var offsetY = (y-1)*w4;
2246
2247                                 var nextY = (y == h) ? y - 1 : y;
2248                                 var prevY = (y == 1) ? 0 : y-2;
2249
2250                                 var offsetYPrev = prevY*w*4;
2251                                 var offsetYNext = nextY*w*4;
2252
2253                                 var x = w;
2254                                 do {
2255                                         var offset = offsetY + (x*4-4);
2256
2257                                         var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
2258                                         var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
2259
2260                                         var r = ((-dataCopy[offsetPrev-4]
2261                                                 - dataCopy[offsetPrev]
2262                                                 - dataCopy[offsetPrev+4]
2263                                                 - dataCopy[offset-4]
2264                                                 - dataCopy[offset+4]
2265                                                 - dataCopy[offsetNext-4]
2266                                                 - dataCopy[offsetNext]
2267                                                 - dataCopy[offsetNext+4])
2268                                                 + dataCopy[offset] * 8)
2269                                                 * weight;
2270
2271                                         var g = ((-dataCopy[offsetPrev-3]
2272                                                 - dataCopy[offsetPrev+1]
2273                                                 - dataCopy[offsetPrev+5]
2274                                                 - dataCopy[offset-3]
2275                                                 - dataCopy[offset+5]
2276                                                 - dataCopy[offsetNext-3]
2277                                                 - dataCopy[offsetNext+1]
2278                                                 - dataCopy[offsetNext+5])
2279                                                 + dataCopy[offset+1] * 8)
2280                                                 * weight;
2281
2282                                         var b = ((-dataCopy[offsetPrev-2]
2283                                                 - dataCopy[offsetPrev+2]
2284                                                 - dataCopy[offsetPrev+6]
2285                                                 - dataCopy[offset-2]
2286                                                 - dataCopy[offset+6]
2287                                                 - dataCopy[offsetNext-2]
2288                                                 - dataCopy[offsetNext+2]
2289                                                 - dataCopy[offsetNext+6])
2290                                                 + dataCopy[offset+2] * 8)
2291                                                 * weight;
2292
2293                                         var brightness = ((r + g + b)/3) + greyLevel;
2294
2295                                         if (contrast != 0) {
2296                                                 if (brightness > 127) {
2297                                                         brightness += ((brightness + 1) - 128) * contrast;
2298                                                 } else if (brightness < 127) {
2299                                                         brightness -= (brightness + 1) * contrast;
2300                                                 }
2301                                         }
2302                                         if (invert) {
2303                                                 brightness = 255 - brightness;
2304                                         }
2305                                         if (brightness < 0 ) brightness = 0;
2306                                         if (brightness > 255 ) brightness = 255;
2307
2308                                         data[offset] = data[offset+1] = data[offset+2] = brightness;
2309
2310                                 } while (--x);
2311                         } while (--y);
2312
2313                         return true;
2314                 }
2315         },
2316         checkSupport : function() {
2317                 return Pixastic.Client.hasCanvasImageData();
2318         }
2319 }
2320
2321 /*
2322  * Pixastic Lib - Lighten filter - v0.1.0
2323  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2324  * License: [http://www.pixastic.com/lib/license.txt]
2325  */
2326
2327 Pixastic.Actions.lighten = {
2328
2329         process : function(params) {
2330                 var amount = parseFloat(params.options.amount) || 0;
2331
2332                 if (Pixastic.Client.hasCanvasImageData()) {
2333                         var data = Pixastic.prepareData(params);
2334                         var rect = params.options.rect;
2335                         var w = rect.width;
2336                         var h = rect.height;
2337                         var w4 = w*4;
2338                         var y = h;
2339                         do {
2340                                 var offsetY = (y-1)*w4;
2341                                 var x = w;
2342                                 do {
2343                                         var offset = offsetY + (x-1)*4;
2344
2345                                         var r = data[offset];
2346                                         var g = data[offset+1];
2347                                         var b = data[offset+2];
2348
2349                                         r += r*amount;
2350                                         g += g*amount;
2351                                         b += b*amount;
2352
2353                                         if (r < 0 ) r = 0;
2354                                         if (g < 0 ) g = 0;
2355                                         if (b < 0 ) b = 0;
2356                                         if (r > 255 ) r = 255;
2357                                         if (g > 255 ) g = 255;
2358                                         if (b > 255 ) b = 255;
2359
2360                                         data[offset] = r;
2361                                         data[offset+1] = g;
2362                                         data[offset+2] = b;
2363
2364                                 } while (--x);
2365                         } while (--y);
2366                         return true;
2367
2368                 } else if (Pixastic.Client.isIE()) {
2369                         var img = params.image;
2370                         if (amount < 0) {
2371                                 img.style.filter += " light()";
2372                                 img.filters[img.filters.length-1].addAmbient(
2373                                         255,255,255,
2374                                         100 * -amount
2375                                 );
2376                         } else if (amount > 0) {
2377                                 img.style.filter += " light()";
2378                                 img.filters[img.filters.length-1].addAmbient(
2379                                         255,255,255,
2380                                         100
2381                                 );
2382                                 img.filters[img.filters.length-1].addAmbient(
2383                                         255,255,255,
2384                                         100 * amount
2385                                 );
2386                         }
2387                         return true;
2388                 }
2389         },
2390         checkSupport : function() {
2391                 return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
2392         }
2393 }
2394 /*
2395  * Pixastic Lib - Mosaic filter - v0.1.0
2396  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2397  * License: [http://www.pixastic.com/lib/license.txt]
2398  */
2399
2400 Pixastic.Actions.mosaic = {
2401
2402         process : function(params) {
2403                 var blockSize = Math.max(1,parseInt(params.options.blockSize,10));
2404
2405                 if (Pixastic.Client.hasCanvasImageData()) {
2406                         var rect = params.options.rect;
2407                         var w = rect.width;
2408                         var h = rect.height;
2409                         var w4 = w*4;
2410                         var y = h;
2411
2412                         var ctx = params.canvas.getContext("2d");
2413
2414                         var pixel = document.createElement("canvas");
2415                         pixel.width = pixel.height = 1;
2416                         var pixelCtx = pixel.getContext("2d");
2417
2418                         var copy = document.createElement("canvas");
2419                         copy.width = w;
2420                         copy.height = h;
2421                         var copyCtx = copy.getContext("2d");
2422                         copyCtx.drawImage(params.canvas,rect.left,rect.top,w,h, 0,0,w,h);
2423
2424                         for (var y=0;y<h;y+=blockSize) {
2425                                 for (var x=0;x<w;x+=blockSize) {
2426                                         var blockSizeX = blockSize;
2427                                         var blockSizeY = blockSize;
2428
2429                                         if (blockSizeX + x > w)
2430                                                 blockSizeX = w - x;
2431                                         if (blockSizeY + y > h)
2432                                                 blockSizeY = h - y;
2433
2434                                         pixelCtx.drawImage(copy, x, y, blockSizeX, blockSizeY, 0, 0, 1, 1);
2435                                         var data = pixelCtx.getImageData(0,0,1,1).data;
2436                                         ctx.fillStyle = "rgb(" + data[0] + "," + data[1] + "," + data[2] + ")";
2437                                         ctx.fillRect(rect.left + x, rect.top + y, blockSize, blockSize);
2438                                 }
2439                         }
2440                         params.useData = false;
2441
2442                         return true;
2443                 }
2444         },
2445         checkSupport : function() {
2446                 return (Pixastic.Client.hasCanvasImageData());
2447         }
2448 }/*
2449  * Pixastic Lib - Noise filter - v0.1.0
2450  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2451  * License: [http://www.pixastic.com/lib/license.txt]
2452  */
2453
2454 Pixastic.Actions.noise = {
2455
2456         process : function(params) {
2457                 var amount = 0;
2458                 var strength = 0;
2459                 var mono = false;
2460
2461                 if (typeof params.options.amount != "undefined")
2462                         amount = parseFloat(params.options.amount)||0;
2463                 if (typeof params.options.strength != "undefined")
2464                         strength = parseFloat(params.options.strength)||0;
2465                 if (typeof params.options.mono != "undefined")
2466                         mono = !!(params.options.mono && params.options.mono != "false");
2467
2468                 amount = Math.max(0,Math.min(1,amount));
2469                 strength = Math.max(0,Math.min(1,strength));
2470
2471                 var noise = 128 * strength;
2472                 var noise2 = noise / 2;
2473
2474                 if (Pixastic.Client.hasCanvasImageData()) {
2475                         var data = Pixastic.prepareData(params);
2476                         var rect = params.options.rect;
2477                         var w = rect.width;
2478                         var h = rect.height;
2479                         var w4 = w*4;
2480                         var y = h;
2481                         var random = Math.random;
2482
2483                         do {
2484                                 var offsetY = (y-1)*w4;
2485                                 var x = w;
2486                                 do {
2487                                         var offset = offsetY + (x-1)*4;
2488                                         if (random() < amount) {
2489                                                 if (mono) {
2490                                                         var pixelNoise = - noise2 + random() * noise;
2491                                                         var r = data[offset] + pixelNoise;
2492                                                         var g = data[offset+1] + pixelNoise;
2493                                                         var b = data[offset+2] + pixelNoise;
2494                                                 } else {
2495                                                         var r = data[offset] - noise2 + (random() * noise);
2496                                                         var g = data[offset+1] - noise2 + (random() * noise);
2497                                                         var b = data[offset+2] - noise2 + (random() * noise);
2498                                                 }
2499
2500                                                 if (r < 0 ) r = 0;
2501                                                 if (g < 0 ) g = 0;
2502                                                 if (b < 0 ) b = 0;
2503                                                 if (r > 255 ) r = 255;
2504                                                 if (g > 255 ) g = 255;
2505                                                 if (b > 255 ) b = 255;
2506
2507                                                 data[offset] = r;
2508                                                 data[offset+1] = g;
2509                                                 data[offset+2] = b;
2510                                         }
2511                                 } while (--x);
2512                         } while (--y);
2513                         return true;
2514                 }
2515         },
2516         checkSupport : function() {
2517                 return Pixastic.Client.hasCanvasImageData();
2518         }
2519 }
2520
2521 /*
2522  * Pixastic Lib - Posterize effect - v0.1.0
2523  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2524  * License: [http://www.pixastic.com/lib/license.txt]
2525  */
2526
2527 Pixastic.Actions.posterize = {
2528
2529         process : function(params) {
2530
2531
2532                 var numLevels = 256;
2533                 if (typeof params.options.levels != "undefined")
2534                         numLevels = parseInt(params.options.levels,10)||1;
2535
2536                 if (Pixastic.Client.hasCanvasImageData()) {
2537                         var data = Pixastic.prepareData(params);
2538
2539                         numLevels = Math.max(2,Math.min(256,numLevels));
2540
2541                         var numAreas = 256 / numLevels;
2542                         var numValues = 256 / (numLevels-1);
2543
2544                         var rect = params.options.rect;
2545                         var w = rect.width;
2546                         var h = rect.height;
2547                         var w4 = w*4;
2548                         var y = h;
2549                         do {
2550                                 var offsetY = (y-1)*w4;
2551                                 var x = w;
2552                                 do {
2553                                         var offset = offsetY + (x-1)*4;
2554
2555                                         var r = numValues * ((data[offset] / numAreas)>>0);
2556                                         var g = numValues * ((data[offset+1] / numAreas)>>0);
2557                                         var b = numValues * ((data[offset+2] / numAreas)>>0);
2558
2559                                         if (r > 255) r = 255;
2560                                         if (g > 255) g = 255;
2561                                         if (b > 255) b = 255;
2562
2563                                         data[offset] = r;
2564                                         data[offset+1] = g;
2565                                         data[offset+2] = b;
2566
2567                                 } while (--x);
2568                         } while (--y);
2569                         return true;
2570                 }
2571         },
2572         checkSupport : function() {
2573                 return Pixastic.Client.hasCanvasImageData();
2574         }
2575 }
2576
2577
2578 /*
2579  * Pixastic Lib - Pointillize filter - v0.1.0
2580  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2581  * License: [http://www.pixastic.com/lib/license.txt]
2582  */
2583
2584 Pixastic.Actions.pointillize = {
2585
2586         process : function(params) {
2587                 var radius = Math.max(1,parseInt(params.options.radius,10));
2588                 var density = Math.min(5,Math.max(0,parseFloat(params.options.density)||0));
2589                 var noise = Math.max(0,parseFloat(params.options.noise)||0);
2590                 var transparent = !!(params.options.transparent && params.options.transparent != "false");
2591
2592                 if (Pixastic.Client.hasCanvasImageData()) {
2593                         var rect = params.options.rect;
2594                         var w = rect.width;
2595                         var h = rect.height;
2596                         var w4 = w*4;
2597                         var y = h;
2598
2599                         var ctx = params.canvas.getContext("2d");
2600                         var canvasWidth = params.canvas.width;
2601                         var canvasHeight = params.canvas.height;
2602
2603                         var pixel = document.createElement("canvas");
2604                         pixel.width = pixel.height = 1;
2605                         var pixelCtx = pixel.getContext("2d");
2606
2607                         var copy = document.createElement("canvas");
2608                         copy.width = w;
2609                         copy.height = h;
2610                         var copyCtx = copy.getContext("2d");
2611                         copyCtx.drawImage(params.canvas,rect.left,rect.top,w,h, 0,0,w,h);
2612
2613                         var diameter = radius * 2;
2614
2615                         if (transparent)
2616                                 ctx.clearRect(rect.left, rect.top, rect.width, rect.height);
2617
2618                         var noiseRadius = radius * noise;
2619
2620                         var dist = 1 / density;
2621
2622                         for (var y=0;y<h+radius;y+=diameter*dist) {
2623                                 for (var x=0;x<w+radius;x+=diameter*dist) {
2624                                         rndX = noise ? (x+((Math.random()*2-1) * noiseRadius))>>0 : x;
2625                                         rndY = noise ? (y+((Math.random()*2-1) * noiseRadius))>>0 : y;
2626
2627                                         var pixX = rndX - radius;
2628                                         var pixY = rndY - radius;
2629                                         if (pixX < 0) pixX = 0;
2630                                         if (pixY < 0) pixY = 0;
2631
2632                                         var cx = rndX + rect.left;
2633                                         var cy = rndY + rect.top;
2634                                         if (cx < 0) cx = 0;
2635                                         if (cx > canvasWidth) cx = canvasWidth;
2636                                         if (cy < 0) cy = 0;
2637                                         if (cy > canvasHeight) cy = canvasHeight;
2638
2639                                         var diameterX = diameter;
2640                                         var diameterY = diameter;
2641
2642                                         if (diameterX + pixX > w)
2643                                                 diameterX = w - pixX;
2644                                         if (diameterY + pixY > h)
2645                                                 diameterY = h - pixY;
2646                                         if (diameterX < 1) diameterX = 1;
2647                                         if (diameterY < 1) diameterY = 1;
2648
2649                                         pixelCtx.drawImage(copy, pixX, pixY, diameterX, diameterY, 0, 0, 1, 1);
2650                                         var data = pixelCtx.getImageData(0,0,1,1).data;
2651
2652                                         ctx.fillStyle = "rgb(" + data[0] + "," + data[1] + "," + data[2] + ")";
2653                                         ctx.beginPath();
2654                                         ctx.arc(cx, cy, radius, 0, Math.PI*2, true);
2655                                         ctx.closePath();
2656                                         ctx.fill();
2657                                 }
2658                         }
2659
2660                         params.useData = false;
2661
2662                         return true;
2663                 }
2664         },
2665         checkSupport : function() {
2666                 return (Pixastic.Client.hasCanvasImageData());
2667         }
2668 }/*
2669  * Pixastic Lib - Resize - v0.1.0
2670  * Copyright (c) 2009 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2671  * License: [http://www.pixastic.com/lib/license.txt]
2672  */
2673
2674 Pixastic.Actions.resize = {
2675         process : function(params) {
2676                 if (Pixastic.Client.hasCanvas()) {
2677                         var width = parseInt(params.options.width,10);
2678                         var height = parseInt(params.options.height,10);
2679                         var canvas = params.canvas;
2680
2681                         if (width < 1) width = 1;
2682                         if (width < 2) width = 2;
2683
2684                         var copy = document.createElement("canvas");
2685                         copy.width = width;
2686                         copy.height = height;
2687
2688                         copy.getContext("2d").drawImage(canvas,0,0,width,height);
2689                         canvas.width = width;
2690                         canvas.height = height;
2691
2692                         canvas.getContext("2d").drawImage(copy,0,0);
2693
2694                         params.useData = false;
2695                         return true;
2696                 }
2697         },
2698         checkSupport : function() {
2699                 return Pixastic.Client.hasCanvas();
2700         }
2701 }
2702
2703
2704 /*
2705  * Pixastic Lib - Remove noise - v0.1.0
2706  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2707  * License: [http://www.pixastic.com/lib/license.txt]
2708  */
2709
2710 Pixastic.Actions.removenoise = {
2711         process : function(params) {
2712
2713                 if (Pixastic.Client.hasCanvasImageData()) {
2714                         var data = Pixastic.prepareData(params);
2715
2716                         var rect = params.options.rect;
2717                         var w = rect.width;
2718                         var h = rect.height;
2719
2720                         var w4 = w*4;
2721                         var y = h;
2722                         do {
2723                                 var offsetY = (y-1)*w4;
2724
2725                                 var nextY = (y == h) ? y - 1 : y;
2726                                 var prevY = (y == 1) ? 0 : y-2;
2727
2728                                 var offsetYPrev = prevY*w*4;
2729                                 var offsetYNext = nextY*w*4;
2730
2731                                 var x = w;
2732                                 do {
2733                                         var offset = offsetY + (x*4-4);
2734
2735                                         var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
2736                                         var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
2737
2738                                         var minR, maxR, minG, maxG, minB, maxB;
2739
2740                                         minR = maxR = data[offsetPrev];
2741                                         var r1 = data[offset-4], r2 = data[offset+4], r3 = data[offsetNext];
2742                                         if (r1 < minR) minR = r1;
2743                                         if (r2 < minR) minR = r2;
2744                                         if (r3 < minR) minR = r3;
2745                                         if (r1 > maxR) maxR = r1;
2746                                         if (r2 > maxR) maxR = r2;
2747                                         if (r3 > maxR) maxR = r3;
2748
2749                                         minG = maxG = data[offsetPrev+1];
2750                                         var g1 = data[offset-3], g2 = data[offset+5], g3 = data[offsetNext+1];
2751                                         if (g1 < minG) minG = g1;
2752                                         if (g2 < minG) minG = g2;
2753                                         if (g3 < minG) minG = g3;
2754                                         if (g1 > maxG) maxG = g1;
2755                                         if (g2 > maxG) maxG = g2;
2756                                         if (g3 > maxG) maxG = g3;
2757
2758                                         minB = maxB = data[offsetPrev+2];
2759                                         var b1 = data[offset-2], b2 = data[offset+6], b3 = data[offsetNext+2];
2760                                         if (b1 < minB) minB = b1;
2761                                         if (b2 < minB) minB = b2;
2762                                         if (b3 < minB) minB = b3;
2763                                         if (b1 > maxB) maxB = b1;
2764                                         if (b2 > maxB) maxB = b2;
2765                                         if (b3 > maxB) maxB = b3;
2766
2767                                         if (data[offset] > maxR) {
2768                                                 data[offset] = maxR;
2769                                         } else if (data[offset] < minR) {
2770                                                 data[offset] = minR;
2771                                         }
2772                                         if (data[offset+1] > maxG) {
2773                                                 data[offset+1] = maxG;
2774                                         } else if (data[offset+1] < minG) {
2775                                                 data[offset+1] = minG;
2776                                         }
2777                                         if (data[offset+2] > maxB) {
2778                                                 data[offset+2] = maxB;
2779                                         } else if (data[offset+2] < minB) {
2780                                                 data[offset+2] = minB;
2781                                         }
2782
2783                                 } while (--x);
2784                         } while (--y);
2785
2786                         return true;
2787                 }
2788         },
2789         checkSupport : function() {
2790                 return Pixastic.Client.hasCanvasImageData();
2791         }
2792 }/*
2793  * Pixastic Lib - Rotate - v0.1.0
2794  * Copyright (c) 2009 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2795  * License: [http://www.pixastic.com/lib/license.txt]
2796  */
2797
2798 Pixastic.Actions.rotate = {
2799         process : function(params) {
2800                 if (Pixastic.Client.hasCanvas()) {
2801                         var canvas = params.canvas;
2802
2803                         var width = params.width;
2804                         var height = params.height;
2805
2806                         var copy = document.createElement("canvas");
2807                         copy.width = width;
2808                         copy.height = height;
2809                         copy.getContext("2d").drawImage(canvas,0,0,width,height);
2810
2811                         var angle = -parseFloat(params.options.angle) * Math.PI / 180;
2812
2813                         var dimAngle = angle;
2814                         if (dimAngle > Math.PI*0.5)
2815                                 dimAngle = Math.PI - dimAngle;
2816                         if (dimAngle < -Math.PI*0.5)
2817                                 dimAngle = -Math.PI - dimAngle;
2818
2819                         var diag = Math.sqrt(width*width + height*height);
2820
2821                         var diagAngle1 = Math.abs(dimAngle) - Math.abs(Math.atan2(height, width));
2822                         var diagAngle2 = Math.abs(dimAngle) + Math.abs(Math.atan2(height, width));
2823
2824                         var newWidth = Math.abs(Math.cos(diagAngle1) * diag);
2825                         var newHeight = Math.abs(Math.sin(diagAngle2) * diag);
2826
2827                         canvas.width = newWidth;
2828                         canvas.height = newHeight;
2829
2830                         var ctx = canvas.getContext("2d");
2831                         ctx.translate(newWidth/2, newHeight/2);
2832                         ctx.rotate(angle);
2833                         ctx.drawImage(copy,-width/2,-height/2);
2834
2835                         params.useData = false;
2836                         return true;
2837                 }
2838         },
2839         checkSupport : function() {
2840                 return Pixastic.Client.hasCanvas();
2841         }
2842 }
2843
2844
2845 /*
2846  * Pixastic Lib - Sepia filter - v0.1.0
2847  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2848  * License: [http://www.pixastic.com/lib/license.txt]
2849  */
2850
2851 Pixastic.Actions.sepia = {
2852
2853         process : function(params) {
2854                 var mode = (parseInt(params.options.mode,10)||0);
2855                 if (mode < 0) mode = 0;
2856                 if (mode > 1) mode = 1;
2857
2858                 if (Pixastic.Client.hasCanvasImageData()) {
2859                         var data = Pixastic.prepareData(params);
2860                         var rect = params.options.rect;
2861                         var w = rect.width;
2862                         var h = rect.height;
2863                         var w4 = w*4;
2864                         var y = h;
2865                         do {
2866                                 var offsetY = (y-1)*w4;
2867                                 var x = w;
2868                                 do {
2869                                         var offset = offsetY + (x-1)*4;
2870
2871                                         if (mode) {
2872                                                 // a bit faster, but not as good
2873                                                 var d = data[offset] * 0.299 + data[offset+1] * 0.587 + data[offset+2] * 0.114;
2874                                                 var r = (d + 39);
2875                                                 var g = (d + 14);
2876                                                 var b = (d - 36);
2877                                         } else {
2878                                                 // Microsoft
2879                                                 var or = data[offset];
2880                                                 var og = data[offset+1];
2881                                                 var ob = data[offset+2];
2882
2883                                                 var r = (or * 0.393 + og * 0.769 + ob * 0.189);
2884                                                 var g = (or * 0.349 + og * 0.686 + ob * 0.168);
2885                                                 var b = (or * 0.272 + og * 0.534 + ob * 0.131);
2886                                         }
2887
2888                                         if (r < 0) r = 0; if (r > 255) r = 255;
2889                                         if (g < 0) g = 0; if (g > 255) g = 255;
2890                                         if (b < 0) b = 0; if (b > 255) b = 255;
2891
2892                                         data[offset] = r;
2893                                         data[offset+1] = g;
2894                                         data[offset+2] = b;
2895
2896                                 } while (--x);
2897                         } while (--y);
2898                         return true;
2899                 }
2900         },
2901         checkSupport : function() {
2902                 return Pixastic.Client.hasCanvasImageData();
2903         }
2904 }/*
2905  * Pixastic Lib - Sharpen filter - v0.1.0
2906  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
2907  * License: [http://www.pixastic.com/lib/license.txt]
2908  */
2909
2910 Pixastic.Actions.sharpen = {
2911         process : function(params) {
2912
2913                 var strength = 0;
2914                 if (typeof params.options.amount != "undefined")
2915                         strength = parseFloat(params.options.amount)||0;
2916
2917                 if (strength < 0) strength = 0;
2918                 if (strength > 1) strength = 1;
2919
2920                 if (Pixastic.Client.hasCanvasImageData()) {
2921                         var data = Pixastic.prepareData(params);
2922                         var dataCopy = Pixastic.prepareData(params, true)
2923
2924                         var mul = 15;
2925                         var mulOther = 1 + 3*strength;
2926
2927                         var kernel = [
2928                                 [0,     -mulOther,      0],
2929                                 [-mulOther,     mul,    -mulOther],
2930                                 [0,     -mulOther,      0]
2931                         ];
2932
2933                         var weight = 0;
2934                         for (var i=0;i<3;i++) {
2935                                 for (var j=0;j<3;j++) {
2936                                         weight += kernel[i][j];
2937                                 }
2938                         }
2939
2940                         weight = 1 / weight;
2941
2942                         var rect = params.options.rect;
2943                         var w = rect.width;
2944                         var h = rect.height;
2945
2946                         mul *= weight;
2947                         mulOther *= weight;
2948
2949                         var w4 = w*4;
2950                         var y = h;
2951                         do {
2952                                 var offsetY = (y-1)*w4;
2953
2954                                 var nextY = (y == h) ? y - 1 : y;
2955                                 var prevY = (y == 1) ? 0 : y-2;
2956
2957                                 var offsetYPrev = prevY*w4;
2958                                 var offsetYNext = nextY*w4;
2959
2960                                 var x = w;
2961                                 do {
2962                                         var offset = offsetY + (x*4-4);
2963
2964                                         var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
2965                                         var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
2966
2967                                         var r = ((
2968                                                 - dataCopy[offsetPrev]
2969                                                 - dataCopy[offset-4]
2970                                                 - dataCopy[offset+4]
2971                                                 - dataCopy[offsetNext])         * mulOther
2972                                                 + dataCopy[offset]      * mul
2973                                                 );
2974
2975                                         var g = ((
2976                                                 - dataCopy[offsetPrev+1]
2977                                                 - dataCopy[offset-3]
2978                                                 - dataCopy[offset+5]
2979                                                 - dataCopy[offsetNext+1])       * mulOther
2980                                                 + dataCopy[offset+1]    * mul
2981                                                 );
2982
2983                                         var b = ((
2984                                                 - dataCopy[offsetPrev+2]
2985                                                 - dataCopy[offset-2]
2986                                                 - dataCopy[offset+6]
2987                                                 - dataCopy[offsetNext+2])       * mulOther
2988                                                 + dataCopy[offset+2]    * mul
2989                                                 );
2990
2991
2992                                         if (r < 0 ) r = 0;
2993                                         if (g < 0 ) g = 0;
2994                                         if (b < 0 ) b = 0;
2995                                         if (r > 255 ) r = 255;
2996                                         if (g > 255 ) g = 255;
2997                                         if (b > 255 ) b = 255;
2998
2999                                         data[offset] = r;
3000                                         data[offset+1] = g;
3001                                         data[offset+2] = b;
3002
3003                                 } while (--x);
3004                         } while (--y);
3005
3006                         return true;
3007
3008                 }
3009         },
3010         checkSupport : function() {
3011                 return Pixastic.Client.hasCanvasImageData();
3012         }
3013 }
3014 /*
3015  * Pixastic Lib - Solarize filter - v0.1.0
3016  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
3017  * License: [http://www.pixastic.com/lib/license.txt]
3018  */
3019
3020 Pixastic.Actions.solarize = {
3021
3022         process : function(params) {
3023                 var useAverage = !!(params.options.average && params.options.average != "false");
3024
3025                 if (Pixastic.Client.hasCanvasImageData()) {
3026                         var data = Pixastic.prepareData(params);
3027                         var rect = params.options.rect;
3028                         var w = rect.width;
3029                         var h = rect.height;
3030                         var w4 = w*4;
3031                         var y = h;
3032                         do {
3033                                 var offsetY = (y-1)*w4;
3034                                 var x = w;
3035                                 do {
3036                                         var offset = offsetY + (x-1)*4;
3037
3038                                         var r = data[offset];
3039                                         var g = data[offset+1];
3040                                         var b = data[offset+2];
3041
3042                                         if (r > 127) r = 255 - r;
3043                                         if (g > 127) g = 255 - g;
3044                                         if (b > 127) b = 255 - b;
3045
3046                                         data[offset] = r;
3047                                         data[offset+1] = g;
3048                                         data[offset+2] = b;
3049
3050                                 } while (--x);
3051                         } while (--y);
3052                         return true;
3053                 }
3054         },
3055         checkSupport : function() {
3056                 return (Pixastic.Client.hasCanvasImageData());
3057         }
3058 }/*
3059  * Pixastic Lib - USM - v0.1.0
3060  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
3061  * License: [http://www.pixastic.com/lib/license.txt]
3062  */
3063
3064
3065 Pixastic.Actions.unsharpmask = {
3066         process : function(params) {
3067
3068                 var amount = (parseFloat(params.options.amount)||0);
3069                 var blurAmount = parseFloat(params.options.radius)||0;
3070                 var threshold = parseFloat(params.options.threshold)||0;
3071
3072                 amount = Math.min(500,Math.max(0,amount)) / 2;
3073                 blurAmount = Math.min(5,Math.max(0,blurAmount)) / 10;
3074                 threshold = Math.min(255,Math.max(0,threshold));
3075
3076                 threshold--;
3077                 var thresholdNeg = -threshold;
3078
3079                 amount *= 0.016;
3080                 amount++;
3081
3082                 if (Pixastic.Client.hasCanvasImageData()) {
3083                         var rect = params.options.rect;
3084
3085                         var blurCanvas = document.createElement("canvas");
3086                         blurCanvas.width = params.width;
3087                         blurCanvas.height = params.height;
3088                         var blurCtx = blurCanvas.getContext("2d");
3089                         blurCtx.drawImage(params.canvas,0,0);
3090
3091                         var scale = 2;
3092                         var smallWidth = Math.round(params.width / scale);
3093                         var smallHeight = Math.round(params.height / scale);
3094
3095                         var copy = document.createElement("canvas");
3096                         copy.width = smallWidth;
3097                         copy.height = smallHeight;
3098
3099                         var steps = Math.round(blurAmount * 20);
3100
3101                         var copyCtx = copy.getContext("2d");
3102                         for (var i=0;i<steps;i++) {
3103                                 var scaledWidth = Math.max(1,Math.round(smallWidth - i));
3104                                 var scaledHeight = Math.max(1,Math.round(smallHeight - i));
3105
3106                                 copyCtx.clearRect(0,0,smallWidth,smallHeight);
3107
3108                                 copyCtx.drawImage(
3109                                         blurCanvas,
3110                                         0,0,params.width,params.height,
3111                                         0,0,scaledWidth,scaledHeight
3112                                 );
3113
3114                                 blurCtx.clearRect(0,0,params.width,params.height);
3115
3116                                 blurCtx.drawImage(
3117                                         copy,
3118                                         0,0,scaledWidth,scaledHeight,
3119                                         0,0,params.width,params.height
3120                                 );
3121                         }
3122
3123                         var data = Pixastic.prepareData(params);
3124                         var blurData = Pixastic.prepareData({canvas:blurCanvas,options:params.options});
3125                         var w = rect.width;
3126                         var h = rect.height;
3127                         var w4 = w*4;
3128                         var y = h;
3129                         do {
3130                                 var offsetY = (y-1)*w4;
3131                                 var x = w;
3132                                 do {
3133                                         var offset = offsetY + (x*4-4);
3134
3135                                         var difR = data[offset] - blurData[offset];
3136                                         if (difR > threshold || difR < thresholdNeg) {
3137                                                 var blurR = blurData[offset];
3138                                                 blurR = amount * difR + blurR;
3139                                                 data[offset] = blurR > 255 ? 255 : (blurR < 0 ? 0 : blurR);
3140                                         }
3141
3142                                         var difG = data[offset+1] - blurData[offset+1];
3143                                         if (difG > threshold || difG < thresholdNeg) {
3144                                                 var blurG = blurData[offset+1];
3145                                                 blurG = amount * difG + blurG;
3146                                                 data[offset+1] = blurG > 255 ? 255 : (blurG < 0 ? 0 : blurG);
3147                                         }
3148
3149                                         var difB = data[offset+2] - blurData[offset+2];
3150                                         if (difB > threshold || difB < thresholdNeg) {
3151                                                 var blurB = blurData[offset+2];
3152                                                 blurB = amount * difB + blurB;
3153                                                 data[offset+2] = blurB > 255 ? 255 : (blurB < 0 ? 0 : blurB);
3154                                         }
3155
3156                                 } while (--x);
3157                         } while (--y);
3158
3159                         return true;
3160                 }
3161         },
3162         checkSupport : function() {
3163                 return Pixastic.Client.hasCanvasImageData();
3164         }
3165 }
3166
3167
3168
3169