js2/mwEmbed/libClipEdit/pixastic-lib/actions/blend.js

   1 /*
   2  * Pixastic Lib - Blend - v0.1.0
   3  * Copyright (c) 2008 Jacob Seidelin, jseidelin@nihilogic.dk, http://blog.nihilogic.dk/
   4  * MIT License [http://www.opensource.org/licenses/mit-license.php]
   5  */
   6
   7 Pixastic.Actions.blend = {
   8
   9         process : function(params) {
  10                 var amount = parseFloat(params.options.amount);
  11                 var mode = (params.options.mode || "normal").toLowerCase();
  12                 var image = params.options.image;
  13
  14                 amount = Math.max(0,Math.min(1,amount));
  15
  16                 if (!image) return false;
  17
  18                 if (Pixastic.Client.hasCanvasImageData()) {
  19                         var rect = params.options.rect;
  20                         var data = Pixastic.prepareData(params);
  21                         var w = rect.width;
  22                         var h = rect.height;
  23
  24                         params.useData = false;
  25
  26                         var otherCanvas = document.createElement("canvas");
  27                         otherCanvas.width = params.canvas.width;
  28                         otherCanvas.height = params.canvas.height;
  29                         var otherCtx = otherCanvas.getContext("2d");
  30                         otherCtx.drawImage(image,0,0);
  31
  32                         var params2 = {canvas:otherCanvas,options:params.options};
  33                         var data2 = Pixastic.prepareData(params2);
  34                         var dataDesc2 = params2.canvasData;
  35
  36                         var p = w*h;
  37                         var pix = p*4;
  38                         var pix1, pix2;
  39                         var r1, g1, b1;
  40                         var r2, g2, b2;
  41                         var r3, g3, b3;
  42                         var r4, g4, b4;
  43
  44                         switch (mode) {
  45                                 case "normal" :
  46                                         //while (p--) {
  47                                         //      data2[pix-=4] = data2[pix];
  48                                         //      data2[pix1=pix+1] = data2[pix1];
  49                                         //      data2[pix2=pix+2] = data2[pix2];
  50                                         //}
  51                                         break;
  52
  53                                 case "multiply" :
  54                                         while (p--) {
  55                                                 data2[pix-=4] = data[pix] * data2[pix] / 255;
  56                                                 data2[pix1=pix+1] = data[pix1] * data2[pix1] / 255;
  57                                                 data2[pix2=pix+2] = data[pix2] * data2[pix2] / 255;
  58                                         }
  59                                         break;
  60
  61                                 case "lighten" :
  62                                         while (p--) {
  63                                                 if ((r1 = data[pix-=4]) > data2[pix])
  64                                                         data2[pix] = r1;
  65                                                 if ((g1 = data[pix1=pix+1]) > data2[pix1])
  66                                                         data2[pix1] = g1;
  67                                                 if ((b1 = data[pix2=pix+2]) > data2[pix2])
  68                                                         data2[pix2] = b1;
  69                                         }
  70                                         break;
  71
  72                                 case "darken" :
  73                                         while (p--) {
  74                                                 if ((r1 = data[pix-=4]) < data2[pix])
  75                                                         data2[pix] = r1;
  76                                                 if ((g1 = data[pix1=pix+1]) < data2[pix1])
  77                                                         data2[pix1] = g1;
  78                                                 if ((b1 = data[pix2=pix+2]) < data2[pix2])
  79                                                         data2[pix2] = b1;
  80
  81                                         }
  82                                         break;
  83
  84                                 case "darkercolor" :
  85                                         while (p--) {
  86                                                 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)) {
  87                                                         data2[pix] = r1;
  88                                                         data2[pix1] = g1;
  89                                                         data2[pix2] = b1;
  90                                                 }
  91                                         }
  92                                         break;
  93
  94                                 case "lightercolor" :
  95                                         while (p--) {
  96                                                 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)) {
  97                                                         data2[pix] = r1;
  98                                                         data2[pix1] = g1;
  99                                                         data2[pix2] = b1;
 100                                                 }
 101                                         }
 102                                         break;
 103
 104                                 case "lineardodge" :
 105                                         while (p--) {
 106                                                 if ((r3 = data[pix-=4] + data2[pix]) > 255)
 107                                                         data2[pix] = 255;
 108                                                 else
 109                                                         data2[pix] = r3;
 110                                                 if ((g3 = data[pix1=pix+1] + data2[pix1]) > 255)
 111                                                         data2[pix1] = 255;
 112                                                 else
 113                                                         data2[pix1] = g3;
 114                                                 if ((b3 = data[pix2=pix+2] + data2[pix2]) > 255)
 115                                                         data2[pix2] = 255;
 116                                                 else
 117                                                         data2[pix2] = b3;
 118                                         }
 119                                         break;
 120
 121                                 case "linearburn" :
 122                                         while (p--) {
 123                                                 if ((r3 = data[pix-=4] + data2[pix]) < 255)
 124                                                         data2[pix] = 0;
 125                                                 else
 126                                                         data2[pix] = (r3 - 255);
 127                                                 if ((g3 = data[pix1=pix+1] + data2[pix1]) < 255)
 128                                                         data2[pix1] = 0;
 129                                                 else
 130                                                         data2[pix1] = (g3 - 255);
 131                                                 if ((b3 = data[pix2=pix+2] + data2[pix2]) < 255)
 132                                                         data2[pix2] = 0;
 133                                                 else
 134                                                         data2[pix2] = (b3 - 255);
 135                                         }
 136                                         break;
 137
 138                                 case "difference" :
 139                                         while (p--) {
 140                                                 if ((r3 = data[pix-=4] - data2[pix]) < 0)
 141                                                         data2[pix] = -r3;
 142                                                 else
 143                                                         data2[pix] = r3;
 144                                                 if ((g3 = data[pix1=pix+1] - data2[pix1]) < 0)
 145                                                         data2[pix1] = -g3;
 146                                                 else
 147                                                         data2[pix1] = g3;
 148                                                 if ((b3 = data[pix2=pix+2] - data2[pix2]) < 0)
 149                                                         data2[pix2] = -b3;
 150                                                 else
 151                                                         data2[pix2] = b3;
 152                                         }
 153                                         break;
 154
 155                                 case "screen" :
 156                                         while (p--) {
 157                                                 data2[pix-=4] = (255 - ( ((255-data2[pix])*(255-data[pix])) >> 8));
 158                                                 data2[pix1=pix+1] = (255 - ( ((255-data2[pix1])*(255-data[pix1])) >> 8));
 159                                                 data2[pix2=pix+2] = (255 - ( ((255-data2[pix2])*(255-data[pix2])) >> 8));
 160                                         }
 161                                         break;
 162
 163                                 case "exclusion" :
 164                                         var div_2_255 = 2 / 255;
 165                                         while (p--) {
 166                                                 data2[pix-=4] = (r1 = data[pix]) - (r1 * div_2_255 - 1) * data2[pix];
 167                                                 data2[pix1=pix+1] = (g1 = data[pix1]) - (g1 * div_2_255 - 1) * data2[pix1];
 168                                                 data2[pix2=pix+2] = (b1 = data[pix2]) - (b1 * div_2_255 - 1) * data2[pix2];
 169                                         }
 170                                         break;
 171
 172                                 case "overlay" :
 173                                         var div_2_255 = 2 / 255;
 174                                         while (p--) {
 175                                                 if ((r1 = data[pix-=4]) < 128)
 176                                                         data2[pix] = data2[pix]*r1*div_2_255;
 177                                                 else
 178                                                         data2[pix] = 255 - (255-data2[pix])*(255-r1)*div_2_255;
 179
 180                                                 if ((g1 = data[pix1=pix+1]) < 128)
 181                                                         data2[pix1] = data2[pix1]*g1*div_2_255;
 182                                                 else
 183                                                         data2[pix1] = 255 - (255-data2[pix1])*(255-g1)*div_2_255;
 184
 185                                                 if ((b1 = data[pix2=pix+2]) < 128)
 186                                                         data2[pix2] = data2[pix2]*b1*div_2_255;
 187                                                 else
 188                                                         data2[pix2] = 255 - (255-data2[pix2])*(255-b1)*div_2_255;
 189
 190                                         }
 191                                         break;
 192
 193                                 case "softlight" :
 194                                         var div_2_255 = 2 / 255;
 195                                         while (p--) {
 196                                                 if ((r1 = data[pix-=4]) < 128)
 197                                                         data2[pix] = ((data2[pix]>>1) + 64) * r1 * div_2_255;
 198                                                 else
 199                                                         data2[pix] = 255 - (191 - (data2[pix]>>1)) * (255-r1) * div_2_255;
 200
 201                                                 if ((g1 = data[pix1=pix+1]) < 128)
 202                                                         data2[pix1] = ((data2[pix1]>>1)+64) * g1 * div_2_255;
 203                                                 else
 204                                                         data2[pix1] = 255 - (191 - (data2[pix1]>>1)) * (255-g1) * div_2_255;
 205
 206                                                 if ((b1 = data[pix2=pix+2]) < 128)
 207                                                         data2[pix2] = ((data2[pix2]>>1)+64) * b1 * div_2_255;
 208                                                 else
 209                                                         data2[pix2] = 255 - (191 - (data2[pix2]>>1)) * (255-b1) * div_2_255;
 210
 211                                         }
 212                                         break;
 213
 214
 215                                 case "hardlight" :
 216                                         var div_2_255 = 2 / 255;
 217                                         while (p--) {
 218                                                 if ((r2 = data2[pix-=4]) < 128)
 219                                                         data2[pix] = data[pix] * r2 * div_2_255;
 220                                                 else
 221                                                         data2[pix] = 255 - (255-data[pix]) * (255-r2) * div_2_255;
 222
 223                                                 if ((g2 = data2[pix1=pix+1]) < 128)
 224                                                         data2[pix1] = data[pix1] * g2 * div_2_255;
 225                                                 else
 226                                                         data2[pix1] = 255 - (255-data[pix1]) * (255-g2) * div_2_255;
 227
 228                                                 if ((b2 = data2[pix2=pix+2]) < 128)
 229                                                         data2[pix2] = data[pix2] * b2 * div_2_255;
 230                                                 else
 231                                                         data2[pix2] = 255 - (255-data[pix2]) * (255-b2) * div_2_255;
 232
 233                                         }
 234                                         break;
 235
 236                                 case "colordodge" :
 237                                         while (p--) {
 238                                                 if ((r3 = (data[pix-=4]<<8)/(255-(r2 = data2[pix]))) > 255 || r2 == 255)
 239                                                         data2[pix] = 255;
 240                                                 else
 241                                                         data2[pix] = r3;
 242
 243                                                 if ((g3 = (data[pix1=pix+1]<<8)/(255-(g2 = data2[pix1]))) > 255 || g2 == 255)
 244                                                         data2[pix1] = 255;
 245                                                 else
 246                                                         data2[pix1] = g3;
 247
 248                                                 if ((b3 = (data[pix2=pix+2]<<8)/(255-(b2 = data2[pix2]))) > 255 || b2 == 255)
 249                                                         data2[pix2] = 255;
 250                                                 else
 251                                                         data2[pix2] = b3;
 252                                         }
 253
 254                                         break;
 255
 256                                 case "colorburn" :
 257                                         while (p--) {
 258                                                 if ((r3 = 255-((255-data[pix-=4])<<8)/data2[pix]) < 0 || data2[pix] == 0)
 259                                                         data2[pix] = 0;
 260                                                 else
 261                                                         data2[pix] = r3;
 262
 263                                                 if ((g3 = 255-((255-data[pix1=pix+1])<<8)/data2[pix1]) < 0 || data2[pix1] == 0)
 264                                                         data2[pix1] = 0;
 265                                                 else
 266                                                         data2[pix1] = g3;
 267
 268                                                 if ((b3 = 255-((255-data[pix2=pix+2])<<8)/data2[pix2]) < 0 || data2[pix2] == 0)
 269                                                         data2[pix2] = 0;
 270                                                 else
 271                                                         data2[pix2] = b3;
 272                                         }
 273                                         break;
 274
 275                                 case "linearlight" :
 276                                         while (p--) {
 277                                                 if ( ((r3 = 2*(r2=data2[pix-=4])+data[pix]-256) < 0) || (r2 < 128 && r3 < 0)) {
 278                                                         data2[pix] = 0
 279                                                 } else {
 280                                                         if (r3 > 255)
 281                                                                 data2[pix] = 255;
 282                                                         else
 283                                                                 data2[pix] = r3;
 284                                                 }
 285                                                 if ( ((g3 = 2*(g2=data2[pix1=pix+1])+data[pix1]-256) < 0) || (g2 < 128 && g3 < 0)) {
 286                                                         data2[pix1] = 0
 287                                                 } else {
 288                                                         if (g3 > 255)
 289                                                                 data2[pix1] = 255;
 290                                                         else
 291                                                                 data2[pix1] = g3;
 292                                                 }
 293                                                 if ( ((b3 = 2*(b2=data2[pix2=pix+2])+data[pix2]-256) < 0) || (b2 < 128 && b3 < 0)) {
 294                                                         data2[pix2] = 0
 295                                                 } else {
 296                                                         if (b3 > 255)
 297                                                                 data2[pix2] = 255;
 298                                                         else
 299                                                                 data2[pix2] = b3;
 300                                                 }
 301                                         }
 302
 303                                         break;
 304
 305                                 case "vividlight" :
 306                                         while (p--) {
 307                                                 if ((r2=data2[pix-=4]) < 128) {
 308                                                         if (r2) {
 309                                                                 if ((r3 = 255 - ((255-data[pix])<<8) / (2*r2)) < 0)
 310                                                                         data2[pix] = 0;
 311                                                                 else
 312                                                                         data2[pix] = r3
 313                                                         } else {
 314                                                                 data2[pix] = 0;
 315                                                         }
 316                                                 } else if ((r3 = (r4=2*r2-256)) < 255) {
 317                                                         if ((r3 = (data[pix]<<8)/(255-r4)) > 255)
 318                                                                 data2[pix] = 255;
 319                                                         else
 320                                                                 data2[pix] = r3;
 321                                                 } else {
 322                                                         if (r3 < 0)
 323                                                                 data2[pix] = 0;
 324                                                         else
 325                                                                 data2[pix] = r3
 326                                                 }
 327
 328                                                 if ((g2=data2[pix1=pix+1]) < 128) {
 329                                                         if (g2) {
 330                                                                 if ((g3 = 255 - ((255-data[pix1])<<8) / (2*g2)) < 0)
 331                                                                         data2[pix1] = 0;
 332                                                                 else
 333                                                                         data2[pix1] = g3;
 334                                                         } else {
 335                                                                 data2[pix1] = 0;
 336                                                         }
 337                                                 } else if ((g3 = (g4=2*g2-256)) < 255) {
 338                                                         if ((g3 = (data[pix1]<<8)/(255-g4)) > 255)
 339                                                                 data2[pix1] = 255;
 340                                                         else
 341                                                                 data2[pix1] = g3;
 342                                                 } else {
 343                                                         if (g3 < 0)
 344                                                                 data2[pix1] = 0;
 345                                                         else
 346                                                                 data2[pix1] = g3;
 347                                                 }
 348
 349                                                 if ((b2=data2[pix2=pix+2]) < 128) {
 350                                                         if (b2) {
 351                                                                 if ((b3 = 255 - ((255-data[pix2])<<8) / (2*b2)) < 0)
 352                                                                         data2[pix2] = 0;
 353                                                                 else
 354                                                                         data2[pix2] = b3;
 355                                                         } else {
 356                                                                 data2[pix2] = 0;
 357                                                         }
 358                                                 } else if ((b3 = (b4=2*b2-256)) < 255) {
 359                                                         if ((b3 = (data[pix2]<<8)/(255-b4)) > 255)
 360                                                                 data2[pix2] = 255;
 361                                                         else
 362                                                                 data2[pix2] = b3;
 363                                                 } else {
 364                                                         if (b3 < 0)
 365                                                                 data2[pix2] = 0;
 366                                                         else
 367                                                                 data2[pix2] = b3;
 368                                                 }
 369                                         }
 370                                         break;
 371
 372                                 case "pinlight" :
 373                                         while (p--) {
 374                                                 if ((r2=data2[pix-=4]) < 128)
 375                                                         if ((r1=data[pix]) < (r4=2*r2))
 376                                                                 data2[pix] = r1;
 377                                                         else
 378                                                                 data2[pix] = r4;
 379                                                 else
 380                                                         if ((r1=data[pix]) > (r4=2*r2-256))
 381                                                                 data2[pix] = r1;
 382                                                         else
 383                                                                 data2[pix] = r4;
 384
 385                                                 if ((g2=data2[pix1=pix+1]) < 128)
 386                                                         if ((g1=data[pix1]) < (g4=2*g2))
 387                                                                 data2[pix1] = g1;
 388                                                         else
 389                                                                 data2[pix1] = g4;
 390                                                 else
 391                                                         if ((g1=data[pix1]) > (g4=2*g2-256))
 392                                                                 data2[pix1] = g1;
 393                                                         else
 394                                                                 data2[pix1] = g4;
 395
 396                                                 if ((r2=data2[pix2=pix+2]) < 128)
 397                                                         if ((r1=data[pix2]) < (r4=2*r2))
 398                                                                 data2[pix2] = r1;
 399                                                         else
 400                                                                 data2[pix2] = r4;
 401                                                 else
 402                                                         if ((r1=data[pix2]) > (r4=2*r2-256))
 403                                                                 data2[pix2] = r1;
 404                                                         else
 405                                                                 data2[pix2] = r4;
 406                                         }
 407                                         break;
 408
 409                                 case "hardmix" :
 410                                         while (p--) {
 411                                                 if ((r2 = data2[pix-=4]) < 128)
 412                                                         if (255 - ((255-data[pix])<<8)/(2*r2) < 128 || r2 == 0)
 413                                                                 data2[pix] = 0;
 414                                                         else
 415                                                                 data2[pix] = 255;
 416                                                 else if ((r4=2*r2-256) < 255 && (data[pix]<<8)/(255-r4) < 128)
 417                                                         data2[pix] = 0;
 418                                                 else
 419                                                         data2[pix] = 255;
 420
 421                                                 if ((g2 = data2[pix1=pix+1]) < 128)
 422                                                         if (255 - ((255-data[pix1])<<8)/(2*g2) < 128 || g2 == 0)
 423                                                                 data2[pix1] = 0;
 424                                                         else
 425                                                                 data2[pix1] = 255;
 426                                                 else if ((g4=2*g2-256) < 255 && (data[pix1]<<8)/(255-g4) < 128)
 427                                                         data2[pix1] = 0;
 428                                                 else
 429                                                         data2[pix1] = 255;
 430
 431                                                 if ((b2 = data2[pix2=pix+2]) < 128)
 432                                                         if (255 - ((255-data[pix2])<<8)/(2*b2) < 128 || b2 == 0)
 433                                                                 data2[pix2] = 0;
 434                                                         else
 435                                                                 data2[pix2] = 255;
 436                                                 else if ((b4=2*b2-256) < 255 && (data[pix2]<<8)/(255-b4) < 128)
 437                                                         data2[pix2] = 0;
 438                                                 else
 439                                                         data2[pix2] = 255;
 440                                         }
 441                                         break;
 442                         }
 443
 444                         otherCtx.putImageData(dataDesc2,0,0);
 445                         var ctx = params.canvas.getContext("2d");
 446                         ctx.save();
 447                         ctx.globalAlpha = amount;
 448                         ctx.drawImage(
 449                                 otherCanvas,
 450                                 0,0,rect.width,rect.height,
 451                                 rect.left,rect.top,rect.width,rect.height
 452                         );
 453                         ctx.globalAlpha = 1;
 454                         ctx.restore();
 455
 456                         return true;
 457                 }
 458         },
 459         checkSupport : function() {
 460                 return Pixastic.Client.hasCanvasImageData();
 461         }
 462 }