pylib/templates/filter.stats.c.t

   1 %% extends "filter.c.t"
   2
   3 %% macro filter_stats_include()
   4 {{ filter_include() }}
   5 #include "GP_Stats.h"
   6 %% endmacro
   7
   8 /*
   9  * Filter per pixel type, used for images with more than one channel per pixel
  10  */
  11 %% macro filter_point_per_channel(name, opts="", filter_op)
  12 %% for pt in pixeltypes
  13 %% if not pt.is_unknown() and len(pt.chanslist) > 1
  14 static int GP_Filter{{ name }}_{{ pt.name }}(const GP_Context *src,
  15         {{ maybe_opts_r(opts) }}GP_ProgressCallback *callback)
  16 {
  17 {{ caller(pt) }}
  18         uint32_t x, y;
  19
  20         for (y = 0; y < src->h; y++) {
  21                 for (x = 0; x < src->w; x++) {
  22                         GP_Pixel pix = GP_GetPixel_Raw_{{ pt.pixelsize.suffix }}(src, x, y);
  23                         %% for c in pt.chanslist
  24                         int32_t {{ c[0] }} = GP_Pixel_GET_{{ c[0] }}_{{ pt.name }}(pix);
  25                         %% endfor
  26
  27                         %% for c in pt.chanslist
  28                         {{ filter_op(c[0], c[2]) }}
  29                         %% endfor
  30                 }
  31
  32                 if (GP_ProgressCallbackReport(callback, y, src->h, src->w))
  33                         return 1;
  34         }
  35
  36         GP_ProgressCallbackDone(callback);
  37         return 0;
  38 }
  39
  40 %% endif
  41 %% endfor
  42 %% endmacro
  43
  44 /*
  45  * Point filter per bpp (used for 1 channel pixels to save space).
  46  */
  47 %% macro filter_point_per_bpp(name, opts="", filter_op)
  48 %% for ps in pixelsizes
  49 %% if ps.size > 1
  50 static int GP_Filter{{ name }}_{{ ps.suffix }}(const GP_Context *src,
  51         {{ maybe_opts_r(opts) }}GP_ProgressCallback *callback)
  52 {
  53 {{ caller(ps) }}
  54         uint32_t x, y;
  55
  56         for (y = 0; y < src->h; y++) {
  57                 for (x = 0; x < src->w; x++) {
  58                         int32_t pix = GP_GetPixel_Raw_{{ ps.suffix }}(src, x, y);
  59                         {{ filter_op('pix', ps.size) }}
  60                 }
  61
  62                 if (GP_ProgressCallbackReport(callback, y, src->h, src->w))
  63                         return 1;
  64         }
  65
  66         GP_ProgressCallbackDone(callback);
  67         return 0;
  68 }
  69
  70 %% endif
  71 %% endfor
  72 %% endmacro
  73
  74 /*
  75  * Switch per pixel sizes or pixel types.
  76  */
  77 %% macro filter_functions(name, opts="", params="", fmt="")
  78 int GP_Filter{{ name }}_Raw(const GP_Context *src{{ maybe_opts_l(opts) }},
  79         GP_ProgressCallback *callback)
  80 {
  81         GP_DEBUG(1, "Running filter {{ name }}");
  82
  83         switch (src->pixel_type) {
  84         %% for pt in pixeltypes
  85         case GP_PIXEL_{{ pt.name }}:
  86                 %% if pt.is_unknown() or pt.pixelsize.size < 2
  87                 return 1;
  88                 %% elif len(pt.chanslist) == 1:
  89                 //TODO: BITENDIAN
  90                 return GP_Filter{{ name }}_{{ pt.pixelsize.suffix }}(src{{ maybe_opts_l(params) }}, callback);
  91                 %% else
  92                 return GP_Filter{{ name }}_{{ pt.name }}(src{{ maybe_opts_l(params) }}, callback);
  93                 %% endif
  94         %% endfor
  95         default:
  96         break;
  97         }
  98
  99         return 1;
 100 }
 101
 102 %% endmacro