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

   1 /*
   2  * Pixastic Lib - Blur filter - 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.blur = {
   8         process : function(params) {
   9
  10                 if (typeof params.options.fixMargin == "undefined")
  11                         params.options.fixMargin = true;
  12
  13                 if (Pixastic.Client.hasCanvasImageData()) {
  14                         var data = Pixastic.prepareData(params);
  15                         var dataCopy = Pixastic.prepareData(params, true)
  16
  17                         /*
  18                         var kernel = [
  19                                 [0.5,   1,      0.5],
  20                                 [1,     2,      1],
  21                                 [0.5,   1,      0.5]
  22                         ];
  23                         */
  24
  25                         var kernel = [
  26                                 [0,     1,      0],
  27                                 [1,     2,      1],
  28                                 [0,     1,      0]
  29                         ];
  30
  31                         var weight = 0;
  32                         for (var i=0;i<3;i++) {
  33                                 for (var j=0;j<3;j++) {
  34                                         weight += kernel[i][j];
  35                                 }
  36                         }
  37
  38                         weight = 1 / (weight*2);
  39
  40                         var rect = params.options.rect;
  41                         var w = rect.width;
  42                         var h = rect.height;
  43
  44                         var w4 = w*4;
  45                         var y = h;
  46                         do {
  47                                 var offsetY = (y-1)*w4;
  48
  49                                 var prevY = (y == 1) ? 0 : y-2;
  50                                 var nextY = (y == h) ? y - 1 : y;
  51
  52                                 var offsetYPrev = prevY*w*4;
  53                                 var offsetYNext = nextY*w*4;
  54
  55                                 var x = w;
  56                                 do {
  57                                         var offset = offsetY + (x*4-4);
  58
  59                                         var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
  60                                         var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
  61
  62                                         data[offset] = (
  63                                                 /*
  64                                                 dataCopy[offsetPrev - 4]
  65                                                 + dataCopy[offsetPrev+4]
  66                                                 + dataCopy[offsetNext - 4]
  67                                                 + dataCopy[offsetNext+4]
  68                                                 +
  69                                                 */
  70                                                 (dataCopy[offsetPrev]
  71                                                 + dataCopy[offset-4]
  72                                                 + dataCopy[offset+4]
  73                                                 + dataCopy[offsetNext])         * 2
  74                                                 + dataCopy[offset]              * 4
  75                                                 ) * weight;
  76
  77                                         data[offset+1] = (
  78                                                 /*
  79                                                 dataCopy[offsetPrev - 3]
  80                                                 + dataCopy[offsetPrev+5]
  81                                                 + dataCopy[offsetNext - 3]
  82                                                 + dataCopy[offsetNext+5]
  83                                                 +
  84                                                 */
  85                                                 (dataCopy[offsetPrev+1]
  86                                                 + dataCopy[offset-3]
  87                                                 + dataCopy[offset+5]
  88                                                 + dataCopy[offsetNext+1])       * 2
  89                                                 + dataCopy[offset+1]            * 4
  90                                                 ) * weight;
  91
  92                                         data[offset+2] = (
  93                                                 /*
  94                                                 dataCopy[offsetPrev - 2]
  95                                                 + dataCopy[offsetPrev+6]
  96                                                 + dataCopy[offsetNext - 2]
  97                                                 + dataCopy[offsetNext+6]
  98                                                 +
  99                                                 */
 100                                                 (dataCopy[offsetPrev+2]
 101                                                 + dataCopy[offset-2]
 102                                                 + dataCopy[offset+6]
 103                                                 + dataCopy[offsetNext+2])       * 2
 104                                                 + dataCopy[offset+2]            * 4
 105                                                 ) * weight;
 106
 107                                 } while (--x);
 108                         } while (--y);
 109
 110                         return true;
 111
 112                 } else if (Pixastic.Client.isIE()) {
 113                         params.image.style.filter += " progid:DXImageTransform.Microsoft.Blur(pixelradius=1.5)";
 114
 115                         if (params.options.fixMargin) {
 116                                 params.image.style.marginLeft = (parseInt(params.image.style.marginLeft,10)||0) - 2 + "px";
 117                                 params.image.style.marginTop = (parseInt(params.image.style.marginTop,10)||0) - 2 + "px";
 118                         }
 119
 120                         return true;
 121                 }
 122         },
 123         checkSupport : function() {
 124                 return (Pixastic.Client.hasCanvasImageData() || Pixastic.Client.isIE());
 125         }
 126 }