1 #define __SP_FILTER_CHEMISTRY_C__
3 /*
4 * Various utility methods for filters
5 *
6 * Authors:
7 * Hugo Rodrigues
8 * bulia byak
9 * Niko Kiirala
10 *
11 * Copyright (C) 2006-2008 authors
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
17 #include "style.h"
18 #include "document-private.h"
19 #include "desktop-style.h"
21 #include "filter-chemistry.h"
22 #include "filter-enums.h"
24 #include "filters/blend.h"
25 #include "sp-filter.h"
26 #include "sp-filter-reference.h"
27 #include "sp-gaussian-blur.h"
28 #include "svg/css-ostringstream.h"
29 #include "libnr/nr-matrix-fns.h"
31 #include "xml/repr.h"
33 /**
34 * Count how many times the filter is used by the styles of o and its
35 * descendants
36 */
37 static guint
38 count_filter_hrefs(SPObject *o, SPFilter *filter)
39 {
40 if (!o)
41 return 1;
43 guint i = 0;
45 SPStyle *style = SP_OBJECT_STYLE(o);
46 if (style
47 && style->filter.set
48 && style->getFilter() == filter)
49 {
50 i ++;
51 }
53 for (SPObject *child = sp_object_first_child(o);
54 child != NULL; child = SP_OBJECT_NEXT(child)) {
55 i += count_filter_hrefs(child, filter);
56 }
58 return i;
59 }
61 /**
62 * Sets a suitable filter effects area according to given blur radius,
63 * expansion and object size.
64 */
65 static void set_filter_area(Inkscape::XML::Node *repr, gdouble radius,
66 double expansion, double expansionX,
67 double expansionY, double width, double height)
68 {
69 // TODO: make this more generic, now assumed, that only the blur
70 // being added can affect the required filter area
72 double rx = radius * (expansionY != 0 ? (expansion / expansionY) : 1);
73 double ry = radius * (expansionX != 0 ? (expansion / expansionX) : 1);
75 if (width != 0 && height != 0 && (2.4 * rx > width * 0.1 || 2.4 * ry > height * 0.1)) {
76 // If not within the default 10% margin (see
77 // http://www.w3.org/TR/SVG11/filters.html#FilterEffectsRegion), specify margins
78 // The 2.4 is an empirical coefficient: at that distance the cutoff is practically invisible
79 // (the opacity at 2.4*radius is about 3e-3)
80 double xmargin = 2.4 * (rx) / width;
81 double ymargin = 2.4 * (ry) / height;
83 // TODO: set it in UserSpaceOnUse instead?
84 sp_repr_set_svg_double(repr, "x", -xmargin);
85 sp_repr_set_svg_double(repr, "width", 1 + 2 * xmargin);
86 sp_repr_set_svg_double(repr, "y", -ymargin);
87 sp_repr_set_svg_double(repr, "height", 1 + 2 * ymargin);
88 }
89 }
91 SPFilter *new_filter(SPDocument *document)
92 {
93 g_return_val_if_fail(document != NULL, NULL);
95 SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
97 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
99 // create a new filter
100 Inkscape::XML::Node *repr;
101 repr = xml_doc->createElement("svg:filter");
103 // Append the new filter node to defs
104 SP_OBJECT_REPR(defs)->appendChild(repr);
105 Inkscape::GC::release(repr);
107 // get corresponding object
108 SPFilter *f = SP_FILTER( document->getObjectByRepr(repr) );
111 g_assert(f != NULL);
112 g_assert(SP_IS_FILTER(f));
114 return f;
115 }
117 SPFilterPrimitive *
118 filter_add_primitive(SPFilter *filter, const Inkscape::Filters::FilterPrimitiveType type)
119 {
120 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(filter->document);
122 //create filter primitive node
123 Inkscape::XML::Node *repr;
124 repr = xml_doc->createElement(FPConverter.get_key(type).c_str());
126 // set default values
127 switch(type) {
128 case Inkscape::Filters::NR_FILTER_BLEND:
129 repr->setAttribute("blend", "normal");
130 break;
131 case Inkscape::Filters::NR_FILTER_COLORMATRIX:
132 break;
133 case Inkscape::Filters::NR_FILTER_COMPONENTTRANSFER:
134 break;
135 case Inkscape::Filters::NR_FILTER_COMPOSITE:
136 break;
137 case Inkscape::Filters::NR_FILTER_CONVOLVEMATRIX:
138 repr->setAttribute("order", "3 3");
139 repr->setAttribute("kernelMatrix", "0 0 0 0 0 0 0 0 0");
140 break;
141 case Inkscape::Filters::NR_FILTER_DIFFUSELIGHTING:
142 break;
143 case Inkscape::Filters::NR_FILTER_DISPLACEMENTMAP:
144 break;
145 case Inkscape::Filters::NR_FILTER_FLOOD:
146 break;
147 case Inkscape::Filters::NR_FILTER_GAUSSIANBLUR:
148 repr->setAttribute("stdDeviation", "1");
149 break;
150 case Inkscape::Filters::NR_FILTER_IMAGE:
151 break;
152 case Inkscape::Filters::NR_FILTER_MERGE:
153 break;
154 case Inkscape::Filters::NR_FILTER_MORPHOLOGY:
155 break;
156 case Inkscape::Filters::NR_FILTER_OFFSET:
157 repr->setAttribute("dx", "0");
158 repr->setAttribute("dy", "0");
159 break;
160 case Inkscape::Filters::NR_FILTER_SPECULARLIGHTING:
161 break;
162 case Inkscape::Filters::NR_FILTER_TILE:
163 break;
164 case Inkscape::Filters::NR_FILTER_TURBULENCE:
165 break;
166 default:
167 break;
168 }
170 //set primitive as child of filter node
171 filter->repr->appendChild(repr);
172 Inkscape::GC::release(repr);
174 // get corresponding object
175 SPFilterPrimitive *prim = SP_FILTER_PRIMITIVE( filter->document->getObjectByRepr(repr) );
177 g_assert(prim != NULL);
178 g_assert(SP_IS_FILTER_PRIMITIVE(prim));
180 return prim;
181 }
183 /**
184 * Creates a filter with blur primitive of specified radius for an item with the given matrix expansion, width and height
185 */
186 SPFilter *
187 new_filter_gaussian_blur (SPDocument *document, gdouble radius, double expansion, double expansionX, double expansionY, double width, double height)
188 {
189 g_return_val_if_fail(document != NULL, NULL);
191 SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
193 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
195 // create a new filter
196 Inkscape::XML::Node *repr;
197 repr = xml_doc->createElement("svg:filter");
198 //repr->setAttribute("inkscape:collect", "always");
200 set_filter_area(repr, radius, expansion, expansionX, expansionY,
201 width, height);
203 //create feGaussianBlur node
204 Inkscape::XML::Node *b_repr;
205 b_repr = xml_doc->createElement("svg:feGaussianBlur");
206 //b_repr->setAttribute("inkscape:collect", "always");
208 double stdDeviation = radius;
209 if (expansion != 0)
210 stdDeviation /= expansion;
212 //set stdDeviation attribute
213 sp_repr_set_svg_double(b_repr, "stdDeviation", stdDeviation);
215 //set feGaussianBlur as child of filter node
216 repr->appendChild(b_repr);
217 Inkscape::GC::release(b_repr);
219 // Append the new filter node to defs
220 SP_OBJECT_REPR(defs)->appendChild(repr);
221 Inkscape::GC::release(repr);
223 // get corresponding object
224 SPFilter *f = SP_FILTER( document->getObjectByRepr(repr) );
225 SPGaussianBlur *b = SP_GAUSSIANBLUR( document->getObjectByRepr(b_repr) );
227 g_assert(f != NULL);
228 g_assert(SP_IS_FILTER(f));
229 g_assert(b != NULL);
230 g_assert(SP_IS_GAUSSIANBLUR(b));
232 return f;
233 }
236 /**
237 * Creates a simple filter with a blend primitive and a blur primitive of specified radius for
238 * an item with the given matrix expansion, width and height
239 */
240 SPFilter *
241 new_filter_blend_gaussian_blur (SPDocument *document, const char *blendmode, gdouble radius, double expansion,
242 double expansionX, double expansionY, double width, double height)
243 {
244 g_return_val_if_fail(document != NULL, NULL);
246 SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
248 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
250 // create a new filter
251 Inkscape::XML::Node *repr;
252 repr = xml_doc->createElement("svg:filter");
253 repr->setAttribute("inkscape:collect", "always");
255 // Append the new filter node to defs
256 SP_OBJECT_REPR(defs)->appendChild(repr);
257 Inkscape::GC::release(repr);
259 // get corresponding object
260 SPFilter *f = SP_FILTER( document->getObjectByRepr(repr) );
262 // Gaussian blur primitive
263 if(radius != 0) {
264 set_filter_area(repr, radius, expansion, expansionX, expansionY, width, height);
266 //create feGaussianBlur node
267 Inkscape::XML::Node *b_repr;
268 b_repr = xml_doc->createElement("svg:feGaussianBlur");
269 b_repr->setAttribute("inkscape:collect", "always");
271 double stdDeviation = radius;
272 if (expansion != 0)
273 stdDeviation /= expansion;
275 //set stdDeviation attribute
276 sp_repr_set_svg_double(b_repr, "stdDeviation", stdDeviation);
278 //set feGaussianBlur as child of filter node
279 repr->appendChild(b_repr);
280 Inkscape::GC::release(b_repr);
282 SPGaussianBlur *b = SP_GAUSSIANBLUR( document->getObjectByRepr(b_repr) );
283 g_assert(b != NULL);
284 g_assert(SP_IS_GAUSSIANBLUR(b));
285 }
286 // Blend primitive
287 if(strcmp(blendmode, "normal")) {
288 Inkscape::XML::Node *b_repr;
289 b_repr = xml_doc->createElement("svg:feBlend");
290 b_repr->setAttribute("inkscape:collect", "always");
291 b_repr->setAttribute("mode", blendmode);
292 b_repr->setAttribute("in2", "BackgroundImage");
294 // set feBlend as child of filter node
295 repr->appendChild(b_repr);
296 Inkscape::GC::release(b_repr);
298 // Enable background image buffer for document
299 Inkscape::XML::Node *root = b_repr->root();
300 if (!root->attribute("enable-background")) {
301 root->setAttribute("enable-background", "new");
302 }
304 SPFeBlend *b = SP_FEBLEND(document->getObjectByRepr(b_repr));
305 g_assert(b != NULL);
306 g_assert(SP_IS_FEBLEND(b));
307 }
309 g_assert(f != NULL);
310 g_assert(SP_IS_FILTER(f));
312 return f;
313 }
315 /**
316 * Creates a simple filter for the given item with blend and blur primitives, using the
317 * specified mode and radius, respectively
318 */
319 SPFilter *
320 new_filter_simple_from_item (SPDocument *document, SPItem *item, const char *mode, gdouble radius)
321 {
322 Geom::OptRect const r = sp_item_bbox_desktop(item, SPItem::GEOMETRIC_BBOX);
324 double width;
325 double height;
326 if (r) {
327 width = r->dimensions()[Geom::X];
328 height= r->dimensions()[Geom::Y];
329 } else {
330 width = height = 0;
331 }
333 Geom::Matrix i2d (sp_item_i2d_affine (item) );
335 return (new_filter_blend_gaussian_blur (document, mode, radius, i2d.descrim(), i2d.expansionX(), i2d.expansionY(), width, height));
336 }
338 /**
339 * Modifies the gaussian blur applied to the item.
340 * If no filters are applied to given item, creates a new blur filter.
341 * If a filter is applied and it contains a blur, modify that blur.
342 * If the filter doesn't contain blur, a blur is added to the filter.
343 * Should there be more references to modified filter, that filter is
344 * duplicated, so that other elements referring that filter are not modified.
345 */
346 /* TODO: this should be made more generic, not just for blurs */
347 SPFilter *
348 modify_filter_gaussian_blur_from_item(SPDocument *document, SPItem *item,
349 gdouble radius)
350 {
351 if (!item->style || !item->style->filter.set) {
352 return new_filter_simple_from_item(document, item, "normal", radius);
353 }
355 SPFilter *filter = SP_FILTER(item->style->getFilter());
356 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document);
358 // If there are more users for this filter, duplicate it
359 if (SP_OBJECT_HREFCOUNT(filter) > count_filter_hrefs(item, filter)) {
360 Inkscape::XML::Node *repr;
361 repr = SP_OBJECT_REPR(item->style->getFilter())->duplicate(xml_doc);
362 SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
363 SP_OBJECT_REPR(defs)->appendChild(repr);
365 filter = SP_FILTER( document->getObjectByRepr(repr) );
366 Inkscape::GC::release(repr);
367 }
369 // Determine the required standard deviation value
370 Geom::Matrix i2d (sp_item_i2d_affine (item));
371 double expansion = i2d.descrim();
372 double stdDeviation = radius;
373 if (expansion != 0)
374 stdDeviation /= expansion;
376 // Get the object size
377 Geom::OptRect const r = sp_item_bbox_desktop(item, SPItem::GEOMETRIC_BBOX);
378 double width;
379 double height;
380 if (r) {
381 width = r->dimensions()[Geom::X];
382 height= r->dimensions()[Geom::Y];
383 } else {
384 width = height = 0;
385 }
387 // Set the filter effects area
388 Inkscape::XML::Node *repr = SP_OBJECT_REPR(item->style->getFilter());
389 set_filter_area(repr, radius, expansion, i2d.expansionX(),
390 i2d.expansionY(), width, height);
392 // Search for gaussian blur primitives. If found, set the stdDeviation
393 // of the first one and return.
394 Inkscape::XML::Node *primitive = repr->firstChild();
395 while (primitive) {
396 if (strcmp("svg:feGaussianBlur", primitive->name()) == 0) {
397 sp_repr_set_svg_double(primitive, "stdDeviation",
398 stdDeviation);
399 return filter;
400 }
401 primitive = primitive->next();
402 }
404 // If there were no gaussian blur primitives, create a new one
406 //create feGaussianBlur node
407 Inkscape::XML::Node *b_repr;
408 b_repr = xml_doc->createElement("svg:feGaussianBlur");
409 //b_repr->setAttribute("inkscape:collect", "always");
411 //set stdDeviation attribute
412 sp_repr_set_svg_double(b_repr, "stdDeviation", stdDeviation);
414 //set feGaussianBlur as child of filter node
415 SP_OBJECT_REPR(filter)->appendChild(b_repr);
416 Inkscape::GC::release(b_repr);
418 return filter;
419 }
421 void remove_filter (SPObject *item, bool recursive)
422 {
423 SPCSSAttr *css = sp_repr_css_attr_new ();
424 sp_repr_css_unset_property (css, "filter");
425 if (recursive)
426 sp_repr_css_change_recursive(SP_OBJECT_REPR(item), css, "style");
427 else
428 sp_repr_css_change (SP_OBJECT_REPR(item), css, "style");
429 sp_repr_css_attr_unref (css);
430 }
432 /**
433 * Removes the first feGaussianBlur from the filter attached to given item.
434 * Should this leave us with an empty filter, remove that filter.
435 */
436 /* TODO: the removed filter primitive may had had a named result image, so
437 * after removing, the filter may be in erroneous state, this situation should
438 * be handled gracefully */
439 void remove_filter_gaussian_blur (SPObject *item)
440 {
441 if (item->style && item->style->filter.set && item->style->getFilter()) {
442 // Search for the first blur primitive and remove it. (if found)
443 Inkscape::XML::Node *repr = SP_OBJECT_REPR(item->style->getFilter());
444 Inkscape::XML::Node *primitive = repr->firstChild();
445 while (primitive) {
446 if (strcmp("svg:feGaussianBlur", primitive->name()) == 0) {
447 sp_repr_unparent(primitive);
448 break;
449 }
450 primitive = primitive->next();
451 }
453 // If there are no more primitives left in this filter, discard it.
454 if (repr->childCount() == 0) {
455 remove_filter(item, false);
456 }
457 }
458 }
460 bool filter_is_single_gaussian_blur(SPFilter *filter)
461 {
462 return (SP_OBJECT(filter)->firstChild() &&
463 SP_OBJECT(filter)->firstChild() == SP_OBJECT(filter)->lastChild() &&
464 SP_IS_GAUSSIANBLUR(SP_OBJECT(filter)->firstChild()));
465 }
467 double get_single_gaussian_blur_radius(SPFilter *filter)
468 {
469 if (SP_OBJECT(filter)->firstChild() &&
470 SP_OBJECT(filter)->firstChild() == SP_OBJECT(filter)->lastChild() &&
471 SP_IS_GAUSSIANBLUR(SP_OBJECT(filter)->firstChild())) {
473 SPGaussianBlur *gb = SP_GAUSSIANBLUR(SP_OBJECT(filter)->firstChild());
474 double x = gb->stdDeviation.getNumber();
475 double y = gb->stdDeviation.getOptNumber();
476 if (x > 0 && y > 0) {
477 return MAX(x, y);
478 }
479 return x;
480 }
481 return 0.0;
482 }
486 /*
487 Local Variables:
488 mode:c++
489 c-file-style:"stroustrup"
490 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
491 indent-tabs-mode:nil
492 fill-column:99
493 End:
494 */
495 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :