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

   1 /*
   2  * Pixastic Lib - Laplace 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.laplace = {
   8         process : function(params) {
   9
  10                 var strength = 1.0;
  11                 var invert = !!(params.options.invert);
  12                 var contrast = parseFloat(params.options.edgeStrength)||0;
  13
  14                 var greyLevel = parseInt(params.options.greyLevel)||0;
  15
  16                 contrast = -contrast;
  17
  18                 if (Pixastic.Client.hasCanvasImageData()) {
  19                         var data = Pixastic.prepareData(params);
  20                         var dataCopy = Pixastic.prepareData(params, true)
  21
  22                         var kernel = [
  23                                 [-1,    -1,     -1],
  24                                 [-1,    8,      -1],
  25                                 [-1,    -1,     -1]
  26                         ];
  27
  28                         var weight = 1/8;
  29
  30                         var rect = params.options.rect;
  31                         var w = rect.width;
  32                         var h = rect.height;
  33
  34                         var w4 = w*4;
  35                         var y = h;
  36                         do {
  37                                 var offsetY = (y-1)*w4;
  38
  39                                 var nextY = (y == h) ? y - 1 : y;
  40                                 var prevY = (y == 1) ? 0 : y-2;
  41
  42                                 var offsetYPrev = prevY*w*4;
  43                                 var offsetYNext = nextY*w*4;
  44
  45                                 var x = w;
  46                                 do {
  47                                         var offset = offsetY + (x*4-4);
  48
  49                                         var offsetPrev = offsetYPrev + ((x == 1) ? 0 : x-2) * 4;
  50                                         var offsetNext = offsetYNext + ((x == w) ? x-1 : x) * 4;
  51
  52                                         var r = ((-dataCopy[offsetPrev-4]
  53                                                 - dataCopy[offsetPrev]
  54                                                 - dataCopy[offsetPrev+4]
  55                                                 - dataCopy[offset-4]
  56                                                 - dataCopy[offset+4]
  57                                                 - dataCopy[offsetNext-4]
  58                                                 - dataCopy[offsetNext]
  59                                                 - dataCopy[offsetNext+4])
  60                                                 + dataCopy[offset] * 8)
  61                                                 * weight;
  62
  63                                         var g = ((-dataCopy[offsetPrev-3]
  64                                                 - dataCopy[offsetPrev+1]
  65                                                 - dataCopy[offsetPrev+5]
  66                                                 - dataCopy[offset-3]
  67                                                 - dataCopy[offset+5]
  68                                                 - dataCopy[offsetNext-3]
  69                                                 - dataCopy[offsetNext+1]
  70                                                 - dataCopy[offsetNext+5])
  71                                                 + dataCopy[offset+1] * 8)
  72                                                 * weight;
  73
  74                                         var b = ((-dataCopy[offsetPrev-2]
  75                                                 - dataCopy[offsetPrev+2]
  76                                                 - dataCopy[offsetPrev+6]
  77                                                 - dataCopy[offset-2]
  78                                                 - dataCopy[offset+6]
  79                                                 - dataCopy[offsetNext-2]
  80                                                 - dataCopy[offsetNext+2]
  81                                                 - dataCopy[offsetNext+6])
  82                                                 + dataCopy[offset+2] * 8)
  83                                                 * weight;
  84
  85                                         var brightness = ((r + g + b)/3) + greyLevel;
  86
  87                                         if (contrast != 0) {
  88                                                 if (brightness > 127) {
  89                                                         brightness += ((brightness + 1) - 128) * contrast;
  90                                                 } else if (brightness < 127) {
  91                                                         brightness -= (brightness + 1) * contrast;
  92                                                 }
  93                                         }
  94                                         if (invert) {
  95                                                 brightness = 255 - brightness;
  96                                         }
  97                                         if (brightness < 0 ) brightness = 0;
  98                                         if (brightness > 255 ) brightness = 255;
  99
 100                                         data[offset] = data[offset+1] = data[offset+2] = brightness;
 101
 102                                 } while (--x);
 103                         } while (--y);
 104
 105                         return true;
 106                 }
 107         },
 108         checkSupport : function() {
 109                 return Pixastic.Client.hasCanvasImageData();
 110         }
 111 }
 112