src/extension/internal/filter/abc.h

   1 #ifndef __INKSCAPE_EXTENSION_INTERNAL_FILTER_ABC_H__
   2 #define __INKSCAPE_EXTENSION_INTERNAL_FILTER_ABC_H__
   3 /* Change the 'ABC' above to be your file name */
   4
   5 /*
   6  * Copyright (C) 2011 Authors:
   7  *   Ivan Louette (filters)
   8  *   Nicolas Dufour (UI) <nicoduf@yahoo.fr>
   9  *
  10  * Basic filters
  11  *   Blur
  12  *   Clean edges
  13  *   Color shift
  14  *   Diffuse light
  15  *   Feather
  16  *   Matte jelly
  17  *   Noise fill
  18  *   Outline
  19  *   Roughen
  20  *   Silhouette
  21  *   Specular light
  22  *
  23  * Released under GNU GPL, read the file 'COPYING' for more information
  24  */
  25 /* ^^^ Change the copyright to be you and your e-mail address ^^^ */
  26
  27 #include "filter.h"
  28
  29 #include "extension/internal/clear-n_.h"
  30 #include "extension/system.h"
  31 #include "extension/extension.h"
  32
  33 namespace Inkscape {
  34 namespace Extension {
  35 namespace Internal {
  36 namespace Filter {
  37
  38 /**
  39     \brief    Custom predefined Blur filter.
  40
  41     Simple horizontal and vertical blur
  42
  43     Filter's parameters:
  44     * Horizontal blur (0.01->100., default 2) -> blur (stdDeviation)
  45     * Vertical blur (0.01->100., default 2) -> blur (stdDeviation)
  46 */
  47
  48 class Blur : public Inkscape::Extension::Internal::Filter::Filter {
  49 protected:
  50     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
  51
  52 public:
  53     Blur ( ) : Filter() { };
  54     virtual ~Blur ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
  55
  56     static void init (void) {
  57         Inkscape::Extension::build_from_mem(
  58             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
  59               "<name>" N_("Blur, custom (ABCs)") "</name>\n"
  60               "<id>org.inkscape.effect.filter.Blur</id>\n"
  61               "<param name=\"hblur\" gui-text=\"" N_("Horizontal blur:") "\" type=\"float\" min=\"0.01\" max=\"100\">2</param>\n"
  62               "<param name=\"vblur\" gui-text=\"" N_("Vertical blur:") "\" type=\"float\" min=\"0.01\" max=\"100\">2</param>\n"
  63               "<effect>\n"
  64                 "<object-type>all</object-type>\n"
  65                 "<effects-menu>\n"
  66                   "<submenu name=\"" N_("Filters") "\">\n"
  67                     "<submenu name=\"" N_("Experimental") "\"/>\n"
  68                   "</submenu>\n"
  69                 "</effects-menu>\n"
  70                 "<menu-tip>" N_("Simple vertical and horizontal blur effect") "</menu-tip>\n"
  71               "</effect>\n"
  72             "</inkscape-extension>\n", new Blur());
  73     };
  74
  75 };
  76
  77 gchar const *
  78 Blur::get_filter_text (Inkscape::Extension::Extension * ext)
  79 {
  80     if (_filter != NULL) g_free((void *)_filter);
  81
  82     std::ostringstream hblur;
  83     std::ostringstream vblur;
  84
  85     hblur << ext->get_param_float("hblur");
  86     vblur << ext->get_param_float("vblur");
  87
  88     _filter = g_strdup_printf(
  89         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Blur, custom\">\n"
  90           "<feGaussianBlur stdDeviation=\"%s %s\" result=\"blur\" />\n"
  91         "</filter>\n", hblur.str().c_str(), vblur.str().c_str());
  92
  93     return _filter;
  94 }; /* Blur filter */
  95
  96 /**
  97     \brief    Custom predefined Clean edges filter.
  98
  99     Removes or decreases glows and jaggeries around objects edges after applying some filters
 100
 101     Filter's parameters:
 102     * Strength (0.01->100., default 0.4) -> blur (stdDeviation)
 103 */
 104
 105 class CleanEdges : public Inkscape::Extension::Internal::Filter::Filter {
 106 protected:
 107     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 108
 109 public:
 110     CleanEdges ( ) : Filter() { };
 111     virtual ~CleanEdges ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 112
 113     static void init (void) {
 114         Inkscape::Extension::build_from_mem(
 115             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 116               "<name>" N_("Clean edges, custom (ABCs)") "</name>\n"
 117               "<id>org.inkscape.effect.filter.CleanEdges</id>\n"
 118               "<param name=\"blur\" gui-text=\"" N_("Strength:") "\" type=\"float\" min=\"0.01\" max=\"100\">0.4</param>\n"
 119               "<effect>\n"
 120                 "<object-type>all</object-type>\n"
 121                 "<effects-menu>\n"
 122                   "<submenu name=\"" N_("Filters") "\">\n"
 123                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 124                   "</submenu>\n"
 125                 "</effects-menu>\n"
 126                 "<menu-tip>" N_("Removes or decreases glows and jaggeries around objects edges after applying some filters") "</menu-tip>\n"
 127               "</effect>\n"
 128             "</inkscape-extension>\n", new CleanEdges());
 129     };
 130
 131 };
 132
 133 gchar const *
 134 CleanEdges::get_filter_text (Inkscape::Extension::Extension * ext)
 135 {
 136     if (_filter != NULL) g_free((void *)_filter);
 137
 138     std::ostringstream blur;
 139
 140     blur << ext->get_param_float("blur");
 141
 142     _filter = g_strdup_printf(
 143         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Clean edges, custom\">\n"
 144           "<feGaussianBlur stdDeviation=\"%s\" result=\"blur\" />\n"
 145           "<feComposite in=\"SourceGraphic\" in2=\"blur\" operator=\"in\" result=\"composite1\" />\n"
 146           "<feComposite in=\"composite1\" in2=\"composite1\" k2=\"1\" operator=\"in\" result=\"composite2\" />\n"
 147         "</filter>\n", blur.str().c_str());
 148
 149     return _filter;
 150 }; /* CleanEdges filter */
 151
 152
 153 /**
 154     \brief    Custom predefined Color shift filter.
 155
 156     Rotate and desaturate hue
 157
 158     Filter's parameters:
 159     * Shift (0->360, default 330) -> color1 (values)
 160     * Saturation (0.->10., default 6) -> color2 (values [/10])
 161 */
 162
 163 class ColorShift : public Inkscape::Extension::Internal::Filter::Filter {
 164 protected:
 165     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 166
 167 public:
 168     ColorShift ( ) : Filter() { };
 169     virtual ~ColorShift ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 170
 171     static void init (void) {
 172         Inkscape::Extension::build_from_mem(
 173             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 174               "<name>" N_("Color shift, custom (ABCs)") "</name>\n"
 175               "<id>org.inkscape.effect.filter.ColorShift</id>\n"
 176               "<param name=\"shift\" gui-text=\"" N_("Shift:") "\" type=\"int\" min=\"0\" max=\"360\">330</param>\n"
 177               "<param name=\"sat\" gui-text=\"" N_("Saturation:") "\" type=\"float\" min=\"0.\" max=\"10\">6</param>\n"
 178               "<effect>\n"
 179                 "<object-type>all</object-type>\n"
 180                 "<effects-menu>\n"
 181                   "<submenu name=\"" N_("Filters") "\">\n"
 182                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 183                   "</submenu>\n"
 184                 "</effects-menu>\n"
 185                 "<menu-tip>" N_("Rotate and desaturate hue") "</menu-tip>\n"
 186               "</effect>\n"
 187             "</inkscape-extension>\n", new ColorShift());
 188     };
 189
 190 };
 191
 192 gchar const *
 193 ColorShift::get_filter_text (Inkscape::Extension::Extension * ext)
 194 {
 195     if (_filter != NULL) g_free((void *)_filter);
 196
 197     std::ostringstream shift;
 198     std::ostringstream sat;
 199
 200     shift << ext->get_param_int("shift");
 201     sat << (ext->get_param_float("sat") / 10);
 202
 203     _filter = g_strdup_printf(
 204         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" height=\"1\" width=\"1\" y=\"0\" x=\"0\" inkscape:label=\"Color shift, custom\">\n"
 205           "<feColorMatrix type=\"hueRotate\" values=\"%s\" result=\"color1\" />\n"
 206           "<feColorMatrix type=\"saturate\" values=\"%s\" result=\"color2\" />\n"
 207         "</filter>\n", shift.str().c_str(), sat.str().c_str());
 208
 209     return _filter;
 210 }; /* ColorShift filter */
 211
 212 /**
 213     \brief    Custom predefined Diffuse light filter.
 214
 215     Basic diffuse bevel to use for building textures
 216
 217     Filter's parameters:
 218     * Smoothness (0.->10., default 6.) -> blur (stdDeviation)
 219     * Elevation (0->360, default 25) -> feDistantLight (elevation)
 220     * Azimuth (0->360, default 235) -> feDistantLight (azimuth)
 221     * Lightning color (guint, default -1 [white]) -> diffuse (lighting-color)
 222 */
 223
 224 class DiffuseLight : public Inkscape::Extension::Internal::Filter::Filter {
 225 protected:
 226     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 227
 228 public:
 229     DiffuseLight ( ) : Filter() { };
 230     virtual ~DiffuseLight ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 231
 232     static void init (void) {
 233         Inkscape::Extension::build_from_mem(
 234             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 235               "<name>" N_("Diffuse light, custom (ABCs)") "</name>\n"
 236               "<id>org.inkscape.effect.filter.DiffuseLight</id>\n"
 237               "<param name=\"smooth\" gui-text=\"" N_("Smoothness:") "\" type=\"float\" min=\"0.0\" max=\"10\">6</param>\n"
 238               "<param name=\"elevation\" gui-text=\"" N_("Elevation:") "\" type=\"int\" min=\"0\" max=\"360\">25</param>\n"
 239               "<param name=\"azimuth\" gui-text=\"" N_("Azimuth:") "\" type=\"int\" min=\"0\" max=\"360\">235</param>\n"
 240               "<param name=\"color\" gui-text=\"" N_("Lightning color") "\" type=\"color\">-1</param>\n"
 241               "<effect>\n"
 242                 "<object-type>all</object-type>\n"
 243                 "<effects-menu>\n"
 244                   "<submenu name=\"" N_("Filters") "\">\n"
 245                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 246                   "</submenu>\n"
 247                 "</effects-menu>\n"
 248                 "<menu-tip>" N_("Basic diffuse bevel to use for building textures") "</menu-tip>\n"
 249               "</effect>\n"
 250             "</inkscape-extension>\n", new DiffuseLight());
 251     };
 252
 253 };
 254
 255 gchar const *
 256 DiffuseLight::get_filter_text (Inkscape::Extension::Extension * ext)
 257 {
 258     if (_filter != NULL) g_free((void *)_filter);
 259
 260     std::ostringstream smooth;
 261     std::ostringstream elevation;
 262     std::ostringstream azimuth;
 263     std::ostringstream r;
 264     std::ostringstream g;
 265     std::ostringstream b;
 266     std::ostringstream a;
 267
 268     smooth << ext->get_param_float("smooth");
 269     elevation << ext->get_param_int("elevation");
 270     azimuth << ext->get_param_int("azimuth");
 271     guint32 color = ext->get_param_color("color");
 272
 273     r << ((color >> 24) & 0xff);
 274     g << ((color >> 16) & 0xff);
 275     b << ((color >>  8) & 0xff);
 276     a << (color & 0xff) / 255.0F;
 277
 278     _filter = g_strdup_printf(
 279         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Diffuse light, custom\">\n"
 280           "<feGaussianBlur in=\"SourceGraphic\" stdDeviation=\"%s\" result=\"blur\" />\n"
 281           "<feDiffuseLighting diffuseConstant=\"1\" surfaceScale=\"10\" lighting-color=\"rgb(%s,%s,%s)\" result=\"diffuse\">\n"
 282             "<feDistantLight elevation=\"%s\" azimuth=\"%s\" />\n"
 283           "</feDiffuseLighting>\n"
 284           "<feComposite in=\"diffuse\" in2=\"diffuse\" operator=\"arithmetic\" k1=\"1\" result=\"composite1\" />\n"
 285           "<feComposite in=\"composite1\" in2=\"SourceGraphic\" k1=\"%s\" operator=\"arithmetic\" k3=\"1\" result=\"composite2\" />\n"
 286         "</filter>\n", smooth.str().c_str(), r.str().c_str(), g.str().c_str(), b.str().c_str(), elevation.str().c_str(), azimuth.str().c_str(), a.str().c_str());
 287
 288     return _filter;
 289 }; /* DiffuseLight filter */
 290
 291 /**
 292     \brief    Custom predefined Feather filter.
 293
 294     Blurred mask on the edge without altering the contents
 295
 296     Filter's parameters:
 297     * Strength (0.01->100., default 5) -> blur (stdDeviation)
 298 */
 299
 300 class Feather : public Inkscape::Extension::Internal::Filter::Filter {
 301 protected:
 302     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 303
 304 public:
 305     Feather ( ) : Filter() { };
 306     virtual ~Feather ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 307
 308     static void init (void) {
 309         Inkscape::Extension::build_from_mem(
 310             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 311               "<name>" N_("Feather, custom (ABCs)") "</name>\n"
 312               "<id>org.inkscape.effect.filter.Feather</id>\n"
 313               "<param name=\"blur\" gui-text=\"" N_("Strength:") "\" type=\"float\" min=\"0.01\" max=\"100\">5</param>\n"
 314               "<effect>\n"
 315                 "<object-type>all</object-type>\n"
 316                 "<effects-menu>\n"
 317                   "<submenu name=\"" N_("Filters") "\">\n"
 318                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 319                   "</submenu>\n"
 320                 "</effects-menu>\n"
 321                 "<menu-tip>" N_("Blurred mask on the edge without altering the contents") "</menu-tip>\n"
 322               "</effect>\n"
 323             "</inkscape-extension>\n", new Feather());
 324     };
 325
 326 };
 327
 328 gchar const *
 329 Feather::get_filter_text (Inkscape::Extension::Extension * ext)
 330 {
 331     if (_filter != NULL) g_free((void *)_filter);
 332
 333     std::ostringstream blur;
 334
 335     blur << ext->get_param_float("blur");
 336
 337     _filter = g_strdup_printf(
 338         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Black outline, custom\">\n"
 339           "<feGaussianBlur stdDeviation=\"%s\" result=\"blur\" />\n"
 340           "<feComposite in=\"SourceGraphic\" in2=\"blur\" operator=\"atop\" result=\"composite1\" />\n"
 341           "<feComposite in2=\"composite1\" operator=\"in\" result=\"composite2\" />\n"
 342           "<feComposite in2=\"composite2\" operator=\"in\" result=\"composite3\" />\n"
 343         "</filter>\n", blur.str().c_str());
 344
 345     return _filter;
 346 }; /* Feather filter */
 347
 348 /**
 349     \brief    Custom predefined Matte jelly filter.
 350
 351     Bulging, matte jelly covering
 352
 353     Filter's parameters:
 354     * Smoothness (0.0->10., default 7.) -> blur (stdDeviation)
 355     * Brightness (0.0->5., default .9) -> specular (specularConstant)
 356     * Elevation (0->360, default 60) -> feDistantLight (elevation)
 357     * Azimuth (0->360, default 225) -> feDistantLight (azimuth)
 358     * Lightning color (guint, default -1 [white]) -> specular (lighting-color)
 359 */
 360
 361 class MatteJelly : public Inkscape::Extension::Internal::Filter::Filter {
 362 protected:
 363     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 364
 365 public:
 366     MatteJelly ( ) : Filter() { };
 367     virtual ~MatteJelly ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 368
 369     static void init (void) {
 370         Inkscape::Extension::build_from_mem(
 371             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 372               "<name>" N_("Matte jelly, custom (ABCs)") "</name>\n"
 373               "<id>org.inkscape.effect.filter.MatteJelly</id>\n"
 374               "<param name=\"smooth\" gui-text=\"" N_("Smoothness:") "\" type=\"float\" min=\"0.0\" max=\"10\">7</param>\n"
 375               "<param name=\"bright\" gui-text=\"" N_("Brightness:") "\" type=\"float\" min=\"0.0\" max=\"5\">0.9</param>\n"
 376               "<param name=\"elevation\" gui-text=\"" N_("Elevation:") "\" type=\"int\" min=\"0\" max=\"360\">60</param>\n"
 377               "<param name=\"azimuth\" gui-text=\"" N_("Azimuth:") "\" type=\"int\" min=\"0\" max=\"360\">225</param>\n"
 378               "<param name=\"color\" gui-text=\"" N_("Lightning color") "\" type=\"color\">-1</param>\n"
 379               "<effect>\n"
 380                 "<object-type>all</object-type>\n"
 381                 "<effects-menu>\n"
 382                   "<submenu name=\"" N_("Filters") "\">\n"
 383                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 384                   "</submenu>\n"
 385                 "</effects-menu>\n"
 386                 "<menu-tip>" N_("Bulging, matte jelly covering") "</menu-tip>\n"
 387               "</effect>\n"
 388             "</inkscape-extension>\n", new MatteJelly());
 389     };
 390
 391 };
 392
 393 gchar const *
 394 MatteJelly::get_filter_text (Inkscape::Extension::Extension * ext)
 395 {
 396     if (_filter != NULL) g_free((void *)_filter);
 397
 398     std::ostringstream smooth;
 399     std::ostringstream bright;
 400     std::ostringstream elevation;
 401     std::ostringstream azimuth;
 402     std::ostringstream r;
 403     std::ostringstream g;
 404     std::ostringstream b;
 405     std::ostringstream a;
 406
 407     smooth << ext->get_param_float("smooth");
 408     bright << ext->get_param_float("bright");
 409     elevation << ext->get_param_int("elevation");
 410     azimuth << ext->get_param_int("azimuth");
 411     guint32 color = ext->get_param_color("color");
 412
 413     r << ((color >> 24) & 0xff);
 414     g << ((color >> 16) & 0xff);
 415     b << ((color >>  8) & 0xff);
 416     a << (color & 0xff) / 255.0F;
 417
 418     _filter = g_strdup_printf(
 419         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Matte jelly, custom\">\n"
 420           "<feColorMatrix values=\"1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0.85 0\" result=\"color\" in=\"SourceGraphic\" />\n"
 421           "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"%s\" result=\"blur\" />\n"
 422           "<feSpecularLighting in=\"blur\" specularExponent=\"25\" specularConstant=\"%s\" surfaceScale=\"5\" lighting-color=\"rgb(%s,%s,%s)\" result=\"specular\">\n"
 423             "<feDistantLight elevation=\"%s\" azimuth=\"%s\" />\n"
 424           "</feSpecularLighting>\n"
 425           "<feComposite in=\"specular\" in2=\"SourceGraphic\" k3=\"1\" k2=\"%s\" operator=\"arithmetic\" result=\"composite1\" />\n"
 426           "<feComposite in=\"composite1\" in2=\"color\" operator=\"atop\" result=\"composite2\" />\n"
 427         "</filter>\n", smooth.str().c_str(), bright.str().c_str(), r.str().c_str(), g.str().c_str(), b.str().c_str(), elevation.str().c_str(), azimuth.str().c_str(), a.str().c_str());
 428
 429     return _filter;
 430 }; /* MatteJelly filter */
 431
 432 /**
 433     \brief    Custom predefined Noise fill filter.
 434
 435     Basic noise fill and transparency texture
 436
 437     Filter's parameters:
 438     * Turbulence type (enum, default fractalNoise else turbulence) -> turbulence (type)
 439     * Horizontal frequency (*100) (0.001->1000., default 2) -> turbulence (baseFrequency [/100])
 440     * Vertical frequency (*100) (0.001->1000., default 4) -> turbulence (baseFrequency [/100])
 441     * Complexity (1->5, default 5) -> turbulence (numOctaves)
 442     * Variation (1->360, default 1) -> turbulence (seed)
 443     * Dilatation (1.->50., default 3) -> color (n-1th value)
 444     * Erosion (0.->50., default 1) -> color (nth value 0->-50)
 445     * Color (guint, default 148,115,39,255) -> flood (flood-color, flood-opacity)
 446     * Inverted (boolean, default false)  -> composite1 (operator, true="in", false="out")
 447 */
 448
 449 class NoiseFill : public Inkscape::Extension::Internal::Filter::Filter {
 450 protected:
 451     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 452
 453 public:
 454     NoiseFill ( ) : Filter() { };
 455     virtual ~NoiseFill ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 456
 457     static void init (void) {
 458         Inkscape::Extension::build_from_mem(
 459             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 460               "<name>" N_("Noise fill, custom (ABCs)") "</name>\n"
 461               "<id>org.inkscape.effect.filter.NoiseFill</id>\n"
 462               "<param name=\"tab\" type=\"notebook\">\n"
 463                 "<page name=\"optionstab\" _gui-text=\"Options\">\n"
 464                   "<param name=\"type\" gui-text=\"" N_("Turbulence type:") "\" type=\"enum\">\n"
 465                     "<_item value=\"fractalNoise\">Fractal noise</_item>\n"
 466                     "<_item value=\"turbulence\">Turbulence</_item>\n"
 467                   "</param>\n"
 468                   "<param name=\"hfreq\" gui-text=\"" N_("Horizontal frequency (x100):") "\" type=\"float\" min=\"0.001\" max=\"1000\">2</param>\n"
 469                   "<param name=\"vfreq\" gui-text=\"" N_("Vertical frequency (x100):") "\" type=\"float\" min=\"0.001\" max=\"1000\">4</param>\n"
 470                   "<param name=\"complexity\" gui-text=\"" N_("Complexity:") "\" type=\"int\" min=\"1\" max=\"5\">5</param>\n"
 471                   "<param name=\"variation\" gui-text=\"" N_("Variation:") "\" type=\"int\" min=\"1\" max=\"360\">0</param>\n"
 472                   "<param name=\"dilat\" gui-text=\"" N_("Dilatation:") "\" type=\"float\" min=\"1\" max=\"50\">3</param>\n"
 473                   "<param name=\"erosion\" gui-text=\"" N_("Erosion:") "\" type=\"float\" min=\"0\" max=\"50\">1</param>\n"
 474                   "<param name=\"inverted\" gui-text=\"" N_("Inverted") "\" type=\"boolean\" >false</param>\n"
 475                 "</page>\n"
 476                 "<page name=\"co11tab\" _gui-text=\"Noise color\">\n"
 477                   "<param name=\"color\" gui-text=\"" N_("Color") "\" type=\"color\">354957823</param>\n"
 478                 "</page>\n"
 479               "</param>\n"
 480               "<effect>\n"
 481                 "<object-type>all</object-type>\n"
 482                 "<effects-menu>\n"
 483                   "<submenu name=\"" N_("Filters") "\">\n"
 484                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 485                   "</submenu>\n"
 486                 "</effects-menu>\n"
 487                 "<menu-tip>" N_("Basic noise fill and transparency texture") "</menu-tip>\n"
 488               "</effect>\n"
 489             "</inkscape-extension>\n", new NoiseFill());
 490     };
 491
 492 };
 493
 494 gchar const *
 495 NoiseFill::get_filter_text (Inkscape::Extension::Extension * ext)
 496 {
 497     if (_filter != NULL) g_free((void *)_filter);
 498
 499     std::ostringstream type;
 500     std::ostringstream hfreq;
 501     std::ostringstream vfreq;
 502     std::ostringstream complexity;
 503     std::ostringstream variation;
 504     std::ostringstream dilat;
 505     std::ostringstream erosion;
 506     std::ostringstream r;
 507     std::ostringstream g;
 508     std::ostringstream b;
 509     std::ostringstream a;
 510     std::ostringstream inverted;
 511
 512     type << ext->get_param_enum("type");
 513     hfreq << (ext->get_param_float("hfreq") / 100);
 514     vfreq << (ext->get_param_float("vfreq") / 100);
 515     complexity << ext->get_param_int("complexity");
 516     variation << ext->get_param_int("variation");
 517     dilat << ext->get_param_float("dilat");
 518     erosion << (- ext->get_param_float("erosion"));
 519     guint32 color = ext->get_param_color("color");
 520     r << ((color >> 24) & 0xff);
 521     g << ((color >> 16) & 0xff);
 522     b << ((color >>  8) & 0xff);
 523     a << (color & 0xff) / 255.0F;
 524     if (ext->get_param_bool("inverted"))
 525         inverted << "out";
 526     else
 527         inverted << "in";
 528
 529     _filter = g_strdup_printf(
 530         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Noise fill, custom\">\n"
 531           "<feTurbulence type=\"%s\" baseFrequency=\"%s %s\" numOctaves=\"%s\" seed=\"%s\" result=\"turbulence\"/>\n"
 532           "<feComposite in=\"SourceGraphic\" in2=\"turbulence\" operator=\"%s\" result=\"composite1\" />\n"
 533           "<feColorMatrix values=\"1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 %s %s \" result=\"color\" />\n"
 534           "<feFlood in=\"color\" flood-opacity=\"%s\" flood-color=\"rgb(%s,%s,%s)\" result=\"flood\" />\n"
 535           "<feMerge result=\"merge\">\n"
 536             "<feMergeNode in=\"flood\" />\n"
 537             "<feMergeNode in=\"color\" />\n"
 538           "</feMerge>\n"
 539           "<feComposite in2=\"SourceGraphic\" operator=\"in\" result=\"composite2\" />\n"
 540         "</filter>\n", type.str().c_str(), hfreq.str().c_str(), vfreq.str().c_str(), complexity.str().c_str(), variation.str().c_str(), inverted.str().c_str(), dilat.str().c_str(), erosion.str().c_str(), a.str().c_str(), r.str().c_str(), g.str().c_str(), b.str().c_str());
 541
 542     return _filter;
 543 }; /* NoiseFill filter */
 544
 545 /**
 546     \brief    Custom predefined Outline filter.
 547
 548     Adds a colorizable outline
 549
 550     Filter's parameters:
 551     * Width (0.01->50., default 5) -> blur1 (stdDeviation)
 552     * Melt (0.01->50., default 2) -> blur2 (stdDeviation)
 553     * Dilatation (1.->50., default 8) -> color2 (n-1th value)
 554     * Erosion (0.->50., default 5) -> color2 (nth value 0->-50)
 555     * Color (guint, default 156,102,102,255) -> flood (flood-color, flood-opacity)
 556     * Blend (enum, default Normal) -> blend (mode)
 557 */
 558
 559 class Outline : public Inkscape::Extension::Internal::Filter::Filter {
 560 protected:
 561     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 562
 563 public:
 564     Outline ( ) : Filter() { };
 565     virtual ~Outline ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 566
 567     static void init (void) {
 568         Inkscape::Extension::build_from_mem(
 569             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 570               "<name>" N_("Outline, custom (ABCs)") "</name>\n"
 571               "<id>org.inkscape.effect.filter.Outline</id>\n"
 572               "<param name=\"tab\" type=\"notebook\">\n"
 573                 "<page name=\"optionstab\" _gui-text=\"Options\">\n"
 574                   "<param name=\"width\" gui-text=\"" N_("Width:") "\" type=\"float\" min=\"0.01\" max=\"50\">5</param>\n"
 575                   "<param name=\"melt\" gui-text=\"" N_("Melt:") "\" type=\"float\" min=\"0.01\" max=\"50\">2</param>\n"
 576                   "<param name=\"dilat\" gui-text=\"" N_("Dilatation:") "\" type=\"float\" min=\"1\" max=\"50\">8</param>\n"
 577                   "<param name=\"erosion\" gui-text=\"" N_("Erosion:") "\" type=\"float\" min=\"0\" max=\"50\">5</param>\n"
 578                 "</page>\n"
 579                 "<page name=\"co11tab\" _gui-text=\"Color\">\n"
 580                   "<param name=\"color\" gui-text=\"" N_("Color") "\" type=\"color\">1029214207</param>\n"
 581                 "</page>\n"
 582               "</param>\n"
 583               "<effect>\n"
 584                 "<object-type>all</object-type>\n"
 585                 "<effects-menu>\n"
 586                   "<submenu name=\"" N_("Filters") "\">\n"
 587                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 588                   "</submenu>\n"
 589                 "</effects-menu>\n"
 590                 "<menu-tip>" N_("Adds a colorizable outline") "</menu-tip>\n"
 591               "</effect>\n"
 592             "</inkscape-extension>\n", new Outline());
 593     };
 594
 595 };
 596
 597 gchar const *
 598 Outline::get_filter_text (Inkscape::Extension::Extension * ext)
 599 {
 600     if (_filter != NULL) g_free((void *)_filter);
 601
 602     std::ostringstream width;
 603     std::ostringstream melt;
 604     std::ostringstream dilat;
 605     std::ostringstream erosion;
 606     std::ostringstream r;
 607     std::ostringstream g;
 608     std::ostringstream b;
 609     std::ostringstream a;
 610     std::ostringstream blend;
 611
 612     width << ext->get_param_float("width");
 613     melt << ext->get_param_float("melt");
 614     dilat << ext->get_param_float("dilat");
 615     erosion << (- ext->get_param_float("erosion"));
 616     guint32 color = ext->get_param_color("color");
 617     r << ((color >> 24) & 0xff);
 618     g << ((color >> 16) & 0xff);
 619     b << ((color >>  8) & 0xff);
 620     a << (color & 0xff) / 255.0F;
 621
 622     _filter = g_strdup_printf(
 623         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" height=\"1.3\" width=\"1.3\" y=\"-0.15\" x=\"-0.15\" inkscape:label=\"Outline, custom\">\n"
 624           "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"%s\" result=\"blur1\" />\n"
 625           "<feColorMatrix result=\"color1\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 200 -1 \" />\n"
 626           "<feGaussianBlur in=\"color1\" stdDeviation=\"%s\" result=\"blur2\" />\n"
 627           "<feColorMatrix values=\"1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 %s %s \" result=\"color2\" />\n"
 628           "<feFlood in=\"color2\" result=\"flood\" flood-opacity=\"%s\" flood-color=\"rgb(%s,%s,%s)\" />\n"
 629           "<feComposite in=\"flood\" in2=\"color2\" operator=\"in\" result=\"composite\" />\n"
 630           "<feBlend in=\"SourceGraphic\" in2=\"composite\" mode=\"normal\" blend=\"normal\" />\n"
 631         "</filter>\n", width.str().c_str(), melt.str().c_str(), dilat.str().c_str(), erosion.str().c_str(), a.str().c_str(), r.str().c_str(), g.str().c_str(), b.str().c_str());
 632
 633     return _filter;
 634 }; /* Outline filter */
 635
 636 /**
 637     \brief    Custom predefined Roughen filter.
 638
 639     Small-scale roughening to edges and content
 640
 641     Filter's parameters:
 642     * Turbulence type (enum, default fractalNoise else turbulence) -> turbulence (type)
 643     * Horizontal frequency (*100) (0.001->1000., default 1.3) -> turbulence (baseFrequency)
 644     * Vertical frequency (*100) (0.001->1000., default 1.3) -> turbulence (baseFrequency)
 645     * Complexity (1->5, default 5) -> turbulence (numOctaves)
 646     * Variation (1->360, default 1) -> turbulence (seed)
 647     * Intensity (0.0->50., default 6.6) -> displacement (scale)
 648 */
 649
 650 class Roughen : public Inkscape::Extension::Internal::Filter::Filter {
 651 protected:
 652     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 653
 654 public:
 655     Roughen ( ) : Filter() { };
 656     virtual ~Roughen ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 657
 658     static void init (void) {
 659         Inkscape::Extension::build_from_mem(
 660             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 661               "<name>" N_("Roughen, custom (ABCs)") "</name>\n"
 662               "<id>org.inkscape.effect.filter.Roughen</id>\n"
 663               "<param name=\"type\" gui-text=\"" N_("Turbulence type:") "\" type=\"enum\">\n"
 664                 "<_item value=\"fractalNoise\">Fractal noise</_item>\n"
 665                 "<_item value=\"turbulence\">Turbulence</_item>\n"
 666               "</param>\n"
 667               "<param name=\"hfreq\" gui-text=\"" N_("Horizontal frequency (x100):") "\" type=\"float\" min=\"0.001\" max=\"1000\">1.3</param>\n"
 668               "<param name=\"vfreq\" gui-text=\"" N_("Vertical frequency (x100):") "\" type=\"float\" min=\"0.001\" max=\"1000\">1.3</param>\n"
 669               "<param name=\"complexity\" gui-text=\"" N_("Complexity:") "\" type=\"int\" min=\"1\" max=\"5\">5</param>\n"
 670               "<param name=\"variation\" gui-text=\"" N_("Variation:") "\" type=\"int\" min=\"1\" max=\"360\">0</param>\n"
 671               "<param name=\"intensity\" gui-text=\"" N_("Intensity:") "\" type=\"float\" min=\"0.0\" max=\"50\">6.6</param>\n"
 672               "<effect>\n"
 673                 "<object-type>all</object-type>\n"
 674                 "<effects-menu>\n"
 675                   "<submenu name=\"" N_("Filters") "\">\n"
 676                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 677                   "</submenu>\n"
 678                 "</effects-menu>\n"
 679                 "<menu-tip>" N_("Small-scale roughening to edges and content") "</menu-tip>\n"
 680               "</effect>\n"
 681             "</inkscape-extension>\n", new Roughen());
 682     };
 683
 684 };
 685
 686 gchar const *
 687 Roughen::get_filter_text (Inkscape::Extension::Extension * ext)
 688 {
 689     if (_filter != NULL) g_free((void *)_filter);
 690
 691     std::ostringstream type;
 692     std::ostringstream hfreq;
 693     std::ostringstream vfreq;
 694     std::ostringstream complexity;
 695     std::ostringstream variation;
 696     std::ostringstream intensity;
 697
 698     type << ext->get_param_enum("type");
 699     hfreq << (ext->get_param_float("hfreq") / 100);
 700     vfreq << (ext->get_param_float("vfreq") / 100);
 701     complexity << ext->get_param_int("complexity");
 702     variation << ext->get_param_int("variation");
 703     intensity << ext->get_param_float("intensity");
 704
 705     _filter = g_strdup_printf(
 706         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Roughen, custom\">\n"
 707           "<feTurbulence  type=\"%s\" numOctaves=\"%s\" seed=\"%s\" baseFrequency=\"%s %s\" result=\"turbulence\" />\n"
 708           "<feDisplacementMap in=\"SourceGraphic\" in2=\"turbulence\" scale=\"%s\" yChannelSelector=\"G\" xChannelSelector=\"R\" />\n"
 709         "</filter>\n", type.str().c_str(), complexity.str().c_str(), variation.str().c_str(), hfreq.str().c_str(), vfreq.str().c_str(), intensity.str().c_str());
 710
 711     return _filter;
 712 }; /* Roughen filter */
 713
 714 /**
 715     \brief    Custom predefined Silhouette filter.
 716
 717     Repaint anything visible monochrome
 718
 719     Filter's parameters:
 720     * Blur (0.01->50., default 0.01) -> blur (stdDeviation)
 721     * Cutout (boolean, default False) -> composite (false=in, true=out)
 722     * Color (guint, default 0,0,0,255) -> flood (flood-color, flood-opacity)
 723 */
 724
 725 class Silhouette : public Inkscape::Extension::Internal::Filter::Filter {
 726 protected:
 727     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 728
 729 public:
 730     Silhouette ( ) : Filter() { };
 731     virtual ~Silhouette ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 732
 733     static void init (void) {
 734         Inkscape::Extension::build_from_mem(
 735             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 736               "<name>" N_("Silhouette, custom (ABCs)") "</name>\n"
 737               "<id>org.inkscape.effect.filter.Silhouette</id>\n"
 738               "<param name=\"blur\" gui-text=\"" N_("Blur:") "\" type=\"float\" min=\"0.01\" max=\"50\">0.01</param>\n"
 739               "<param name=\"cutout\" gui-text=\"" N_("Cutout") "\" type=\"boolean\">false</param>\n"
 740               "<param name=\"color\" gui-text=\"" N_("Color") "\" type=\"color\">255</param>\n"
 741               "<effect>\n"
 742                 "<object-type>all</object-type>\n"
 743                 "<effects-menu>\n"
 744                   "<submenu name=\"" N_("Filters") "\">\n"
 745                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 746                   "</submenu>\n"
 747                 "</effects-menu>\n"
 748                 "<menu-tip>" N_("Repaint anything visible monochrome") "</menu-tip>\n"
 749               "</effect>\n"
 750             "</inkscape-extension>\n", new Silhouette());
 751     };
 752
 753 };
 754
 755 gchar const *
 756 Silhouette::get_filter_text (Inkscape::Extension::Extension * ext)
 757 {
 758     if (_filter != NULL) g_free((void *)_filter);
 759
 760     std::ostringstream a;
 761     std::ostringstream r;
 762     std::ostringstream g;
 763     std::ostringstream b;
 764     std::ostringstream cutout;
 765     std::ostringstream blur;
 766
 767     guint32 color = ext->get_param_color("color");
 768     r << ((color >> 24) & 0xff);
 769     g << ((color >> 16) & 0xff);
 770     b << ((color >>  8) & 0xff);
 771     a << (color & 0xff) / 255.0F;
 772     if (ext->get_param_bool("cutout"))
 773         cutout << "out";
 774     else
 775         cutout << "in";
 776     blur << ext->get_param_float("blur");
 777
 778     _filter = g_strdup_printf(
 779         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Silhouette, custom\">\n"
 780           "<feFlood in=\"SourceGraphic\" flood-opacity=\"%s\" flood-color=\"rgb(%s,%s,%s)\" result=\"flood\" />\n"
 781           "<feComposite in=\"flood\" in2=\"SourceGraphic\" operator=\"%s\" result=\"composite\" />\n"
 782           "<feGaussianBlur stdDeviation=\"%s\" />\n"
 783         "</filter>\n", a.str().c_str(), r.str().c_str(), g.str().c_str(), b.str().c_str(), cutout.str().c_str(), blur.str().c_str());
 784
 785     return _filter;
 786 }; /* Silhouette filter */
 787
 788 /**
 789     \brief    Custom predefined Specular light filter.
 790
 791     Basic specular bevel to use for building textures
 792
 793     Filter's parameters:
 794     * Smoothness (0.0->10., default 6.) -> blur (stdDeviation)
 795     * Brightness (0.0->5., default 1.) -> specular (specularConstant)
 796     * Elevation (0->360, default 45) -> feDistantLight (elevation)
 797     * Azimuth (0->360, default 235) -> feDistantLight (azimuth)
 798     * Lightning color (guint, default -1 [white]) -> specular (lighting-color)
 799 */
 800
 801 class SpecularLight : public Inkscape::Extension::Internal::Filter::Filter {
 802 protected:
 803     virtual gchar const * get_filter_text (Inkscape::Extension::Extension * ext);
 804
 805 public:
 806     SpecularLight ( ) : Filter() { };
 807     virtual ~SpecularLight ( ) { if (_filter != NULL) g_free((void *)_filter); return; }
 808
 809     static void init (void) {
 810         Inkscape::Extension::build_from_mem(
 811             "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 812               "<name>" N_("Specular light, custom (ABCs)") "</name>\n"
 813               "<id>org.inkscape.effect.filter.SpecularLight</id>\n"
 814               "<param name=\"smooth\" gui-text=\"" N_("Smoothness:") "\" type=\"float\" min=\"0.0\" max=\"10\">6</param>\n"
 815               "<param name=\"bright\" gui-text=\"" N_("Brightness:") "\" type=\"float\" min=\"0.0\" max=\"5\">1</param>\n"
 816               "<param name=\"elevation\" gui-text=\"" N_("Elevation:") "\" type=\"int\" min=\"0\" max=\"360\">45</param>\n"
 817               "<param name=\"azimuth\" gui-text=\"" N_("Azimuth:") "\" type=\"int\" min=\"0\" max=\"360\">235</param>\n"
 818               "<param name=\"color\" gui-text=\"" N_("Lightning color") "\" type=\"color\">-1</param>\n"
 819               "<effect>\n"
 820                 "<object-type>all</object-type>\n"
 821                 "<effects-menu>\n"
 822                   "<submenu name=\"" N_("Filters") "\">\n"
 823                     "<submenu name=\"" N_("Experimental") "\"/>\n"
 824                   "</submenu>\n"
 825                 "</effects-menu>\n"
 826                 "<menu-tip>" N_("Basic specular bevel to use for building textures") "</menu-tip>\n"
 827               "</effect>\n"
 828             "</inkscape-extension>\n", new SpecularLight());
 829     };
 830
 831 };
 832
 833 gchar const *
 834 SpecularLight::get_filter_text (Inkscape::Extension::Extension * ext)
 835 {
 836     if (_filter != NULL) g_free((void *)_filter);
 837
 838     std::ostringstream smooth;
 839     std::ostringstream bright;
 840     std::ostringstream elevation;
 841     std::ostringstream azimuth;
 842     std::ostringstream r;
 843     std::ostringstream g;
 844     std::ostringstream b;
 845     std::ostringstream a;
 846
 847     smooth << ext->get_param_float("smooth");
 848     bright << ext->get_param_float("bright");
 849     elevation << ext->get_param_int("elevation");
 850     azimuth << ext->get_param_int("azimuth");
 851     guint32 color = ext->get_param_color("color");
 852
 853     r << ((color >> 24) & 0xff);
 854     g << ((color >> 16) & 0xff);
 855     b << ((color >>  8) & 0xff);
 856     a << (color & 0xff) / 255.0F;
 857
 858     _filter = g_strdup_printf(
 859         "<filter xmlns:inkscape=\"http://www.inkscape.org/namespaces/inkscape\" color-interpolation-filters=\"sRGB\" inkscape:label=\"Specular light, custom\">\n"
 860           "<feGaussianBlur in=\"SourceAlpha\" stdDeviation=\"%s\" result=\"blur\" />\n"
 861           "<feSpecularLighting in=\"blur\" specularExponent=\"25\" specularConstant=\"%s\" surfaceScale=\"10\" lighting-color=\"rgb(%s,%s,%s)\" result=\"specular\">\n"
 862             "<feDistantLight elevation=\"%s\" azimuth=\"%s\" />\n"
 863           "</feSpecularLighting>\n"
 864           "<feComposite in=\"specular\" in2=\"SourceGraphic\" k3=\"1\" k2=\"%s\" operator=\"arithmetic\" result=\"composite1\" />\n"
 865           "<feComposite in=\"composite1\" in2=\"SourceAlpha\" operator=\"in\" result=\"composite2\" />\n"
 866         "</filter>\n", smooth.str().c_str(), bright.str().c_str(), r.str().c_str(), g.str().c_str(), b.str().c_str(), elevation.str().c_str(), azimuth.str().c_str(), a.str().c_str());
 867
 868     return _filter;
 869 }; /* SpecularLight filter */
 870
 871
 872 }; /* namespace Filter */
 873 }; /* namespace Internal */
 874 }; /* namespace Extension */
 875 }; /* namespace Inkscape */
 876
 877 /* Change the 'ABC' below to be your file name */
 878 #endif /* __INKSCAPE_EXTENSION_INTERNAL_FILTER_ABC_H__ */