drafts: filters/master/Filters.html@b31bb9367aef (annotated)

filters/master/Filters.html@b31bb9367aef (annotated)

filters/master/Filters.html

Wed, 07 Sep 2011 10:26:03 +1000

author: Dean Jackson <dino@apple.com>
date: Wed, 07 Sep 2011 10:26:03 +1000
changeset 36: b31bb9367aef
parent 34: cc281b90a47a
child 40: 3f1fdd4a8004
permissions: -rw-r--r--

- Added opacity function
- Corrected luminanceToAlpha values

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional+edit//EN" "xhtml1-transitional+edit.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml"
  xmlns:edit="http://xmlns.grorg.org/SVGT12NG/" xml:lang="en" lang="en">
 <head>
   <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
   <title>Filter Effects 1.0: Language</title>
   <link rel="stylesheet" type="text/css" href="style/svg-style.css" />
   <link rel="stylesheet" type="text/css" href="style/svg-style-extra.css"/>
 </head>
 <body>
 <div class="head">
   <p><a href="http://www.w3.org/"><img height="48" width="72" alt="W3C" src="http://www.w3.org/Icons/w3c_home"/></a></p>
   <h1 id="pagetitle">Filter Effects 1.0: Language</h1>
   <h2 id="pagesubtitle">W3C <edit:maturity/> <em><edit:date/></em></h2>
   <dl>
     <dt>This version:</dt>
     <dd><edit:thisversion/></dd>
     <dt>Latest version:</dt>
     <dd><edit:latestversion/></dd>
     <dt>Previous version:</dt>
     <dd><edit:previousversion/></dd>
     <dt>Editors:</dt>
     <dd><a href="mailto:ed@opera.com">Erik Dahlström</a>, (<a href="http://www.opera.com/">Opera Software ASA</a>)</dd>
     <dd><a href="mailto:dino@apple.com">Dean Jackson</a> (<a href="http://www.apple.com/">Apple Inc</a>)</dd>
     <dt>Authors:</dt>
     <dd>The authors of this specification are the participants of the W3C SVG and CSS Working Groups.</dd>
   </dl>
   <edit:copyright/>
 </div>
 <hr/>
 <h2 id="abstract" edit:toc="no">Abstract</h2>
 <p>
   Filter effects are a way of processing an element's display before it is
   displayed in the document. Typically, rendering an element via CSS or SVG
   can conceptually described as if the element, including its children, are
   drawn into a buffer (such as a raster image) and then that buffer is
   composited into the elements parent. Filters apply an effect before the
   compositing stage. Examples of such effects are blurring, changing color
   intensity and warping the image.
 </p>
 <p>
   Although originally designed for use in SVG, filter effects simply define
   a set of operations to apply on an image buffer. In SVG they are triggered
   by a style instruction (the 'filter property' property), and have very little
   specific to an SVG environment. This specification describes filters in
   a manner that allow them to be used in other presentational environments,
   such as HTML styled by CSS and XSL:FO. It also defines a CSS property
   value function that allows a filter chain to produce a CSS &lt;image&gt; value.
 </p>
 <h2 id="status" edit:toc="no">Status of This Document</h2>
 <p><em>This section describes the status of this document at the time of its
 publication. Other documents may supersede this document. The latest status
 of this document series is maintained at the W3C. </em> </p>
 <p>
   This document is the first public working draft of this specification. There
   is an accompanying <a href="http://dev.w3.org/SVG/modules/filters/publish/SVGFilterPrimer.html">Filter Effects 1.0, Part 1:
   Primer</a> that lists the ways SVG filters may be used.
 </p>
 <p>
   This document has been produced by the <a
   href="http://www.w3.org/Style/CSS">W3C CSS</a> and <a
   href="http://www.w3.org/Graphics/SVG">SVG</a> Working Groups as part of the
   <a href="http://www.w3.org/Interaction/">W3C Interaction Domain</a>.
 </p>
 <p>
   The (<a href="http://lists.w3.org/Archives/Public/public-fx/">archived</a>)
   public mailing list <a
   href="mailto:www-style@w3.org?Subject=%5Bfilters%5D%20PUT%20SUBJECT%20HERE">
   public-fx@w3.org</a> (see <a
   href="http://www.w3.org/Mail/Request">instructions</a>) is preferred for
   discussion of this specification. Acceptance of the archiving policy is
   requested automatically upon first post to the list. When sending e-mail,
   please put the text &#8220;filters&#8221; in the subject, preferably like
   this: &#8220;[<!---->filters<!---->] <em>&hellip;summary of
   comment&hellip;</em>&#8221;
 </p>
 <p>
   The latest information regarding <a
   href="http://www.w3.org/Graphics/SVG/Disclosures">patent disclosures</a>
   related to this document is available on the Web. As of this publication,
   the SVG Working Group are not aware of any royalty-bearing patents they
   believe to be essential to SVG. <span class="note">[@@ Add patent link for CSS WG]</span>
 </p>
 <p>
   Publication of this document does not imply endorsement by the W3C
   membership. A list of current W3C Recommendations and other technical
   documents can be found at <a
   href="http://www.w3.org/TR/">http://www.w3.org/TR/</a>. W3C publications may
   be updated, replaced, or obsoleted by other documents at any time. It is
   inappropriate to cite a W3C Working Draft as anything other than a <em>work
   in progress</em>."
 </p>
 <p>
   The <a href="ChangeLog">list of changes made to this specification</a> is
   available.
 </p>
 <edit:fulltoc/>
 <h2 id="introduction">Introduction</h2>
 <p>
   This chapter describes a declarative filter effects feature set, which when
   combined with the other web technologies, such as SVG or HTML, can describe
   much of the common artwork on the Web in such a way that client-side
   generation and alteration can be performed easily. In addition, the ability
   to apply filter effects to elements helps to maintain the semantic
   structure of the document, instead of resorting to images which aside from
   generally being a fixed resolution tend to obscure the original semantics of
   the elements they replace. This is especially true for effects applied to
   text.
 </p>
 <p>
 </p>
 <p>
   Note that even though this specification references parts of <a
   href="#ref-svg11">SVG 1.1</a> it does not require an SVG 1.1
   implementation. <span class="note">Add link to conformance classes
   here.</span>
 </p>
 <p>This document is normative.</p>
 <p>This document contains explicit conformance criteria that overlap with
 some RelaxNG definitions in requirements. If there is any conflict between the
 two, the explicit conformance criteria are the definitive reference. </p>
 <p>A filter effect consists of a series of graphics operations that are
 applied to a given <span id="TermSourceGraphic" class="SVG-Term">source graphic</span> to produce a modified graphical
 result. The result of the filter effect is rendered to the target device
 instead of the original source graphic. The following illustrates the
 process:</p>
 <p><object data="examples/filters00.svg" type="image/svg+xml" height="78" width="400">
   <img alt="Image showing source graphic transformed by filter effect"
   src="examples/filters00.png" width="401" height="78" />
 </object></p>
 <p class="view-as-svg"><a href="examples/filters00.svg">View this example as
 SVG (SVG-enabled browsers only)</a><br />
 </p>
 <h2 id="FilterDefinitions">Definitions</h2>
   <p>When used in this specification, terms have the meanings assigned in this section.</p>
   <dl>
     <dt id="TermNullFilter"><span
     class="SVG-TermDefine">null filter</span></dt>
     <dd>
       <p>
       The null filter output is all transparent black pixels. If applied to an element it means
     that the element (and children if any) becomes invisible. Note that it does not affect event processing.
       </p>
     </dd>
     <dt id="TermTransferFunctionElements"><span
     class="SVG-TermDefine">transfer function elements</span></dt>
     <dd>
       <p>
       The set of elements,
         <a>'feFuncR'</a>, <a>'feFuncG'</a>, <a>'feFuncB'</a>, <a>'feFuncA'</a>, that define the transfer function for the <a>'feComponentTransfer'</a> filter primitive.
       </p>
     </dd>
   <dt id="TermClientBoundingRect"><span
     class="SVG-TermDefine">bounding client rect</span></dt>
   <dd>
     <p>
     The union of all CSS border-boxes for the element if formatted by CSS, as defined by the CSS OM method
     <a href="http://www.w3.org/TR/cssom-view/#dom-element-getboundingclientrect">getBoundingClientRect</a> [<a href="#ref-CSSOM">CSSOM</a>].
     </p>
   </dd>
   <dt id="TermCSSBoundingBox"><span
     class="SVG-TermDefine">CSS bounding box</span></dt>
   <dd>
     <p>
     The union of all CSS border-boxes for the element and all it's descendant elements, provided the element is formatted by CSS. [<a href="#ref-CSS21">CSS</a>].
     </p>
   </dd>
   <dt id="TermCurrentUserCoordinateSystem"><span
     class="SVG-TermDefine">current user coordinate system</span></dt>
   <dd>
     <p>
     For elements formatted by CSS: the current user coordinate system has its origin at the top-left corner of the
     <a href="#TermClientBoundingRect">bounding client rect</a> and one unit equals on CSS px. The viewport for resolving percentage values is defined by the width and height of the
     <a href="#TermClientBoundingRect">bounding client rect</a>.
     </p>
     <p>
     For SVG elements see <a>user coordinate system</a>.
     </p>
   </dd>
   <dt id="TermObjectBoundingBoxUnits"><span
     class="SVG-TermDefine">object bounding box units</span></dt>
   <dd>
     For elements formatted by CSS: the bounding box is defined by <a href="#TermCSSBoundingBox">the CSS bounding box.</a>
     <p>
     For SVG elements the bounding box is defined by <a href="http://www.w3.org/TR/2008/REC-SVGTiny12-20081222/intro.html#TermBoundingBox">the SVG bounding box</a>.
     </p>
     <p>
     For both cases the bounding box defines the coordinate system in which to resolve values, as defined in <a>object bounding box units</a>.
     </p>
   </dd>
   <dt id="TermFilterPrimitiveReference"><span
     class="SVG-TermDefine">&lt;filter-primitive-reference&gt;</span></dt>
   <dd>
     <p>
     A string that identifies a particular filter primitive's output.
     </p>
   </dd>
   <dt id="TermFilterPrimitiveElements"><span
     class="SVG-TermDefine">filter primitives, filter primitive elements</span></dt>
   <dd>
     <p>
     The set of elements that control the output of a <a>'filter element'</a> element, particularly:
       <a>'feDistantLight'</a>,
       <a>'fePointLight'</a>,
       <a>'feSpotLight'</a>,
       <a>'feBlend'</a>,
       <a>'feColorMatrix'</a>,
       <a>'feComponentTransfer'</a>,
       <a>'feComposite'</a>,
       <a>'feConvolveMatrix'</a>,
       <a>'feDiffuseLighting'</a>,
       <a>'feDisplacementMap'</a>,
       <a>'feFlood'</a>,
       <a>'feGaussianBlur'</a>,
       <a>'feImage'</a>,
       <a>'feMerge'</a>,
       <a>'feMorphology'</a>,
       <a>'feOffset'</a>,
       <a>'feSpecularLighting'</a>,
       <a>'feTile'</a>,
       <a>'feTurbulence'</a>,
       <a>'feDropShadow'</a>,
       <a>'feDiffuseSpecular'</a>,
       <a>'feUnsharpMask'</a>,
       <a>'feCustom'</a>.
       </p>
   </dd>
   </dl>
   <br/>
 <h2 id="FilterProperty">The <span class="prop-name">'filter'</span>
 property</h2>
 <p>The description of the <span class="prop-name">'filter'</span> property is
 as follows:</p>
 <div class="propdef">
 <dl>
   <dt id='propdef-filter'><span class='propdef-title prop-name'>'filter'</span></dt>
     <dd>
       <table summary="filter property" class="propinfo" cellspacing="0"
       cellpadding="0">
         <tbody>
           <tr valign="baseline">
             <td><em>Value:</em>  </td>
             <td>none | <a href="#FilterFunction">&lt;filter-function&gt;</a> [ <a href="#FilterFunction">&lt;filter-function&gt;</a> ]* </td>
           </tr>
           <tr valign="baseline">
             <td><em>Initial:</em>  </td>
             <td>none</td>
           </tr>
           <tr valign="baseline">
             <td><em>Applies to:</em>  </td>
             <td>All elements</td>
           </tr>
           <tr valign="baseline">
             <td><em>Inherited:</em>  </td>
             <td>no</td>
           </tr>
           <tr valign="baseline">
             <td><em>Percentages:</em>  </td>
             <td>N/A</td>
           </tr>
           <tr valign="baseline">
             <td><em>Media:</em>  </td>
             <td>visual</td>
           </tr>
           <tr valign="baseline">
             <td><em>Animatable:</em>  </td>
             <td>yes</td>
           </tr>
         </tbody>
       </table>
     </dd>
 </dl>
 </div>
 <p>
   If the value of the <a>'filter property'</a> property is <span class="prop-value">none</span> then there
   is no filter effect applied. Otherwise, the list of functions (described <a href="#FilterFunction">below</a>)
   are applied in order.
 </p>
 <h3 id="filters-in-css">How the <a>'filter property'</a> property applies to content formatted by CSS (e.g HTML)</h3>
 <p>
   The application of the <a>'filter property'</a> property to an element
   formatted by CSS establishes a pseudo-stacking-context the same way that CSS
   <a href="http://www.w3.org/TR/css3-color/#transparency">'opacity'</a> does,
   and all the element's boxes are rendered together as a group with the filter
   effect applied to the group as a whole.
 </p>
 <p>
   The <a>'filter property'</a> property has no effect on the geometry of the
   target element's CSS boxes, even though <a>'filter property'</a> can cause
   painting outside of an element's border-box.
 </p>
 <p>
   The compositing model follows the <a
   href="http://www.w3.org/TR/SVG11/render.html#Introduction">SVG compositing
   model</a>: first any filter effect is applied, then any clipping, masking
   and opacity. These effects all apply after any other CSS effects such as
   'border'. As per SVG, the application of <a>'filter property'</a> has no
   effect on hit-testing.
 </p>
 <br />
 <h2 id="FilterFunction">Filter Functions</h2>
 <p>
   The value of the <a>'filter property'</a> property is a list of &lt;filter-functions&gt;
   applied in the order provided. The individual filter functions are
   separated by whitespace. The set of allowed filter functions is given
   below.
 </p>
 <dl>
   <dt>
     <a>&lt;FuncIRI&gt;</a>
   </dt>
   <dd>
     An <a>IRI reference</a>
     to a <a>'filter element'</a> element that defines the
     filter effect. For example "url(commonfilters.xml#large-blur)". If the IRI references a non-existent object or the referenced
     object is not a <a>'filter element'</a> element, then the <a>null filter</a> will be applied instead.
   </dd>
   <dt>
     grayscale(amount)
   </dt>
   <dd>
     Converts the input image to grayscale. The value of 'amount' defines the proportion
     of the conversion. A value of 1 is completely grayscale. A value of 0 leaves the
     input unchanged. Values between 0 and 1 are linear multipliers on the effect.
     If the 'amount' parameter is missing, a value of 1 is used.
     The markup equivalent of this function is <a href="#grayscaleEquivalent">given below</a>.
   </dd>
   <dt>
     sepia(amount)
   </dt>
   <dd>
     Converts the input image to sepia. The value of 'amount' defines the proportion
     of the conversion. A value of 1 is completely sepia. A value of 0 leaves the
     input unchanged. Values between 0 and 1 are linear multipliers on the effect.
     If the 'amount' parameter is missing, a value of 1 is used.
     The markup equivalent of this function is <a href="#sepiaEquivalent">given below</a>.
   </dd>
   <dt>
     saturate(amount)
   </dt>
   <dd>
     Saturates the input image. The value of 'amount' defines the proportion
     of the conversion. A value of 1 is completely saturated. A value of 0 leaves the
     input unchanged. Values between 0 and 1 are linear multipliers on the effect.
     If the 'amount' parameter is missing, a value of 1 is used.
     The markup equivalent of this function is <a href="#saturateEquivalent">given below</a>.
   </dd>
   <dt>
     hue-rotate(angle)
   </dt>
   <dd>
     Applies a hue rotation on the input image. The value of 'angle' defines the
     number of degrees around the color circle the input samples will be adjusted.
     A value of 0 leaves the input unchanged. If the 'angle' parameter is missing,
     a value of 0 is used.
     The markup equivalent of this function is <a href="#huerotateEquivalent">given below</a>.
   </dd>
   <dt>
     invert(amount)
   </dt>
   <dd>
     Inverts the samples in the input image. The value of 'amount' defines the proportion
     of the conversion. A value of 1 is completely inverted. A value of 0 leaves the
     input unchanged. Values between 0 and 1 are linear multipliers on the effect.
     If the 'amount' parameter is missing, a value of 1 is used.
     The markup equivalent of this function is <a href="#invertEquivalent">given below</a>.
   </dd>
   <dt>
     opacity(amount)
   </dt>
   <dd>
     Applies transparency to the samples in the input image. The value of 'amount' defines the proportion
     of the conversion. A value of 1 is completely transparent. A value of 0 leaves the
     input unchanged. Values between 0 and 1 are linear multipliers on the effect.
     This is equivalent to multiplying the input image samples by (1 - amount).
     If the 'amount' parameter is missing, a value of 1 is used.
     The markup equivalent of this function is <a href="#opacityEquivalent">given below</a>.
   </dd>
   <dt>
     gamma(amplitude exponent offset)
   </dt>
   <dd>
     Applies a gamma function to the input image.
     The value of 'amplitude' defines the multiplier to the gamma function.
     The value of 'exponent' defines the exponent of the gamma function.
     The value of 'offset' defines the offset of the gamma function.
     If any of the parameters are missing, the default value for 'amplitude'
     is 1, for 'exponent' is 1, and for 'offset' is 0.
     The markup equivalent of this function is <a href="#gammaEquivalent">given below</a>.
   </dd>
   <dt>
     blur(radiusX radiusY)
   </dt>
   <dd>
     Applies a Gaussian blur to the input image.
     The value of 'radiusX' defines the X value of the standard deviation to the Gaussian function.
     The value of 'radiusY' defines the Y value of the standard deviation to the Gaussian function.
     If one parameter is provided, then that value is used for both 'radiusX' and 'radiusY'.
     If no parameters are provided, then the value for both attributes is 0.
     The markup equivalent of this function is <a href="#blurEquivalent">given below</a>.
   </dd>
   <dt>
     sharpen(amount radius threshold)
   </dt>
   <dd>
     Applies an sharpening effect to the input image. This is equivalent to subtracting the
     input samples from a blurred version of the image.
     The value of 'amount' defines the proportion of the effect (as a multiplier on the
     subtraction). A value of 1 applies the effect completely. A value of 0 leaves the
     input unchanged.
     The value of 'radius' defines the value of the standard deviation to the Gaussian function.
     The value of 'threshold' defines a point at which the function will not be applied.
     If the 'threshold' parameter is not provided, then its value is 1. If the 'radius' parameter
     is not provided, then its value is 0. If no parameters are provided, then the value for 'amount' is 0.
     The markup equivalent of this function is <a href="#sharpenEquivalent">given below</a>.
   </dd>
   <dt>
     drop-shadow(&lt;shadow&gt;)
   </dt>
   <dd>
     Applies a drop shadow effect to the input image. A drop shadow is
     effectively a blurred, offset version of the input image's alpha mask
     drawn in a particular color, composited below the image. The function
     accepts a parameter of type &lt;shadow&gt; (defined in CSS3 Backgrounds),
     with the exception that the 'inset' keyword is not allowed. The markup
     equivalent of this function is <a href="#dropshadowEquivalent">given
     below</a>.
   </dd>
 </dl>
 <div class="note">
   <p>
     The above list is a collection of effects that can be easily defined in
     terms of SVG filters. However, there are many more interesting effects
     that can be considered for inclusion. If accepted, there will have to
     be equivalent XML elements for the effect. Effects considered include:
   </p>
   <ul>
   <li>brightness, contrast, exposure</li>
   <li>halftone</li>
   <li>motion-blur(radius, angle)</li>
   <li>posterize(levels)</li>
   <li>bump(x, y, radius, intensity)</li>
   <li>generators</li>
   <li>circle-crop(x, y, radius)</li>
   <li>affine-transform(some matrix)</li>
   <li>crop(x, y, w, h)</li>
   <li>bloom(radius, intensity)</li>
   <li>gloom(radius, intensity)</li>
   <li>mosaic(w,h)</li>
   <li>displace(url, intensity)</li>
   <li>edge-detect(intensity)</li>
   <li>pinch(x, y, radius, scale)</li>
   <li>twirl(x, y, radius, angle)</li>
   </ul>
 </div>
 <p>
   The first function in the list takes the element (<a href="#SourceGraphic">SourceGraphic</a>) as
   the input image. Subsequent operations take the output from the
   previous function as the input image. The exception is the function
   that references a 'filter element' element, which can specify an
   alternate input, but still uses the previous output as its
   <a href="#SourceGraphic">SourceGraphic</a>.
 </p>
 <h2 id="FilterElement">The <span class="element-name">'filter'</span>
 element</h2>
 <edit:elementsummary name='filter'/>
 <edit:with element='filter'>
 <p>The description of the <a>'filter element'</a> element
 follows:</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="FilterElementFilterUnitsAttribute"><span
   class="adef">filterUnits</span> = "<em>userSpaceOnUse</em> |
   <em>objectBoundingBox</em>"</dt>
     <dd>See <a>filter effects region</a>.</dd>
   <dt id="FilterElementPrimitiveUnitsAttribute"><span
   class="adef">primitiveUnits</span> = "<em>userSpaceOnUse</em> |
   <em>objectBoundingBox</em>"</dt>
     <dd>Specifies the coordinate system for the various length values within
       the <a>filter primitives</a> and for the attributes that define the <a>filter primitive subregion</a>.<br />
       If <span class='attr-value'>primitiveUnits="userSpaceOnUse"</span>, any length values
       within the filter definitions represent values in the <a href="#TermCurrentUserCoordinateSystem">current user
       coordinate system</a> in place at the time when the <a>'filter element'</a>
       element is referenced (i.e., the user coordinate system for the element
       referencing the <a>'filter element'</a> element via a <a>'filter property'</a>
       property).<br />
       If <span class='attr-value'>primitiveUnits="objectBoundingBox"</span>, then any length
       values within the filter definitions represent fractions or percentages
       of the bounding box on the referencing element (see <a href="#TermObjectBoundingBoxUnits">object bounding box
       units</a>). Note that if only one number was specified in a <a>&lt;number-optional-number&gt;</a> value
     this number is expanded out before the <a>'filter/primitiveUnits'</a> computation takes place.
     <br />
       The <a>lacuna value</a> for <a>'filter/primitiveUnits'</a> is <span class="attr-value">userSpaceOnUse</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="FilterElementXAttribute">
   <span class="adef">x</span> = "<em><a>&lt;coordinate&gt;</a></em>"</dt>
     <dd>See <a>filter effects region</a>.</dd>
   <dt id="FilterElementYAttribute">
   <span class="adef">y</span> = "<em><a>&lt;coordinate&gt;</a></em>"</dt>
     <dd>See <a>filter effects region</a>.</dd>
   <dt id="FilterElementWidthAttribute"><span class="adef">width</span> =
   "<em><a>&lt;length&gt;</a></em>"</dt>
     <dd>See <a>filter effects region</a>.</dd>
   <dt id="FilterElementHeightAttribute"><span class="adef">height</span> =
   "<em><a>&lt;length&gt;</a></em>"</dt>
     <dd>See <a>filter effects region</a>.</dd>
 <dt id="FilterElementFilterResAttribute"><span
   class="adef">filterRes</span> = "<em><a>&lt;number-optional-number&gt;</a></em>"
   </dt>
     <dd>See <a>filter effects region</a>.</dd>
  <dt id="FilterElementHrefAttribute"><span class="adef">xlink:href</span>
   = "<span class="attr-value">&lt;IRI&gt;</span>"</dt>
     <dd>An <a>IRI reference</a>
       to another <a>'filter element'</a> element within
       the current <a>SVG document fragment</a>. Any attributes which are defined on
       the referenced <a>'filter element'</a> element which
       are not defined on this element are inherited by this element. If this
       element has no defined filter nodes, and the referenced element has
       defined filter nodes (possibly due to its own <span
       class="attr-name">href</span> attribute), then this element inherits
       the filter nodes defined from the referenced <a>'filter element'</a> element. Inheritance can be
       indirect to an arbitrary level; thus, if the referenced <a>'filter element'</a> element inherits attributes or its
       filter node specification due to its own <span
       class="attr-name">href</span> attribute, then the current element can
       inherit those attributes or filter node specifications.
       <div class="note">
       This attribute is deprecated and should not be used, it's included for
       backwards compatibility reasons only.</div>
       <br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <p>Properties inherit into the <a>'filter element'</a>
 element from its ancestors; properties do <em>not</em> inherit from the
 element referencing the <a>'filter element'</a>
 element.</p>
 <p><a>'filter element'</a> elements are never rendered
 directly; their only usage is as something that can be referenced using the
 <a>'filter property'</a>
 property. The <a>'display'</a> property does not
 apply to the <a>'filter element'</a> element; thus, <a>'filter element'</a> elements are not directly rendered even
 if the <a>'display'</a> property is set to a value
 other than <span class="prop-value">none</span>, and <a>'filter element'</a> elements are available for referencing
 even when the <a>'display'</a> property on the <a>'filter element'</a> element or any of its ancestors is set
 to <span class="prop-value">none</span>.</p>
 <br />
 <h2 id="FilterEffectsRegion">Filter effects region</h2>
 <p>A <a>'filter element'</a>
 element can define a region on the canvas to which a given filter effect
 applies and can provide a resolution for any intermediate continuous tone
 images used to process any raster-based <a>filter primitives</a>.
 The <a>'filter element'</a>
 element has the following attributes which work together to define the filter
 effects region:</p>
  <dl class='definitions unemphasized-names'>
   <dt id="FilterUnitsAttribute"><a>'filterUnits'</a></dt>
   <dd>
       <p>Defines the coordinate system for attributes <a>'x'</a>, <a>'y'</a>,
       <a>'width'</a>, <a>'height'</a>.</p>
     <p>If <span class="attr-value">filterUnits="userSpaceOnUse"</span>, <a>'x'</a>, <a>'y'</a>,
       <a>'width'</a>, <a>'height'</a> represent values in the current user coordinate
       system in place at the time when the <a>'filter element'</a> element is referenced (i.e., the
       user coordinate system for the element referencing the <a>'filter element'</a>
       element via a <a>'filter property'</a> property).</p>
       <p>If <span class="attr-value">filterUnits="objectBoundingBox"</span>, then <a>'x'</a>, <a>'y'</a>,
       <a>'width'</a>, <a>'height'</a> represent fractions or percentages of the
       bounding box on the referencing element (see <a>object bounding box units</a>).</p>
     <p>The <a>lacuna value</a> for <a>'filterUnits'</a> is <span
       class="attr-value">objectBoundingBox</span>.</p>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="FilterRegionXYWidthHeightAttributes"><a>'x'</a>, <a>'y'</a>, <a>'width'</a>, <a>'height'</a></dt>
     <dd>
     <p>These attributes define a rectangular region on the canvas to which this filter applies.</p>
       <p>The amount of memory and processing time required to apply the filter are
          related to the size of this rectangle and the <a>'filter/filterRes'</a> attribute of the filter.</p>
     <p>The coordinate system for these attributes depends on the value for attribute <a>'filterUnits'</a>.</p>
     <p>The bounds of this rectangle act as a hard clipping region for each <a>filter primitive</a>
        included with a given <a>'filter element'</a> element; thus, if the effect of
          a given filter primitive would extend beyond the bounds of the rectangle
          (this sometimes happens when using a <a>'feGaussianBlur'</a> filter primitive with a
          very large <a>'feGaussianBlur/stdDeviation'</a>), parts of the effect will get clipped.</p>
     <p>The <a>lacuna value</a> for <a>'x'</a> and <a>'y'</a> is <span class="attr-value">-10%</span>.</p>
     <p>The <a>lacuna value</a> for <a>'width'</a> and <a>'height'</a> is <span class="attr-value">120%</span>.</p>
       <p>Negative or zero values for <a>'width'</a> or <a>'height'</a> disable rendering of the element which
        referenced the filter. </p>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="FilterRegionFilterRes"><a>'filter/filterRes'</a></dt>
   <dd>
     <p>Defines the width and height of the intermediate
       images in pixels. If not provided, then the user agent will use reasonable
       values to produce a high-quality result on the output device.</p>
       <p>Care should be taken when assigning a non-default value to this
       attribute. Too small of a value may result in unwanted pixelation in the
       result. Too large of a value may result in slow processing and large
       memory usage.</p>
       <p>Non-integer values are truncated, i.e rounded to the closest integer value towards zero.</p>
       <p><span class="requirement" id="assert_OORFilterRegion">Negative or zero values disable rendering of the element which referenced the filter.</span></p>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
 </dl>
 <p>Note that both of the two possible value for <a>'filterUnits'</a> (i.e., <span
 class="attr-value">objectBoundingBox</span> and <span
 class="attr-value">userSpaceOnUse</span>) result in a <a>filter region</a> whose
 coordinate system has its X-axis and Y-axis each parallel to the X-axis and
 Y-axis, respectively, of the <a>user coordinate system</a> for the element to which
 the filter will be applied.</p>
 <p class="note implementation">Sometimes implementers can achieve faster performance when the filter
 region can be mapped directly to device pixels; thus, for best performance on
 display devices, it is suggested that authors define their region such that
 the user agent can align the <a>filter region</a> pixel-for-pixel with the
 background. In particular, for best filter effects performance, avoid
 rotating or skewing the user coordinate system. Explicit values for attribute
 <a>'filter/filterRes'</a> can either help or harm performance.
 If <a>'filter/filterRes'</a> is smaller than the automatic
 (i.e., default) filter resolution, then filter effect might have faster
 performance (usually at the expense of quality). If <a>'filter/filterRes'</a> is larger than the automatic (i.e.,
 default) filter resolution, then filter effects performance will usually be
 slower.</p>
 <p class="note authoring">It is often necessary to provide padding space because the filter effect
 might impact bits slightly outside the tight-fitting <a>'bounding box'</a> on a given
 object. For these purposes, it is possible to provide negative percentage
 values for <a>'x'</a>, <a>'y'</a> and percentages values greater than <span class="attr-value">100%</span> for
 <a>'width'</a>, <a>'height'</a>. This, for example, is why the defaults for
 the filter effects region are <span class="attr-value">x="-10%" y="-10%" width="120%"
 height="120%"</span>.</p>
 <h2 id="AccessBackgroundImage">Accessing the background image</h2>
 <p id="AccessingBackgroundImage">Two possible pseudo input images for filter effects are <a>BackgroundImage</a> and <a>BackgroundAlpha</a>, which each represent an image
 snapshot of the canvas under the <a>filter region</a> at the time that the <a
 href="#FilterElement"><span class="element-name">'filter'</span></a> element
 is invoked. <a>BackgroundImage</a> represents both
 the color values and alpha channel of the canvas (i.e., RGBA pixel values),
 whereas <a>BackgroundAlpha</a> represents only the
 alpha channel.</p>
 <p>Implementations <!--of SVG user agents often-->
 will often need to maintain supplemental background image buffers in order to
 support the <a>BackgroundImage</a> and <a>BackgroundAlpha</a> pseudo input images. Sometimes,
 the background image buffers will contain an in-memory copy of the
 accumulated painting operations on the current canvas.</p>
 <p>Because in-memory image buffers can take up significant system resources, <!--SVG-->
 content must explicitly indicate to the <!--SVG-->
 user agent that the document needs access to the background image before <a>BackgroundImage</a> and <a>BackgroundAlpha</a> pseudo input images can be used.
 </p>
 A background image is what's been <i>rendered before</i> the current element.
 <edit:hostreq>The host language is responsible for defining what <i>rendered before</i> in
 this context means
 .</edit:hostreq> For SVG, that uses the painter's algorithm, <i>rendered before</i> means
 all of the prior elements in pre order traversal previous to the element to
 which the filter is applied.
 <p>The property which enables access to the background image is
 <a>'enable-background'</a>:</p>
 <div class="propdef">
 <dl>
   <dt id="EnableBackgroundProperty"><span class='propdef-title prop-name'>'enable-background'</span></dt>
     <dd>
       <table summary="enable-background property" class="propinfo"
       cellspacing="0" cellpadding="0">
         <tbody>
           <tr valign="baseline">
             <td><em>Value:</em>  </td>
             <td>accumulate | new | <a class="noxref"
               href="http://www.w3.org/TR/2009/CR-CSS2-20090423/cascade.html#value-def-inherit"><span
               class="value-inst-inherit noxref">inherit</span></a></td>
           </tr>
           <tr valign="baseline">
             <td><em>Initial:</em>  </td>
             <td>accumulate</td>
           </tr>
           <tr valign="baseline">
             <td><em>Applies to:</em>  </td>
             <td>Typically elements that can contain renderable elements.
               language is responsible for defining the applicable set of
               elements.
               For SVG: <a>container elements</a></td>
           </tr>
           <tr valign="baseline">
             <td><em>Inherited:</em>  </td>
             <td>no</td>
           </tr>
           <tr valign="baseline">
             <td><em>Percentages:</em>  </td>
             <td>N/A</td>
           </tr>
           <tr valign="baseline">
             <td><em>Media:</em>  </td>
             <td>visual</td>
           </tr>
           <tr valign="baseline">
             <td><em>Animatable:</em>  </td>
             <td>no</td>
           </tr>
         </tbody>
       </table>
     </dd>
 </dl>
 </div>
 <p><a>'enable-background'</a> is only
   applicable to <a>container elements</a>
   and specifies how the <a>SVG user agent</a> manages the accumulation
   of the background image.</p>
 <p>A value of <strong>new</strong> indicates two things:</p>
 <ul>
   <li>It enables the ability of children of the current <a>container element</a>
     element to access the background image.</li>
   <li>It indicates that a new (i.e., initially transparent black) background
     image canvas is established and that (in effect) all children of the
     current <a>container element</a>
     element shall be rendered into the new background image canvas in
     addition to being rendered onto the target device.</li>
 </ul>
 <p>A meaning of <span class="attr-value">enable-background: accumulate</span> (the
 initial/default value) depends on context:</p>
 <ul>
   <li>If an ancestor <a>container element</a>
     element has a property value of <span class="attr-value">'enable-background:new'</span>, then all
     renderable child elements of the current <a>container element</a>
     element are rendered both onto the parent <a>container element</a>
     element's background image canvas and onto the target device.</li>
   <li>Otherwise, there is no current background image canvas, so it is only
     necessary to render <a>graphics elements</a>
     the renderable elements onto the target device. (No need to render to the
     background image canvas.)</li>
 </ul>
 <p>If a filter effect specifies either the <a>BackgroundImage</a> or the
   <a>BackgroundAlpha</a> pseudo input images and no
 ancestor <a>container element</a>
  element has a property value of <span class="attr-value">'enable-background:new'</span>, then the background
 image request is technically in error. Processing will proceed without
 interruption (i.e., no error message) and a transparent black image shall be
 provided in response to the request.</p>
 <h3 id="AccessBackgroundImageSVG">Accessing the background image in SVG</h3>
 <p>This section only applies to the SVG definition of enable-background.</p>
 <p>Assume you have an element E in the document and that E has a series of
 ancestors A<sub>1</sub> (its immediate parent), A<sub>2</sub>, etc. (Note:
 A<sub>0</sub> is E.) Each ancestor A<sub>i</sub> will have a corresponding
 temporary background image offscreen buffer BUF<sub>i</sub>. The contents of
 the <em>background image</em> available to a <a href="#FilterElement"><span
 class="element-name">'filter'</span></a> referenced by E is defined as
 follows:</p>
 <ul>
   <li>Find the element A<sub>i</sub> with the smallest subscript i (including
     A<sub>0</sub>=E) for which the <a href="#EnableBackgroundProperty"><span
     class="prop-name">'enable-background'</span></a> property has the value
     <span class="prop-value">new</span>. (Note: if there is no such ancestor
     element, then there is no background image available to E, in which case
     a transparent black image will be used as E's background image.)</li>
   <li>For each A<sub>i</sub> (from i=n to 1), initialize BUF<sub>i</sub> to
     transparent black. Render all children of A<sub>i</sub> up to but not
     including A<sub>i-1</sub> into BUF<sub>i</sub>. The children are painted,
     then filtered, clipped, masked and composited using the various painting,
     filtering, clipping, masking and object opacity settings on the given
     child. Any filter effects, masking and group opacity that might be set on
     A<sub>i</sub> do <em>not</em> apply when rendering the children of
     A<sub>i</sub> into BUF<sub>i</sub>.<br />
     (Note that for the case of A<sub>0</sub>=E, the graphical contents of E
     are not rendered into BUF<sub>1</sub> and thus are not part of the
     background image available to E. Instead, the graphical contents of E are
     available via the <a href="#SourceGraphic">SourceGraphic</a> and <a
     href="#SourceAlpha">SourceAlpha</a> pseudo input images.)</li>
   <li>Then, for each A<sub>i</sub> (from i=1 to n-1), composite
     BUF<sub>i</sub> into BUF<sub>i+1</sub>.</li>
   <li>The accumulated result (i.e., BUF<sub>n</sub>) represents the
     background image available to E.</li>
 </ul>
 <edit:example href="examples/enable-background-01.svg" image="yes" link="yes"/>
 <p>The example above contains five parts, described as follows:</p>
 <ol>
   <li>The first set is the reference graphic. The reference graphic consists
     of a red rectangle followed by a 50% transparent <span
     class="element-name">'g'</span>
     element. Inside the <span class="element-name">'g'</span>
     is a green circle that partially overlaps the rectangle and a a blue
     triangle that partially overlaps the circle. The three objects are then
     outlined by a rectangle stroked with a thin blue line. No filters are
     applied to the reference graphic.</li>
   <li>The second set enables background image processing and adds an empty
     <span class="element-name">'g'</span>
     element which invokes the ShiftBGAndBlur filter. This filter takes the
     current accumulated background image (i.e., the entire reference graphic)
     as input, shifts its offscreen down, blurs it, and then writes the result
     to the canvas. Note that the offscreen for the filter is initialized to
     transparent black, which allows the already rendered rectangle, circle
     and triangle to show through after the filter renders its own result to
     the canvas.</li>
   <li>The third set enables background image processing and instead invokes
     the ShiftBGAndBlur filter on the inner <span
     class="element-name">'g'</span>
     element. The accumulated background at the time the filter is applied
     contains only the red rectangle. Because the children of the inner <span
     class="element-name">'g'</span>
     (i.e., the circle and triangle) are not part of the inner <span
     class="element-name">'g'</span>
     element's background and because ShiftBGAndBlur ignores SourceGraphic,
     the children of the inner <span class="element-name">'g'</span>
     do not appear in the result.</li>
   <li>The fourth set enables background image processing and invokes the
     ShiftBGAndBlur on the <span class="element-name">'polygon'</span>
     element that draws the triangle. The accumulated background at the time
     the filter is applied contains the red rectangle plus the green circle
     ignoring the effect of the <span class="prop-name">'opacity'</span>
     property on the inner <span class="element-name">'g'</span>
     element. (Note that the blurred green circle at the bottom does not let
     the red rectangle show through on its left side. This is due to ignoring
     the effect of the <span class="prop-name">'opacity'</span>
     property.) Because the triangle itself is not part of the accumulated
     background and because ShiftBGAndBlur ignores SourceGraphic, the triangle
     does not appear in the result.</li>
   <li>The fifth set is the same as the fourth except that filter
     ShiftBGAndBlur_WithSourceGraphic is invoked instead of ShiftBGAndBlur.
     ShiftBGAndBlur_WithSourceGraphic performs the same effect as
     ShiftBGAndBlur, but then renders the SourceGraphic on top of the shifted,
     blurred background image. In this case, SourceGraphic is the blue
     triangle; thus, the result is the same as in the fourth case except that
     the blue triangle now appears.</li>
 </ol>
 </edit:with>
 <h2 id="FilterPrimitivesOverview">Filter primitives overview</h2>
 <h3 id="FilterPrimitivesOverviewIntro">Overview</h3>
 <p>This section describes the various filter primtives that can be assembled
 to achieve a particular filter effect.</p>
 <p>Unless otherwise stated, all image filters operate on premultiplied RGBA
 samples. Filters which work more naturally on non-premultiplied data
 (<a>'feColorMatrix'</a> and <a>'feComponentTransfer'</a>) will temporarily undo and redo
 premultiplication as specified. All raster effect filtering operations take 1
 to N input RGBA images, additional attributes as parameters, and produce a
 single output RGBA image.</p>
 <p>The RGBA result from each filter primitive will be clamped into the
 allowable ranges for colors and opacity values. Thus, for example, the result
 from a given <a>filter primitive</a> will have any negative color values or opacity
 values adjusted up to color/opacity of zero.</p>
 <p id="filtersColorSpace">The color space in which a particular <a>filter primitive</a> performs its
 operations is determined by the value of property <a>'color-interpolation-filters'</a> on the given <a>filter
 primitive</a>. A different property, <a>'color-interpolation'</a> determines the color space for
 other color operations. Because these two properties have different initial
 values (<a>'color-interpolation-filters'</a> has an
 initial value of <span class="prop-value">linearRGB</span> whereas <a>'color-interpolation'</a> has an initial value of <span class="prop-value">sRGB</span>), in some cases to achieve certain results
 (e.g., when coordinating gradient interpolation with a filtering operation)
 it will be necessary to explicitly set <a>'color-interpolation'</a> to <span
 class="prop-value">linearRGB</span> or <a>'color-interpolation-filters'</a> to <span
 class="prop-value">sRGB</span> on particular elements. Note that the examples
 below do not explicitly set either <a>'color-interpolation'</a> or <a>'color-interpolation-filters'</a>, so the initial values for these properties apply to the examples.</p>
 <p><span class="requirement" id="assert_undefinedPixels">Sometimes <a>filter primitives</a> result in undefined pixels. For example,
 filter primitive <a>'feOffset'</a> can shift an image down and to the
 right, leaving undefined pixels at the top and left. In these cases, the
 undefined pixels are set to transparent black.</span></p>
 <h3 id="CommonAttributes">Common attributes</h3>
 <p>The following attributes are available for most of the filter
 primitives:</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="FilterPrimitiveXAttribute">
   <span class="adef">x</span> = "<em><a>&lt;coordinate&gt;</a></em>"</dt>
     <dd><p>The minimum x coordinate for the subregion which restricts
       calculation and rendering of the given <a>filter primitive</a>. See <a>filter primitive subregion</a>.</p>
     <p>The <a>lacuna value</a> for <span class="attr-name">x</span> is <span class="attr-value">0%</span>.</p>
         <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="FilterPrimitiveYAttribute">
   <span class="adef">y</span> = "<em><a>&lt;coordinate&gt;</a></em>"</dt>
     <dd><p>The minimum y coordinate for the subregion which restricts
       calculation and rendering of the given <a>filter primitive</a>. See <a>filter primitive subregion</a>. </p>
     <p>The <a>lacuna value</a> for <span class="attr-name">y</span> is <span class="attr-value">0%</span>.</p>
         <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="FilterPrimitiveWidthAttribute">
   <span class="adef">width</span> = "<em><a>&lt;length&gt;</a></em>"</dt>
     <dd><p>The width of the subregion which restricts calculation and rendering
       of the given <a>filter primitive</a>. See <a>filter primitive subregion</a>.</p>
       <p>A negative or zero value disables the effect of the given filter
       primitive (i.e., the result is a transparent black image).</p>
     <p>The <a>lacuna value</a> for <span class="attr-name">width</span> is <span class="attr-value">100%</span>.</p>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="FilterPrimitiveHeightAttribute">
   <span class="adef">height</span> = "<em><a>&lt;length&gt;</a></em>"</dt>
     <dd><p>The height of the subregion which restricts calculation and rendering
       of the given <a>filter primitive</a>. See <a>filter primitive subregion</a>.</p>
       <p>A negative or zero value disables the effect of the given filter
       primitive (i.e., the result is a transparent black image).</p>
     <p>The <a>lacuna value</a> for <span class="attr-name">height</span> is <span class="attr-value">100%</span>.</p>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="FilterPrimitiveResultAttribute">
   <span class="adef">result</span> =
   "<em><a>&lt;filter-primitive-reference&gt;</a></em>"</dt>
     <dd><p>Assigned name for this <a>filter primitive</a>. If supplied, then graphics
       that result from processing this <a>filter primitive</a> can be referenced by
       an <a>'in'</a> attribute on a subsequent filter
       primitive within the same <a>'filter element'</a> element. If no value is
       provided, the output will only be available for re-use as the implicit
       input into the next <a>filter primitive</a> if that <a>filter primitive</a> provides
       no value for its <a>'in'</a> attribute.</p>
       <p>Note that a <a>&lt;filter-primitive-reference&gt;</a> is not an XML
       ID; instead, a <a>&lt;filter-primitive-reference&gt;</a> is only
       meaningful within a given <a>'filter element'</a> element and thus have only
       local scope. It is legal for the same
       <a>&lt;filter-primitive-reference&gt;</a> to appear multiple times
       within the same <a>'filter element'</a> element. When referenced, the
       <a>&lt;filter-primitive-reference&gt;</a> will use the closest
       preceding <a>filter primitive</a> with the given result.</p>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="FilterPrimitiveInAttribute">
   <span class="adef">in</span> = "<em><a>SourceGraphic</a> | <a>SourceAlpha</a> | <a>BackgroundImage</a> | <a>BackgroundAlpha</a> | <a>FillPaint</a> | <a>StrokePaint</a> |
   <a>&lt;filter-primitive-reference&gt;</a></em>"</dt>
     <dd><p>Identifies input for the given filter primitive. The value can be
       either one of six keywords or can be a string which matches a previous
       <a>'feBlend/result'</a> attribute value within the same <a>'filter element'</a>
       element. If no value is provided and this is the first <a>filter primitive</a>,
   then this <a>filter primitive</a> will use <a>SourceGraphic</a>
       as its input. If no value is provided and this is a subsequent <a>filter primitive</a>,
   then this <a>filter primitive</a> will use the result from the
       previous <a>filter primitive</a> as its input.</p>
       <p>If the value for <span class="attr-name">result</span> appears
       multiple times within a given <a>'filter element'</a> element, then a reference to
       that result will use the closest preceding <a>filter primitive</a> with the
       given value for attribute <a>'feBlend/result'</a>.
       Forward references to results are not allowed, and will be treated as
       if no result was specified. </p>
       <p>Definitions for the six keywords: </p>
       <dl>
         <dt id="SourceGraphic"><span class="attr-value">SourceGraphic</span></dt>
           <dd><p>This keyword represents the graphics elements
             that were the original input into the <a>'filter element'</a> element. For raster
             effects <a>filter primitives</a>, the graphics elements
             will be rasterized into an initially clear RGBA raster in image
             space. Pixels left untouched by the original graphic will be left
             clear. The image is specified to be rendered in linear RGBA
             pixels. The alpha channel of this image captures any
             anti-aliasing specified by SVG. (Since the raster is linear, the
             alpha channel of this image will represent the exact percent
             coverage of each pixel.)</p></dd>
         <dt id="SourceAlpha"><span class="attr-value">SourceAlpha</span></dt>
           <dd><p>This keyword represents the graphics elements
             that were the original input into the <a>'filter element'</a> element.
       <a>SourceAlpha</a> has all of the same rules
             as <a>SourceGraphic</a> except that only the
             alpha channel is used. The input image is an RGBA image
             consisting of implicitly black color values for the RGB channels,
             but whose alpha channel is the same as <a>SourceGraphic</a>.</p>
       <p class="note implementation">If this option is
             used, then some implementations might need to rasterize the
             graphics elements
             in order to extract the alpha channel.</p>
     </dd>
         <dt id="BackgroundImage"><span class="attr-value">BackgroundImage</span></dt>
           <dd><p>This keyword represents an image snapshot of the canvas under
             the <a>filter region</a> at the time that the <a>'filter element'</a> element was invoked. See
             <a href="#AccessingBackgroundImage">accessing the background
             image</a>.</p>
       </dd>
         <dt id="BackgroundAlpha"><span class="attr-value">BackgroundAlpha</span></dt>
           <dd><p>Same as <a>BackgroundImage</a> except
             only the alpha channel is used. See <a>SourceAlpha</a> and <a
             href="#AccessingBackgroundImage">accessing the background
             image</a>.</p>
       </dd>
         <dt id="FillPaint"><span class="attr-value">FillPaint</span></dt>
           <dd>
       <p>This keyword represents the target element <i>rendered filled</i>.</p>
       <p>For svg this keyword represents the value of the <a>'fill'</a>
             property on the target element for the filter effect.</p>
       <p>For non-SVG cases <a>FillPaint</a> generates a transparent black image.
         <span class="specissue">ISSUE: Consider whether this should be e.g the CSS bounding box filled with the current color, or if it makes sense to use the 'fill' property for this case too.</span>
       </p>
       <p class="note authoring">Note that text is generally painted filled, not stroked.</p>
       <p>The <a>FillPaint</a> image has conceptually infinite extent.
       Frequently this image is opaque everywhere, but it might not be if the "paint"
       itself has alpha, as in the case of a gradient or pattern which
       itself includes transparent or semi-transparent parts.</p>
       </dd>
         <dt id="StrokePaint"><span class="attr-value">StrokePaint</span></dt>
           <dd>
       <p>This keyword represents the target element <i>rendered stroked</i>.</p>
       <p>For svg this keyword represents the value of the <a>'stroke'</a>
          on the target element for the filter effect.</p>
       <p>For non-SVG cases <a>StrokePaint</a> generates a transparent black image.
         <span class="specissue">ISSUE: Consider whether this should be e.g the CSS bounding box filled with the one of the border colors, or if it makes sense to use the 'stroke' property for this case too.</span>
       </p>
       <p class="note authoring">Note that text is generally painted filled, not stroked.</p>
         <p>The <a>StrokePaint</a> image has conceptually infinite extent.
       Frequently this image is opaque everywhere, but it
       might not be if the "paint"
       itself has alpha, as in the case of a gradient or pattern which
       itself includes transparent or semi-transparent parts.
       </p>
       </dd>
         </dl>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   </dl>
 </div>
 <h3 id="FilterPrimitiveSubRegion">Filter primitive subregion</h3>
 <edit:with element="feBlend">
 <p>
 All <a>filter primitives</a> have attributes <a>'x'</a>, <a>'y'</a>,
 <a>'width'</a> and <a>'height'</a> which
 together identify a subregion which restricts calculation and rendering of
 the given <a>filter primitive</a>. The <a>'x'</a>, <a>'y'</a>,
 <a>'width'</a> and <a>'height'</a> attributes are defined
 according to the same rules as other <a>filter primitives</a>' coordinate and length
 attributes and thus represent values in the coordinate system established by
 attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a> element.
 </p>
 <p><a>'x'</a>, <a>'y'</a>,
 <a>'width'</a> and <a>'height'</a> default to the union (i.e., tightest fitting bounding
 box) of the subregions defined for all referenced nodes. If there are no
 referenced nodes (e.g., for <a>'feImage'</a> or <a>'feTurbulence'</a>), or one or more of the
 referenced nodes is a standard input (one of <a>SourceGraphic</a>, <a>SourceAlpha</a>, <a>BackgroundImage</a>, <a>BackgroundAlpha</a>,
 <a href="#FillPaint"><span class="attr-value">FillPaint</span></a> or <a
 href="#StrokePaint"><span class="attr-value">StrokePaint</span></a>), or for
 <a href="#feTileElement"><span class="element-name">'feTile'</span></a>
 (which is special because its principal function is to replicate the
 referenced node in X and Y and thereby produce a usually larger result), the
 default subregion is <span class="attr-value">0%, 0%, 100%, 100%</span>,
 where as a special-case the percentages are relative to the dimensions of the <a>filter region</a>,
 thus making the default <a>filter primitive subregion</a> equal to the <a>filter region</a>.
 </p>
 <p>If the <a>filter primitive
 subregion</a> has a negative or zero width or height, the effect of the filter
 primitive is disabled. </p>
 <p>The <a>filter primitive subregion</a> act as a hard clip clipping rectangle on both the
 filter primitive's input image(s) and the filter primitive result.</p>
 <p class="specissue">ISSUE: Consider making it possible to do select between clip-input, clip-output, clip-both or none.</p>
 <p>All intermediate offscreens are defined to not exceed the intersection of
 the <a>filter primitive subregion</a> with the <a>filter region</a>.
 The <a>filter region</a> and any of the filter primitive subregions are
 to be set up such that all offscreens are made big enough to accommodate any
 pixels which even partly intersect with either the <a>filter region</a> or the
 filter primitive subregions.</p>
 <p><a>'feTile'</a> references a previous filter primitive and then stitches the tiles together
 based on the <a>filter primitive subregion</a> of the referenced filter primitive in
 order to fill its own <a>filter primitive subregion</a>.</p>
 <edit:example href="examples/filtersubregion00.svg" image="yes" link="yes"/>
 <p>
 In the example above there are three rects that each have a cross and a circle in them.
 The circle element in each one has a different filter applied, but with the same <a>filter primitive subregion</a>.
 The filter output should be limited to the <a>filter primitive subregion</a>, so you should never see the circles
 themselves, just the rects that make up the <a>filter primitive subregion</a>.
 </p>
 <ul>
 <li>
 The upper left rect shows an <a>'feFlood'</a> with <span class="attr-name">flood-opacity</span>="<span class="attr-value">75%</span>" so the cross should be visible through the green rect in the middle.
 </li>
 <li>
 The lower left rect shows an <a>'feMerge'</a> that merges <a>SourceGraphic</a> with <a>FillPaint</a>. Since the circle has <span class="attr-name">fill-opacity</span>="<span class="attr-value">0.5</span>" it will also be transparent so that the cross is visible through the green rect in the middle.
 </li>
 <li>The upper right rect shows an <a>'feBlend'</a> that has <span class="attr-name">mode</span>="<span class="attr-value">multiply</span>". Since the circle in this case isn't transparent the result is totally opaque. The rect should be dark green and the cross should not be visible through it.
 </li>
 </ul>
 </edit:with>
 <h2 id="LightSourceDefinitions">Light source elements and properties</h2>
 <h3 id="LightSourceIntro">Introduction</h3>
 <p>The following sections define the elements that define a light source, <a>'feDistantLight'</a>,
 <a>'fePointLight'</a> and <a>'feSpotLight'</a>,
 and property <a>'lighting-color'</a>, which defines the color of the
 light.</p>
 <h3 id="feDistantLightElement">Light source <span class="element-name">'feDistantLight'</span></h3>
 <edit:elementsummary name='feDistantLight'/>
 <edit:with element='feDistantLight'>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feDistantLightAzimuthAttribute"><span
   class="adef">azimuth</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Direction angle for the light source on the XY plane (clockwise), in
       degrees from the x axis.<br />
       The <a>lacuna value</a> for <a>'azimuth'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feDistantLightElevationAttribute"><span
   class="adef">elevation</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Direction angle for the light source from the XY plane towards the Z-axis, in degrees.
     Note that the positive Z-axis points towards the viewer.<br />
     The <a>lacuna value</a> for <a>'elevation'</a> is <span class="attr-value">0</span>.<br />
     <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <p>
   The following diagram illustrates the angles which <a>'azimuth'</a>
   and <a>'elevation'</a> represent in an XYZ coordinate system.
 </p>
 <img src="examples/azimuth-elevation.png" alt="Angles which azimuth and elevation represent" width="480" height="360" />
 </edit:with>
 <h3 id="fePointLightElement">Light source <span class="element-name">'fePointLight'</span></h3>
 <edit:elementsummary name='fePointLight'/>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="fePointLightXAttribute"><span
   class="adef">x</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>X location for the light source in the coordinate system established
       by attribute <a>'filter/primitiveUnits'</a> on the <a
       href="#FilterElement"><span class="element-name">'filter'</span></a>
       element.<br />
       The <a>lacuna value</a> for <a>'fePointLight/x'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="fePointLightYAttribute"><span
   class="adef">y</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Y location for the light source in the coordinate system established
       by attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a>
       element.<br />
       The <a>lacuna value</a> for <a>'fePointLight/y'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="fePointLightZAttribute"><span
   class="adef">z</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Z location for the light source in the coordinate system established
       by attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a>
       element, assuming that, in the <a>initial coordinate system</a>
       , the positive Z-axis comes out towards the person viewing the content
       and assuming that one unit along the Z-axis equals <a href="http://www.w3.org/TR/SVG11/coords.html#Units_viewport_percentage">one unit in X and Y</a>.<br />
       The <a>lacuna value</a> for <a>'fePointLight/z'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <h3 id="feSpotLightElement">Light source <span class="element-name">'feSpotLight'</span></h3>
 <edit:elementsummary name='feSpotLight'/>
 <edit:with element='feSpotLight'>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feSpotLightXAttribute"><span
   class="adef">x</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>X location for the light source in the coordinate system established
       by attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a>
       element.<br />
       The <a>lacuna value</a> for <a>'feSpotLight/x'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpotLightYAttribute"><span
   class="adef">y</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Y location for the light source in the coordinate system established
       by attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a>
       element.<br />
       The <a>lacuna value</a> for <a>'feSpotLight/y'</a> is <span class="attr-value">0</span>.<br />
      <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpotLightZAttribute"><span
   class="adef">z</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Z location for the light source in the coordinate system established
       by attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a>
       element, assuming that, in the <a>initial coordinate system</a>
       , the positive Z-axis comes out towards the person viewing the content
       and assuming that one unit along the Z-axis equals <a href="http://www.w3.org/TR/SVG11/coords.html#Units_viewport_percentage">one unit in X and Y</a>.<br />
       The <a>lacuna value</a> for <a>'feSpotLight/z'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpotLightPointsAtXAttribute"><span
   class="adef">pointsAtX</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>X location in the coordinate system established by attribute <a>'filter/primitiveUnits'</a>
       on the <a>'filter element'</a>
       element of the point at which the light source is pointing.<br />
       The <a>lacuna value</a> for <a>'pointsAtX'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpotLightPointsAtYAttribute"><span
   class="adef">pointsAtY</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Y location in the coordinate system established by attribute <a>'filter/primitiveUnits'</a>
       on the <a>'filter element'</a> element of the point at which the light source is pointing.<br />
       The <a>lacuna value</a> for <a>'pointsAtY'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpotLightPointsAtZAttribute"><span
   class="adef">pointsAtZ</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Z location in the coordinate system established by the
         attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a> element of
         the point at which the light source is pointing, assuming that, in the
         <a>initial coordinate system</a>, the positive Z-axis comes out
          towards the person viewing the content and assuming that
          one unit along the Z-axis equals
          <a href="http://www.w3.org/TR/SVG11/coords.html#Units_viewport_percentage">
          one unit in X and Y</a>.<br />
       The <a>lacuna value</a> for <a>'pointsAtZ'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpotLightSpecularExponentAttribute"><span
   class="adef">specularExponent</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Exponent value controlling the focus for the light source.<br />
       The <a>lacuna value</a> for <a>'specularExponent'</a> is <span class="attr-value">1</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpotLightLimitingConeAngleAttribute"><span
   class="adef">limitingConeAngle</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>A limiting cone which restricts the region where the light is
       projected. No light is projected outside the cone. <span
       class="attr-name">limitingConeAngle</span> represents the angle in degrees between
       the spot light axis (i.e. the axis between the light source and the
       point to which it is pointing at) and the spot light cone. <span class="requirement" id="assert_userAgentLightingConeSmoothing">User agents
       should apply a smoothing technique such as anti-aliasing at the
       boundary of the cone.</span><br />
       If no value is specified, then no limiting cone will be applied.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 </edit:with>
 <h3 id="LightingColorProperty">The <span class="prop-name">'lighting-color'</span> property</h3>
 <p>The <a>'lighting-color'</a> property defines the
 color of the light source for <a>filter primitives</a> <a>'feDiffuseLighting'</a> and <a>'feSpecularLighting'</a>.</p>
 <div class="propdef">
 <dl>
   <dt><span class="index-def" title="'margin-top'"><a
   id="propdef-lighting-color" name="propdef-lighting-color"
   class="propdef-title"><span
   class="prop-name">'lighting-color'</span></a></span></dt>
     <dd>
       <table summary="lighting-color property" class="propinfo"
       cellspacing="0" cellpadding="0">
         <tbody>
           <tr valign="baseline">
             <td><em>Value:</em>  </td>
             <td>currentColor |<br />
               <a>&lt;color&gt;</a>
               [<a>&lt;icccolor&gt;</a>] |<br />
               <a class="noxref"
               href="http://www.w3.org/TR/2009/CR-CSS2-20090423/cascade.html#value-def-inherit"><span
               class="value-inst-inherit noxref">inherit</span></a></td>
           </tr>
           <tr valign="baseline">
             <td><em>Initial:</em>  </td>
             <td>white</td>
           </tr>
           <tr valign="baseline">
             <td><em>Applies to:</em>  </td>
             <td><a>'feDiffuseLighting'</a> and <a>'feSpecularLighting'</a>
             elements</td>
           </tr>
           <tr valign="baseline">
             <td><em>Inherited:</em>  </td>
             <td>no</td>
           </tr>
           <tr valign="baseline">
             <td><em>Percentages:</em>  </td>
             <td>N/A</td>
           </tr>
           <tr valign="baseline">
             <td><em>Media:</em>  </td>
             <td>visual</td>
           </tr>
           <tr valign="baseline">
             <td><em>Animatable:</em>  </td>
             <td>yes</td>
           </tr>
         </tbody>
       </table>
     </dd>
 </dl>
 </div>
 <h2 id="feBlendElement">Filter primitive <span class="element-name">'feBlend'</span></h2>
 <edit:elementsummary name='feBlend'/>
 <edit:with element='feBlend'>
 <p>This filter composites two objects together using commonly used imaging
 software blending modes. It performs a pixel-wise combination of two input
 images.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feBlendModeAttribute"><span
   class="adef">mode</span> = "<em>normal | multiply | screen | darken |
   lighten</em>"</dt>
     <dd>One of the image blending modes (see <a
       href="#BlendingTable">table</a> below). The <a>lacuna value</a> for <a>'mode'</a> is <span class="attr-value">normal</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feBlendIn2Attribute"><span
   class="adef">in2</span> = "<em>(see <a
   href="#FilterPrimitiveInAttribute"><span class="attr-name">in</span></a>
   attribute)</em>"</dt>
     <dd>The second input image to the blending operation. This attribute can
       take on the same values as the <a
       href="#FilterPrimitiveInAttribute"><span
       class="attr-name">in</span></a> attribute.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <p>For all feBlend modes, the result opacity is computed as follows:</p>
 <pre>qr = 1 - (1-qa)*(1-qb)</pre>
 <p>For the compositing formulas below, the following definitions apply:</p>
 <pre>image A = in
 image B = in2
 cr = Result color (RGB) - premultiplied
 qa = Opacity value at a given pixel for image A
 qb = Opacity value at a given pixel for image B
 ca = Color (RGB) at a given pixel for image A - premultiplied
 cb = Color (RGB) at a given pixel for image B - premultiplied </pre>
 <p id="BlendingTable">The following table
 provides the list of available image blending modes:</p>
 <div class="note-editor">
 ED: make table look nicer</div>
 <table summary="blending modes" width="500" border="1">
   <tbody>
     <tr>
       <td>Image Blending Mode</td>
       <td>Formula for computing result color</td>
     </tr>
     <tr>
       <td>normal</td>
       <td>cr = (1 - qa) * cb + ca</td>
     </tr>
     <tr>
       <td>multiply</td>
       <td>cr = (1-qa)*cb + (1-qb)*ca + ca*cb</td>
     </tr>
     <tr>
       <td>screen</td>
       <td>cr = cb + ca - ca * cb</td>
     </tr>
     <tr>
       <td>darken</td>
       <td>cr = Min ((1 - qa) * cb + ca, (1 - qb) * ca + cb)</td>
     </tr>
     <tr>
       <td>lighten</td>
       <td>cr = Max ((1 - qa) * cb + ca, (1 - qb) * ca + cb)</td>
     </tr>
   </tbody>
 </table>
 <p>The <span class="attr-value">'normal'</span> blend mode is equivalent to <a
 href="#feCompositeOperatorAttribute"><span
 class="attr-value">operator="over"</span></a> on the <a>'feComposite'</a>
 filter primitive, matches the blending method used by <a>'feMerge'</a> and matches
 the <a>simple alpha compositing</a> technique used in SVG for all compositing outside of filter effects.</p>
 </edit:with>
 <edit:example href="examples/feBlend.svg" image="yes" link="yes"/>
 <h2 id="feColorMatrixElement">Filter primitive <span class="element-name">'feColorMatrix'</span></h2>
 <edit:elementsummary name='feColorMatrix'/>
 <p>This filter applies a matrix transformation:</p>
 <object data="mathml/feColorMatrix00.mml" type="application/mathml+xml" width="100%" height="140">
 <pre>| R' |     | a00 a01 a02 a03 a04 |   | R |
 | G' |     | a10 a11 a12 a13 a14 |   | G |
 | B' |  =  | a20 a21 a22 a23 a24 | * | B |
 | A' |     | a30 a31 a32 a33 a34 |   | A |
 | 1  |     |  0   0   0   0   1  |   | 1 |</pre>
 </object>
 <p>on the RGBA color and alpha values of every pixel on the input graphics to
 produce a result with a new set of RGBA color and alpha values.</p>
 <p>The calculations are performed on non-premultiplied color values. If the
 input graphics consists of premultiplied color values, those values are
 automatically converted into non-premultiplied color values for this
 operation.</p>
 <p>These matrices often perform an identity mapping in the alpha channel. If
 that is the case, an implementation can avoid the costly undoing and redoing
 of the premultiplication for all pixels with A = 1.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feColorMatrixTypeAttribute"><span class="adef">type</span> =
   "<em>matrix | saturate | hueRotate | luminanceToAlpha</em>"</dt>
     <dd>Indicates the type of matrix operation. The keyword <span
       class="attr-name">matrix</span> indicates that a full 5x4 matrix of
       values will be provided. The other keywords represent convenience
       shortcuts to allow commonly used color operations to be performed
       without specifying a complete matrix.
       The <a>lacuna value</a> for <a>'type'</a> is <span class="attr-value">matrix</span>.
       <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feColorMatrixValuesAttribute"><span class="adef">values</span> =
   "<em>list of <a>&lt;number&gt;</a>s</em>"</dt>
     <dd>The contents of <span class="attr-name">values</span> depends on the
       value of attribute <a href="#feColorMatrixTypeAttribute"><span
       class="attr-name">type</span></a>:
       <ul>
         <li>For <span class="attr-value">type="matrix"</span>, <span
           class="attr-name">values</span> is a list of 20 matrix values (a00
           a01 a02 a03 a04 a10 a11 ... a34), separated by whitespace and/or a
           comma. For example, the identity matrix could be expressed as:
           <pre>type="matrix"
 values="1 0 0 0 0  0 1 0 0 0  0 0 1 0 0  0 0 0 1 0"</pre>
         </li>
         <li>For <span class="attr-value">type="saturate"</span>, <span
           class="attr-name">values</span> is a single real number value (0 to
 ). A <span class="attr-value">saturate</span> operation is
           equivalent to the following matrix operation:
       <p>
       <object data="mathml/feColorMatrix01.mml" type="application/mathml+xml" width="100%" height="130">
           <pre>| R' |     | (0.2127 + 0.7873s)  (0.7152 - 0.7152s)  (0.0722 - 0.0722s) 0  0 |   | R |
 | G' |     | (0.2127 - 0.2127s)  (0.7152 + 0.2848s)  (0.0722 - 0.0722s) 0  0 |   | G |
 | B' |  =  | (0.2127 - 0.2127s)  (0.7152 - 0.7152s)  (0.0722 + 0.9278s) 0  0 | * | B |
 | A' |     |           0                   0                   0        1  0 |   | A |
 | 1  |     |           0                   0                   0        0  1 |   | 1 |</pre>
       </object>
     </p>
         </li>
         <li>For <span class="attr-value">type="hueRotate"</span>, <span
           class="attr-name">values</span> is a single one real number value
           (degrees). A <span class="attr-value">hueRotate</span> operation is
           equivalent to the following matrix operation:
       <p>
       <object data="mathml/feColorMatrix02.mml" type="application/mathml+xml" width="100%" height="130">
           <pre>| R' |     | a00  a01  a02  0  0 |   | R |
 | G' |     | a10  a11  a12  0  0 |   | G |
 | B' |  =  | a20  a21  a22  0  0 | * | B |
 | A' |     | 0    0    0    1  0 |   | A |
 | 1  |     | 0    0    0    0  1 |   | 1 |</pre>
     </object>
     </p>
           where the terms a00, a01, etc. are calculated as follows:
       <p>
     <object data="mathml/feColorMatrix03.mml" type="application/mathml+xml" width="100%" height="230">
           <pre>| a00 a01 a02 |     [0.2127 0.7152 0.0722]
 | a10 a11 a12 | =   [0.2127 0.7152 0.0722] +
 | a20 a21 a22 |     [0.2127 0.7152 0.0722]
                                             [ 0.7873 -0.7152 -0.0722]
                     cos(hueRotate value) *  [-0.2127  0.2848 -0.0722] +
                                             [-0.2127 -0.7152  0.9278]
                                             [-0.2127 -0.7152  0.9278]
                     sin(hueRotate value) *  [ 0.143   0.140  -0.283 ]
                                             [-0.7873  0.7152  0.0722]</pre>
     </object>
     </p>
           Thus, the upper left term of the hue matrix turns out to be:
       <p>
     <object data="mathml/feColorMatrix04.mml" type="application/mathml+xml" width="100%" height="30">
           <pre>.2127 + cos(hueRotate value) * 0.7873 - sin(hueRotate value) * 0.2127</pre>
       </object>
       </p>
         </li>
         <li>For <span class="attr-value">type="luminanceToAlpha"</span>,
           <span class="attr-name">values</span> is not applicable. A <span
           class="attr-value">luminanceToAlpha</span> operation is equivalent
           to the following matrix operation:
       <p>
       <object data="mathml/feColorMatrix05.mml" type="application/mathml+xml" width="100%" height="130">
           <pre>   | R' |     |      0        0        0  0  0 |   | R |
    | G' |     |      0        0        0  0  0 |   | G |
    | B' |  =  |      0        0        0  0  0 | * | B |
    | A' |     | 0.2127   0.7152   0.0722  0  0 |   | A |
    | 1  |     |      0        0        0  0  1 |   | 1 |</pre>
    </object>
    </p>
         </li>
       </ul>
       If the attribute is not specified, then the default behavior depends on
       the value of attribute <a>'feColorMatrix/type'</a>. If <span
       class="attr-value">type="matrix"</span>, then this attribute defaults
       to the identity matrix. If <span
       class="attr-value">type="saturate"</span>, then this attribute defaults
       to the value <span class="attr-value">1</span>, which results in the
       identity matrix. If <span class="attr-value">type="hueRotate"</span>,
       then this attribute defaults to the value <span
       class="attr-value">0</span>, which results in the identity matrix.<br />
       <span class="anim-target">Animatable: yes.</span> </dd>
 </dl>
 </div>
 <edit:example href="examples/feColorMatrix.svg" image="yes" link="yes"/>
 <h2 id="feComponentTransferElement">Filter primitive <span class="element-name">'feComponentTransfer'</span></h2>
 <edit:elementsummary name='feComponentTransfer'/>
 <p>This filter primitive performs component-wise remapping of data as
 follows:</p>
 <pre>R' = <a href="#feFuncRElement">feFuncR</a>( R )
 G' = <a href="#feFuncGElement">feFuncG</a>( G )
 B' = <a href="#feFuncBElement">feFuncB</a>( B )
 A' = <a href="#feFuncAElement">feFuncA</a>( A )</pre>
 <p>for every pixel. It allows operations like brightness adjustment, contrast
 adjustment, color balance or thresholding.</p>
 <p>The calculations are performed on non-premultiplied color values. If the
 input graphics consists of premultiplied color values, those values are
 automatically converted into non-premultiplied color values for this
 operation. (Note that the undoing and redoing of the premultiplication can be
 avoided if <a>'feFuncA'</a> is the identity transform
 and all alpha values on the source graphic are set to 1.)</p>
 <p>The child elements of a <a>'feComponentTransfer'</a> element specify the
 transfer functions for the four channels:</p>
 <ul id="transferFuncElements">
   <li><a>'feFuncR'</a> — transfer function for the red component of the input graphic</li>
   <li><a>'feFuncG'</a> — transfer function for the green component of the input graphic</li>
   <li><a>'feFuncB'</a> — transfer function for the blue component of the input graphic</li>
   <li><a>'feFuncA'</a> — transfer function for the alpha component of the input graphic</li>
 </ul>
 <p>The following rules apply to the processing of the <a>'feComponentTransfer'</a> element:</p>
 <ul>
   <li>If more than one <a>transfer function element</a> of the same kind is specified, the last occurrence is to be used.</li>
   <li>If any of the <a>transfer function elements</a> are unspecified, the <a>'feComponentTransfer'</a> must be processed as if those <a>transfer function elements</a> were specified with their <a>'type'</a> attributes set to <span class="attr-value">'identity'</span>.</li>
 </ul>
 <edit:with element='feFuncR'>
 <div id='feFuncRElement'>
 <edit:elementsummary name='feFuncR'/>
 </div>
 <div id='feFuncGElement'>
 <edit:elementsummary name='feFuncG'/>
 </div>
 <div id='feFuncBElement'>
 <edit:elementsummary name='feFuncB'/>
 </div>
 <div id='feFuncAElement'>
 <edit:elementsummary name='feFuncA'/>
 </div>
 <p id="TransferFunctionElementAttributes">The attributes below are the
 <span class='SVG-TermDefine'>transfer function element attributes</span>,
 which apply to the <a>transfer function elements</a>.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feComponentTransferTypeAttribute"><span class="adef">type</span>
   = "<em>identity | table | discrete | linear | gamma</em>"</dt>
     <dd><p>Indicates the type of component transfer function. The type of
       function determines the applicability of the other attributes.</p>
       <p>In the following, C is the initial component (e.g.,
          <a>'feFuncR'</a>), C' is the remapped component; both
          in the closed interval [0,1].</p>
       <ul>
         <li>For <span class="attr-value">identity</span>:
           <pre>C' = C</pre>
         </li>
         <li>For <span class="attr-value">table</span>, the function is
           defined by linear interpolation
           between values given in the attribute
           <a>'tableValues'</a>. The table has <em>n+1</em>
           values (i.e., v<sub>0</sub> to v<sub>n</sub>)
           specifying the start and end values for <em>n</em>
           evenly sized interpolation regions. Interpolations
           use the following formula:
           <p>For a value <code>C &lt; 1</code> find <code>k</code> such that:</p>
           <p class="filterformula">k/n &lt;= C &lt; (k+1)/n</p>
           <p>The result <code>C'</code> is given by:</p>
           <p class="filterformula">C' = v<sub>k</sub> + (C - k/n)*n * (v<sub>k+1</sub> - v<sub>k</sub>)</p>
           <p>If <code>C = 1</code> then:</p>
           <p class="filterformula">C' = v<sub>n</sub>.</p>
         </li>
         <li>For <span class="attr-value">discrete</span>, the function is defined by the step function
           given in the attribute <a>'tableValues'</a>, which provides a list of
           <em>n</em> values (i.e., v<sub>0</sub> to v<sub>n-1</sub>) in order
           to identify a step function consisting of <em>n</em> steps. The
           step function is defined by the following formula:
           <p>For a value <code>C &lt; 1</code> find <code>k</code> such that:</p>
           <p class="filterformula">k/n &lt;= C &lt; (k+1)/n</p>
           <p>For a value <code>C</code> pick a <code>k</code> such that:</p>
           <p class="filterformula">k/N &lt;= C &lt; (k+1)/N</p>
           <p>The result <code>C'</code> is given by:</p>
           <p class="filterformula">C' = v<sub>k</sub></p>
           <p>If <code>C = 1</code> then:</p>
           <p class="filterformula">C' = v<sub>n-1</sub>.</p>
         </li>
         <li>For <span class="attr-value">linear</span>, the function is
           defined by the following linear equation:
           <p class="filterformula">C' = <a
           href="#feComponentTransferSlopeAttribute"><span
           class="attr-name">slope</span></a> * C + <a
           href="#feComponentTransferInterceptAttribute"><span
           class="attr-name">intercept</span></a></p>
         </li>
         <li>For <span class="attr-value">gamma</span>, the function is
           defined by the following exponential function:
           <p class="filterformula">C' = <a
           href="#feComponentTransferAmplitudeAttribute"><span
           class="attr-name">amplitude</span></a> * pow(C, <a
           href="#feComponentTransferExponentAttribute"><span
           class="attr-name">exponent</span></a>) + <a
           href="#feComponentTransferOffsetAttribute"><span
           class="attr-name">offset</span></a></p>
         </li>
       </ul>
       <span class="anim-target">Animatable: yes.</span> </dd>
   <dt id="feComponentTransferTableValuesAttribute"><span
   class="adef">tableValues</span> = "<em>(list of <a>&lt;number&gt;</a>s)</em>"</dt>
     <dd>When <span class="attr-value">type="table"</span>, the list of
       <a>&lt;number&gt;</a>
       s <em>v0,v1,...vn</em>, separated by white space and/or a comma, which
       define the lookup table. An empty list results in an identity transfer
       function. If the attribute is not specified, then the effect is as if
       an empty list were provided.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feComponentTransferSlopeAttribute"><span
   class="adef">slope</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>When <span class="attr-value">type="linear"</span>, the slope of the
       linear function.<br />
       The <a>lacuna value</a> for <a>'slope'</a> is <span class="attr-value">1</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feComponentTransferInterceptAttribute"><span
   class="adef">intercept</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>When <span class="attr-value">type="linear"</span>, the intercept of
       the linear function.<br />
       The <a>lacuna value</a> for <a>'intercept'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feComponentTransferAmplitudeAttribute"><span
   class="adef">amplitude</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>When <span class="attr-value">type="gamma"</span>, the amplitude of
       the gamma function.<br />
       The <a>lacuna value</a> for <a>'amplitude'</a> is <span class="attr-value">1</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feComponentTransferExponentAttribute"><span
   class="adef">exponent</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>When <span class="attr-value">type="gamma"</span>, the exponent of
       the gamma function.<br />
       The <a>lacuna value</a> for <a>'exponent'</a> is <span class="attr-value">1</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feComponentTransferOffsetAttribute"><span
   class="adef">offset</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>When <span class="attr-value">type="gamma"</span>, the offset of the
       gamma function.<br />
       The <a>lacuna value</a> for <a>'offset'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 </edit:with>
 <edit:example href="examples/feComponentTransfer.svg" image="yes" link="yes"/>
 <h2 id="feCompositeElement">Filter primitive <span class="element-name">'feComposite'</span></h2>
 <edit:elementsummary name='feComposite'/>
 <edit:with element='feComposite'>
 <p>This filter performs the combination of the two input images pixel-wise in
 image space using one of the Porter-Duff [<a
 href="#ref-PORTERDUFF">PORTERDUFF</a>] compositing operations: <em>over, in,
 atop, out, xor</em> [<a href="#ref-SVG-COMPOSITING">SVG-COMPOSITING</a>]. Additionally, a component-wise <em>arithmetic</em>
 operation (with the result clamped between [0..1]) can be applied.</p>
 <p>The <em>arithmetic</em> operation is useful for combining the output from
 the <a>'feDiffuseLighting'</a> and <a>'feSpecularLighting'</a> filters with texture
 data. It is also useful for implementing <em>dissolve</em>. If the
 <em>arithmetic</em> operation is chosen, each result pixel is computed using
 the following formula:</p>
 <pre>result = k1*i1*i2 + k2*i1 + k3*i2 + k4</pre>
 where:
 <ul>
  <li>
  <code>i1</code> and <code>i2</code> indicate the corresponding pixel channel values of the input image, which map to <a>'in'</a> and <a>'in2'</a> respectively
  </li>
  <li>
  <code>k1, k2, k3</code> and <code>k4</code> indicate the values of the attributes with the same name
  </li>
 </ul>
 <p>For this filter primitive, the extent of the resulting image might grow as
 described in the section that describes the <a>filter primitive subregion</a>.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feCompositeOperatorAttribute"><span class="adef">operator</span>
   = "<em>over | in | out | atop | xor | arithmetic</em>"</dt>
     <dd>The compositing operation that is to be performed. All of the <span
       class="attr-name">operator</span> types except <span
       class="attr-value">arithmetic</span> match the corresponding operation as
       described in [<a href="#ref-PORTERDUFF">PORTERDUFF</a>]. The <span
       class="attr-value">arithmetic</span> operator is described above.
       The <a>lacuna value</a> for <a>'operator'</a> is <span class="attr-value">over</span>.
       <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feCompositeK1Attribute"><span
   class="adef">k1</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Only applicable if <span
       class="attr-value">operator="arithmetic"</span>.<br />
       The <a>lacuna value</a> for <a>'k1'</a> is <span class="attr-value">0</span>. <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feCompositeK2Attribute"><span
   class="adef">k2</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Only applicable if <span
       class="attr-value">operator="arithmetic"</span>.<br />
       The <a>lacuna value</a> for <a>'k2'</a> is <span class="attr-value">0</span>. <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feCompositeK3Attribute"><span
   class="adef">k3</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Only applicable if <span
       class="attr-value">operator="arithmetic"</span>.<br />
       The <a>lacuna value</a> for <a>'k3'</a> is <span class="attr-value">0</span>. <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feCompositeK4Attribute"><span
   class="adef">k4</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Only applicable if <span
       class="attr-value">operator="arithmetic"</span>.<br />
       The <a>lacuna value</a> for <a>'k4'</a> is <span class="attr-value">0</span>. <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feCompositeIn2Attribute">
   <span class="adef">in2</span> = "<em>(see <a
   href="#FilterPrimitiveInAttribute"><span class="attr-name">in</span></a>
   attribute)</em>"</dt>
     <dd>The second input image to the compositing operation. This attribute
       can take on the same values as the <a
       href="#FilterPrimitiveInAttribute"><span
       class="attr-name">in</span></a> attribute.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 </edit:with>
 <edit:example href="examples/feComposite.svg" image="yes" link="yes"/>
 <h2 id="feConvolveMatrixElement">Filter primitive <span class="element-name">'feConvolveMatrix'</span></h2>
 <edit:elementsummary name='feConvolveMatrix'/>
 <edit:with element='feConvolveMatrix'>
 <p>feConvolveMatrix applies a matrix convolution filter effect. A convolution
 combines pixels in the input image with neighboring pixels to produce a
 resulting image. A wide variety of imaging operations can be achieved through
 convolutions, including blurring, edge detection, sharpening, embossing and
 beveling.</p>
 <p>A matrix convolution is based on an n-by-m matrix (the convolution kernel)
 which describes how a given pixel value in the input image is combined with
 its neighboring pixel values to produce a resulting pixel value. Each result
 pixel is determined by applying the kernel matrix to the corresponding source
 pixel and its neighboring pixels. The basic convolution formula which is
 applied to each color value for a given pixel is:</p>
 <p class="filterformula" id="feConvolveMatrixElementFormula">COLOR<sub>X,Y</sub> = ( <br />
               SUM <sub>I=0 to [<a
 href="#feConvolveMatrixElementOrderAttribute">'orderY'</a>-1]</sub> { <br />
                 SUM <sub>J=0 to [<a
 href="#feConvolveMatrixElementOrderAttribute">'orderX'</a>-1]</sub> { <br />
                   SOURCE <sub>X-<a>'targetX'</a>+J, Y-<a>'targetY'</a>+I</sub> *  <a>'kernelMatrix'</a><sub><a
 href="#feConvolveMatrixElementOrderAttribute">'orderX'</a>-J-1,  <a
 href="#feConvolveMatrixElementOrderAttribute">'orderY'</a>-I-1</sub> <br />
                 } <br />
               } <br />
             ) /  <a>'divisor'</a> +  <a>'bias'</a>&nbsp;*&nbsp;ALPHA<sub>X,Y</sub><br />
 </p>
 <div class="note-editor">
 ED: Consider making this into mathml</div>
 <p>where "orderX" and "orderY" represent the X and Y values for the <a>'order'</a> attribute, "targetX" represents the value
 of the <a>'targetX'</a> attribute, "targetY" represents the
 value of the <a>'targetY'</a> attribute, "kernelMatrix" represents the
 value of the <a>'kernelMatrix'</a> attribute, "divisor" represents the
 value of the <a>'divisor'</a> attribute, and "bias" represents the
 value of the <a>'bias'</a> attribute.</p>
 <p>Note in the above formulas that the values in the kernel matrix are
 applied such that the kernel matrix is rotated 180 degrees relative to the
 source and destination images in order to match convolution theory as
 described in many computer graphics textbooks.</p>
 <p>To illustrate, suppose you have a input image which is 5 pixels by 5
 pixels, whose color values for one of the color channels are as follows:</p>
 <pre>    0  20  40 235 235
 120 140 235 235
 220 240 235 235
 225 255 255 255
 225 255 255 255</pre>
 <div class="note-editor">
 ED: Consider making this into mathml</div>
 <p>and you define a 3-by-3 convolution kernel as follows:</p>
 <pre>  1 2 3
 5 6
 8 9</pre>
 <div class="note-editor">
 ED: Consider making this into mathml</div>
 <p>Let's focus on the color value at the second row and second column of the
 image (source pixel value is 120). Assuming the simplest case (where the
 input image's pixel grid aligns perfectly with the kernel's pixel grid) and
 assuming default values for attributes <a>'divisor'</a>, <a>'targetX'</a> and
 <a>'targetY'</a>, then resulting color value will
 be:</p>
 <pre>(9*  0 + 8* 20 + 7* 40 +
 *100 + 5*120 + 4*140 +
 *200 + 2*220 + 1*240) / (9+8+7+6+5+4+3+2+1)</pre>
 <div class="note-editor">
 ED: Consider making this into mathml</div>
 <p>Because they operate on pixels, matrix convolutions are inherently
 resolution-dependent. To make <a>'feConvolveMatrix'</a> produce resolution-independent
 results, an explicit value should be provided for either the <a>'filter/filterRes'</a> attribute on the <a>'filter element'</a> element
 and/or attribute <a>'kernelUnitLength'</a>.</p>
 <p><a>'kernelUnitLength'</a>, in combination with the other
 attributes, defines an implicit pixel grid in the filter effects coordinate
 system (i.e., the coordinate system established by the <a>'filter/primitiveUnits'</a> attribute). If the pixel grid
 established by <a>'kernelUnitLength'</a> is not scaled to match the
 pixel grid established by attribute <a>'filter/filterRes'</a> (implicitly or explicitly), then the
 input image will be temporarily rescaled to match its pixels with <a>'kernelUnitLength'</a>. The convolution happens on the
 resampled image. After applying the convolution, the image is resampled back
 to the original resolution.</p>
 <p>When the image must be resampled to match the coordinate system defined by
 <a>'kernelUnitLength'</a> prior to convolution, or
 resampled to match the device coordinate system after convolution, it is
 recommended that high quality viewers make use of appropriate interpolation
 techniques, for example bilinear or bicubic. Depending on the speed of the
 available interpolents, this choice may be affected by the <a>'image-rendering'</a> property setting. Note that
 implementations might choose approaches that minimize or eliminate resampling
 when not necessary to produce proper results, such as when the document is
 zoomed out such that <a>'kernelUnitLength'</a> is
 considerably smaller than a device pixel.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feConvolveMatrixElementOrderAttribute"><span
   class="adef">order</span> = "<span
   class="attr-value"><a>&lt;number-optional-number&gt;</a></span>"</dt>
     <dd>Indicates the number of cells in each dimension for <a>'kernelMatrix'</a>. The values provided must be
       <a>&lt;integer&gt;</a>
       s greater than zero. The first number, &lt;orderX&gt;, indicates the
       number of columns in the matrix. The second number, &lt;orderY&gt;,
       indicates the number of rows in the matrix. If &lt;orderY&gt; is not
       provided, it defaults to &lt;orderX&gt;.<br />
       A typical value is order="3". It is recommended that only small values
       (e.g., 3) be used; higher values may result in very high CPU overhead
       and usually do not produce results that justify the impact on
       performance.<br />
       If the attribute is not specified, the effect is as if a value of "3"
       were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feConvolveMatrixElementKernelMatrixAttribute"><span
   class="adef">kernelMatrix</span> = "<span class="attr-value">&lt;list of
   numbers&gt;</span>"</dt>
     <dd>The list of <a>&lt;number&gt;</a>
       s that make up the kernel matrix for the convolution. Values are
       separated by space characters and/or a comma. The number of entries in
       the list must equal &lt;orderX&gt; times &lt;orderY&gt;.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feConvolveMatrixElementDivisorAttribute"><span
   class="adef">divisor</span> = "<span
   class="attr-value"><a>&lt;number&gt;</a></span>"</dt>
     <dd>After applying the <span class="attr-name">kernelMatrix</span> to the
       input image to yield a number, that number is divided by <a>'divisor'</a> to yield the final destination color
       value. A divisor that is the sum of all the matrix values tends to have
       an evening effect on the overall color intensity of the result. If the
       specified divisor is zero then the default value will be used instead.
       The default value is the sum of all values in kernelMatrix, with the
       exception that if the sum is zero, then the divisor is set to 1.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feConvolveMatrixElementBiasAttribute"><span
   class="adef">bias</span> = "<span
   class="attr-value"><a>&lt;number&gt;</a></span>"</dt>
     <dd>After applying the <span class="attr-name">kernelMatrix</span> to the
       input image to yield a number and applying the <a>'divisor'</a>, the <a>'bias'</a> attribute is added to each component. One
       application of <a>'bias'</a> is when it is
       desirable to have <span class="attr-value">.5</span> gray value be the zero response of the filter.
       The bias property shifts the range of the filter. This allows representation of values that would
       otherwise be clamped to 0 or 1.<br />
       The <a>lacuna value</a> for <a>'bias'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feConvolveMatrixElementTargetXAttribute"><span
   class="adef">targetX</span> = "<span
   class="attr-value"><a>&lt;integer&gt;</a></span>"</dt>
     <dd>Determines the positioning in X of the convolution matrix relative to
       a given target pixel in the input image. The leftmost column of the
       matrix is column number zero. The value must be such that: 0 &lt;=
       targetX &lt; orderX. By default, the convolution matrix is centered in
       X over each pixel of the input image (i.e., targetX = floor ( orderX /
 )).<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feConvolveMatrixElementTargetYAttribute"><span
   class="adef">targetY</span> = "<span
   class="attr-value"><a>&lt;integer&gt;</a></span>"</dt>
     <dd>Determines the positioning in Y of the convolution matrix relative to
       a given target pixel in the input image. The topmost row of the matrix
       is row number zero. The value must be such that: 0 &lt;= targetY &lt;
       orderY. By default, the convolution matrix is centered in Y over each
       pixel of the input image (i.e., targetY = floor ( orderY / 2 )).<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feConvolveMatrixElementEdgeModeAttribute"><span
   class="adef">edgeMode</span> = "<span class="attr-value">duplicate | wrap |
   none</span>"</dt>
     <dd><p>Determines how to extend the input image as necessary with color
       values so that the matrix operations can be applied when the kernel is
       positioned at or near the edge of the input image.</p>
       <p>"duplicate" indicates that the input image is extended along each of
       its borders as necessary by duplicating the color values at the given
       edge of the input image.</p>
       <pre>Original N-by-M image, where m=M-1 and n=N-1:
 12 ... 1m 1M
 22 ... 2m 2M
           .. .. ... .. ..
           n1 n2 ... nm nM
           N1 N2 ... Nm NM
 Extended by two pixels using "duplicate":
 11   11 12 ... 1m 1M   1M 1M
 11   11 12 ... 1m 1M   1M 1M
 11   11 12 ... 1m 1M   1M 1M
 21   21 22 ... 2m 2M   2M 2M
   .. ..   .. .. ... .. ..   .. ..
   n1 n1   n1 n2 ... nm nM   nM nM
   N1 N1   N1 N2 ... Nm NM   NM NM
   N1 N1   N1 N2 ... Nm NM   NM NM
   N1 N1   N1 N2 ... Nm NM   NM NM</pre>
       <div class="note-editor">
       ED: Consider making this into mathml</div>
       <p>"wrap" indicates that the input image is extended by taking the
       color values from the opposite edge of the image.</p>
       <pre>Extended by two pixels using "wrap":
   nm nM   n1 n2 ... nm nM   n1 n2
   Nm NM   N1 N2 ... Nm NM   N1 N2
 m 1M   11 12 ... 1m 1M   11 12
 m 2M   21 22 ... 2m 2M   21 22
   .. ..   .. .. ... .. ..   .. ..
   nm nM   n1 n2 ... nm nM   n1 n2
   Nm NM   N1 N2 ... Nm NM   N1 N2
 m 1M   11 12 ... 1m 1M   11 12
 m 2M   21 22 ... 2m 2M   21 22</pre>
       <div class="note-editor">
       ED: Consider making this into mathml</div>
       <p>The value <span class="attr-value">none</span> indicates that the input image is extended with pixel values
       of zero for R, G, B and A.</p>
       <p>The <a>lacuna value</a> for <a>'edgeMode'</a> is <span class="attr-value">duplicate</span>.</p>
       <p><span class="anim-target">Animatable: yes.</span></p>
     </dd>
   <dt id="feConvolveMatrixElementKernelUnitLengthAttribute"><span
   class="adef">kernelUnitLength</span> = "<span
   class="attr-value"><a>&lt;number-optional-number&gt;</a></span>"</dt>
     <dd>The first number is the &lt;dx&gt; value. The second number is the
       &lt;dy&gt; value. If the &lt;dy&gt; value is not specified, it defaults
       to the same value as &lt;dx&gt;. Indicates the intended distance in
       current filter units (i.e., units as determined by the value of
       attribute <a>'filter/primitiveUnits'</a>) between successive columns
       and rows, respectively, in the <a>'kernelMatrix'</a>. By specifying value(s) for
       <a>'kernelUnitLength'</a>, the kernel becomes defined
       in a scalable, abstract coordinate system. If <a>'kernelUnitLength'</a> is not specified, the default
       value is one pixel in the offscreen bitmap, which is a pixel-based
       coordinate system, and thus potentially not scalable. For some level of
       consistency across display media and user agents, it is necessary that
       a value be provided for at least one of <a>'filter/filterRes'</a> and <a>'kernelUnitLength'</a>.
       In some implementations, the most consistent results and the fastest performance will be achieved if
       the pixel grid of the temporary offscreen images aligns with the pixel
       grid of the kernel.<br />
       If a negative or zero value is specified the default value will be used
       instead. <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feConvolveMatrixElementPreserveAlphaAttribute"><span
   class="adef">preserveAlpha</span> = "<span class="attr-value">false |
   true</span>"</dt>
     <dd>A value of <span class="attr-value">false</span> indicates that the
       convolution will apply to all channels, including the alpha channel.
       In this case the <code>ALPHA<sub>X,Y</sub></code> of the
       <a href="#feConvolveMatrixElementFormula">convolution formula</a> for a given pixel is:
       <p class="filterformula">
        ALPHA<sub>X,Y</sub>&nbsp;=&nbsp;(&nbsp;<br />
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;SUM
        <sub>I=0&nbsp;to&nbsp;[<a href="#feConvolveMatrixElementOrderAttribute">'orderY'</a>-1]</sub>&nbsp;{&nbsp;<br />
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;SUM
        <sub>J=0&nbsp;to&nbsp;[<a href="#feConvolveMatrixElementOrderAttribute">'orderX'</a>-1]</sub>&nbsp;{&nbsp;<br />
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;SOURCE
        <sub>X-<a>'targetX'</a>+J,&nbsp;Y-<a>'targetY'</a>+I</sub>&nbsp;*&nbsp;
        <a>'kernelMatrix'</a><sub><a href="#feConvolveMatrixElementOrderAttribute">'orderX'</a>-J-1,&nbsp;
        <a href="#feConvolveMatrixElementOrderAttribute">'orderY'</a>-I-1</sub>&nbsp;<br />
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;<br />
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;<br />
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;)&nbsp;/&nbsp;
        <a>'divisor'</a>&nbsp;+&nbsp;
        <a>'bias'</a>&nbsp;
        <br />
        </p>
       <br />
       A value of <span class="attr-value">true</span> indicates that the
       convolution will only apply to the color channels. In this case, the
       filter will temporarily unpremultiply the color component values, apply
       the kernel, and then re-premultiply at the end.
       In this case the <code>ALPHA<sub>X,Y</sub></code>
       of the <a href="#feConvolveMatrixElementFormula">convolution formula</a> for a given pixel is:
       <p class="filterformula">
         ALPHA<sub>X,Y</sub>&nbsp;=&nbsp;SOURCE<sub>X,Y</sub>
       </p>
       The <a>lacuna value</a> for <a>'preserveAlpha'</a> is <span class="attr-value">false</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 </edit:with>
 <h2 id="feDiffuseLightingElement">Filter primitive <span
 class="element-name">'feDiffuseLighting'</span></h2>
 <edit:elementsummary name='feDiffuseLighting'/>
 <p>This filter primitive lights an image using the alpha channel as a bump
 map. The resulting image is an RGBA opaque image based on the light color
 with alpha = 1.0 everywhere. The lighting calculation follows the standard
 diffuse component of the Phong lighting model. The resulting image depends on
 the light color, light position and surface geometry of the input bump
 map.</p>
 <p>The light map produced by this filter primitive can be combined with a
 texture image using the multiply term of the <em>arithmetic</em> <a>'feComposite'</a> compositing method. Multiple
 light sources can be simulated by adding several of these light maps together
 before applying it to the texture image.</p>
 <p>The formulas below make use of 3x3 filters. Because they operate on
 pixels, such filters are inherently resolution-dependent. To make <a>'feDiffuseLighting'</a> produce
 resolution-independent results, an explicit value should be provided for
 either the <a>'filter/filterRes'</a> attribute on the <a>'filter element'</a> element
 and/or attribute <a>'feDiffuseLighting/kernelUnitLength'</a>.</p>
 <p><a>'feDiffuseLighting/kernelUnitLength'</a>, in combination with the other
 attributes, defines an implicit pixel grid in the filter effects coordinate
 system (i.e., the coordinate system established by the <a>'filter/primitiveUnits'</a> attribute). If the pixel grid
 established by <a>'feDiffuseLighting/kernelUnitLength'</a> is not scaled to match the
 pixel grid established by attribute <a>'filter/filterRes'</a> (implicitly or explicitly), then the
 input image will be temporarily rescaled to match its pixels with <a>'feDiffuseLighting/kernelUnitLength'</a>. The 3x3 filters are applied to the resampled image. After applying the filter, the image is resampled back
 to its original resolution.</p>
 <p><span class="requirement" id="assert_diffuseLightingImageResampling">When the image must be resampled, it is recommended that high quality viewers make use of appropriate interpolation techniques, for example
 bilinear or bicubic.</span> Depending on the speed of the available interpolents,
 this choice may be affected by the <a>'image-rendering'</a> property setting. Note that
 implementations might choose approaches that minimize or eliminate resampling
 when not necessary to produce proper results, such as when the document is
 zoomed out such that <a>'feDiffuseLighting/kernelUnitLength'</a> is
 considerably smaller than a device pixel.</p>
 <p>For the formulas that follow, the
 <code>Norm(A<sub>x</sub>,A<sub>y</sub>,A<sub>z</sub>)</code> function is
 defined as:</p>
 <div class="note-editor">
 ED: Consider making the following in mathml</div>
 <p class="filterformula">Norm(A<sub>x</sub>,A<sub>y</sub>,A<sub>z</sub>) =
 sqrt(A<sub>x</sub>^2+A<sub>y</sub>^2+A<sub>z</sub>^2)</p>
 <p>The resulting RGBA image is computed as follows:</p>
 <p class="filterformula">D<sub>r</sub> = k<sub>d</sub> * N.L *
 L<sub>r</sub><br />
 D<sub>g</sub> = k<sub>d</sub> * N.L * L<sub>g</sub><br />
 D<sub>b</sub> = k<sub>d</sub> * N.L * L<sub>b</sub><br />
 D<sub>a</sub> = 1.0</p>
 <p>where</p>
 <dl>
     <dd>k<sub>d</sub> = diffuse lighting constant<br />
       N = surface normal unit vector, a function of x and y<br />
       L = unit vector pointing from surface to light, a function of x and y
       in the point and spot light cases<br />
       L<sub>r</sub>,L<sub>g</sub>,L<sub>b</sub> = RGB components of light, a
       function of x and y in the spot light case</dd>
 </dl>
 <p>N is a function of x and y and depends on the surface gradient as
 follows:</p>
 <p>The surface described by the input alpha image I(x,y) is:</p>
 <p class="filterformula">Z (x,y) = surfaceScale *  I(x,y)</p>
 <p id="SurfaceNormalCalculations">Surface normal is calculated using the Sobel gradient 3x3 filter.
 Different filter kernels are used depending on whether the given pixel is on
 the interior or an edge. For each case, the formula is:</p>
 <p class="filterformula">N<sub>x</sub> (x,y) = - surfaceScale *
 FACTOR<sub>x</sub> *<br />
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(K<sub>x</sub>(0,0)*I(x-dx,y-dy)&nbsp;+
 K<sub>x</sub>(1,0)*I(x,y-dy)&nbsp;+
 K<sub>x</sub>(2,0)*I(x+dx,y-dy)&nbsp;+<br />
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;K<sub>x</sub>(0,1)*I(x-dx,y)&nbsp;&nbsp;&nbsp;&nbsp;+
 K<sub>x</sub>(1,1)*I(x,y)&nbsp;&nbsp;&nbsp;&nbsp;+
 K<sub>x</sub>(2,1)*I(x+dx,y)&nbsp;&nbsp;&nbsp;&nbsp;+<br />
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;K<sub>x</sub>(0,2)*I(x-dx,y+dy)&nbsp;+
 K<sub>x</sub>(1,2)*I(x,y+dy)&nbsp;+
 K<sub>x</sub>(2,2)*I(x+dx,y+dy))<br />
  N<sub>y</sub> (x,y) = - surfaceScale * FACTOR<sub>y</sub>
 *<br />
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(K<sub>y</sub>(0,0)*I(x-dx,y-dy)&nbsp;+
 K<sub>y</sub>(1,0)*I(x,y-dy)&nbsp;+
 K<sub>y</sub>(2,0)*I(x+dx,y-dy)&nbsp;+<br />
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;K<sub>y</sub>(0,1)*I(x-dx,y)&nbsp;&nbsp;&nbsp;&nbsp;+
 K<sub>y</sub>(1,1)*I(x,y)&nbsp;&nbsp;&nbsp;&nbsp;+
 K<sub>y</sub>(2,1)*I(x+dx,y)&nbsp;&nbsp;&nbsp;&nbsp;+<br />
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;K<sub>y</sub>(0,2)*I(x-dx,y+dy)&nbsp;+
 K<sub>y</sub>(1,2)*I(x,y+dy)&nbsp;+
 K<sub>y</sub>(2,2)*I(x+dx,y+dy))<br />
  N<sub>z</sub> (x,y) = 1.0<br />
 <br />
  N = (N<sub>x</sub>, N<sub>y</sub>, N<sub>z</sub>) /
 Norm((N<sub>x</sub>,N<sub>y</sub>,N<sub>z</sub>))</p>
 <p>In these formulas, the <code>dx</code> and <code>dy</code> values (e.g.,
 <code>I(x-dx,y-dy)</code>), represent deltas relative to a given
 <code>(x,y)</code> position for the purpose of estimating the slope of the
 surface at that point. These deltas are determined by the value (explicit or
 implicit) of attribute <a>'feDiffuseLighting/kernelUnitLength'</a>.</p>
 <table summary="feDiffuseLighting formulas" border="1">
   <colgroup><col width="33.3%" /><col width="33.3%" /><col width="*"
   /></colgroup>
   <tbody>
     <tr>
       <td><p>Top/left corner:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=2/(3*dx)<br />
         K<sub>x</sub> =<br />
             |  0  0  0 |<br />
             |  0 -2  2 |<br />
             |  0 -1  1 |<br />
         <br />
         FACTOR<sub>y</sub>=2/(3*dy)<br />
         K<sub>y</sub> =  <br />
             |  0  0  0 |<br />
             |  0 -2 -1 |<br />
             |  0  2  1 |</p>
       </td>
       <td><p>Top row:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=1/(3*dx)<br />
         K<sub>x</sub> =<br />
             |  0  0  0 |<br />
             | -2  0  2 |<br />
             | -1  0  1 |<br />
         <br />
         FACTOR<sub>y</sub>=1/(2*dy)<br />
         K<sub>y</sub> =  <br />
             |  0  0  0 |<br />
             | -1 -2 -1 |<br />
             |  1  2  1 |</p>
       </td>
       <td><p>Top/right corner:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=2/(3*dx)<br />
         K<sub>x</sub> =<br />
             |  0  0  0 |<br />
             | -2  2  0 |<br />
             | -1  1  0 |<br />
         <br />
         FACTOR<sub>y</sub>=2/(3*dy)<br />
         K<sub>y</sub> =  <br />
             |  0  0  0 |<br />
             | -1 -2  0 |<br />
             |  1  2  0 |</p>
       </td>
     </tr>
     <tr>
       <td><p>Left column:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=1/(2*dx)<br />
         K<sub>x</sub> =<br />
             | 0 -1  1 |<br />
             | 0 -2  2 |<br />
             | 0 -1  1 |<br />
         <br />
         FACTOR<sub>y</sub>=1/(3*dy)<br />
         K<sub>y</sub> =  <br />
             |  0 -2 -1 |<br />
             |  0  0  0 |<br />
             |  0  2  1 |</p>
       </td>
       <td><p>Interior pixels:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=1/(4*dx)<br />
         K<sub>x</sub> =<br />
             | -1  0  1 |<br />
             | -2  0  2 |<br />
             | -1  0  1 |<br />
         <br />
         FACTOR<sub>y</sub>=1/(4*dy)<br />
         K<sub>y</sub> =  <br />
             | -1 -2 -1 |<br />
             |  0  0  0 |<br />
             |  1  2  1 |</p>
       </td>
       <td><p>Right column:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=1/(2*dx)<br />
         K<sub>x</sub> =<br />
             | -1  1  0|<br />
             | -2  2  0|<br />
             | -1  1  0|<br />
         <br />
         FACTOR<sub>y</sub>=1/(3*dy)<br />
         K<sub>y</sub> =  <br />
             | -1 -2  0 |<br />
             |  0  0  0 |<br />
             |  1  2  0 |</p>
       </td>
     </tr>
     <tr>
       <td><p>Bottom/left corner:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=2/(3*dx)<br />
         K<sub>x</sub> =<br />
             | 0 -1  1 |<br />
             | 0 -2  2 |<br />
             | 0  0  0 |<br />
         <br />
         FACTOR<sub>y</sub>=2/(3*dy)<br />
         K<sub>y</sub> =  <br />
             |  0 -2 -1 |<br />
             |  0  2  1 |<br />
             |  0  0  0 |</p>
       </td>
       <td><p>Bottom row:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=1/(3*dx)<br />
         K<sub>x</sub> =<br />
             | -1  0  1 |<br />
             | -2  0  2 |<br />
             |  0  0  0 |<br />
         <br />
         FACTOR<sub>y</sub>=1/(2*dy)<br />
         K<sub>y</sub> =  <br />
             | -1 -2 -1 |<br />
             |  1  2  1 |<br />
             |  0  0  0 |</p>
       </td>
       <td><p>Bottom/right corner:</p>
         <p class="filterformula">FACTOR<sub>x</sub>=2/(3*dx)<br />
         K<sub>x</sub> =<br />
             | -1  1  0 |<br />
             | -2  2  0 |<br />
             |  0  0  0 |<br />
         <br />
         FACTOR<sub>y</sub>=2/(3*dy)<br />
         K<sub>y</sub> =  <br />
             | -1 -2  0 |<br />
             |  1  2  0 |<br />
             |  0  0  0 |</p>
       </td>
     </tr>
   </tbody>
 </table>
 <p>L, the unit vector from the image sample to the light, is calculated as
 follows:</p>
 <p>For Infinite light sources it is constant:</p>
 <p class="filterformula">L<sub>x</sub> = cos(azimuth)*cos(elevation)<br />
 L<sub>y</sub> = sin(azimuth)*cos(elevation)<br />
 L<sub>z</sub> = sin(elevation)</p>
 <p>For Point and spot lights it is a function of position:</p>
 <p class="filterformula">L<sub>x</sub> = Light<sub>x</sub> - x<br />
 L<sub>y</sub> = Light<sub>y</sub> - y<br />
 L<sub>z</sub> = Light<sub>z</sub> - Z(x,y)<br />
 <br />
 L = (L<sub>x</sub>, L<sub>y</sub>, L<sub>z</sub>) / Norm(L<sub>x</sub>,
 L<sub>y</sub>, L<sub>z</sub>)</p>
 <p>where Light<sub>x</sub>, Light<sub>y</sub>, and Light<sub>z</sub> are the
 input light position.</p>
 <p>L<sub>r</sub>,L<sub>g</sub>,L<sub>b</sub>, the light color vector, is a
 function of position in the spot light case only:</p>
 <p class="filterformula">L<sub>r</sub> =
 Light<sub>r</sub>*pow((-L.S),specularExponent)<br />
 L<sub>g</sub> = Light<sub>g</sub>*pow((-L.S),specularExponent)<br />
 L<sub>b</sub> = Light<sub>b</sub>*pow((-L.S),specularExponent)</p>
 <p>where S is the unit vector pointing from the light to the point
 (pointsAtX, pointsAtY, pointsAtZ) in the x-y plane:</p>
 <p class="filterformula">S<sub>x</sub> = pointsAtX - Light<sub>x</sub><br />
 S<sub>y</sub> = pointsAtY - Light<sub>y</sub><br />
 S<sub>z</sub> = pointsAtZ - Light<sub>z</sub><br />
 <br />
 S = (S<sub>x</sub>, S<sub>y</sub>, S<sub>z</sub>) / Norm(S<sub>x</sub>,
 S<sub>y</sub>, S<sub>z</sub>)</p>
 <p>If L.S is positive, no light is present. (L<sub>r</sub> = L<sub>g</sub> =
 L<sub>b</sub> = 0). If <a>'feSpotLight/limitingConeAngle'</a> is specified, -L.S &lt; cos(limitingConeAngle) also indicates that no light is present.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feDiffuseLightingSurfaceScaleAttribute"><span
   class="adef">surfaceScale</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>height of surface when A<sub>in</sub> = 1.<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">1</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feDiffuseLightingDiffuseConstantAttribute"><span
   class="adef">diffuseConstant</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>kd in Phong lighting model. In SVG, this can be any non-negative
       number.<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">1</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feDiffuseLightingKernelUnitLengthAttribute"><span
   class="adef">kernelUnitLength</span> = "<span
   class="attr-value"><a>&lt;number-optional-number&gt;</a></span>"</dt>
     <dd>The first number is the &lt;dx&gt; value. The second number is the
       &lt;dy&gt; value. If the &lt;dy&gt; value is not specified, it defaults
       to the same value as &lt;dx&gt;. Indicates the intended distance in
       current filter units (i.e., units as determined by the value of
       attribute <a>'filter/primitiveUnits'</a>) for <code>dx</code> and
       <code>dy</code>, respectively, in the <a
       href="#SurfaceNormalCalculations">surface normal calculation
       formulas</a>. By specifying value(s) for <span
       class="attr-name">kernelUnitLength</span>, the kernel becomes defined
       in a scalable, abstract coordinate system. If <span
       class="attr-name">kernelUnitLength</span> is not specified, the
       <code>dx</code> and <code>dy</code> values should represent very small
       deltas relative to a given <code>(x,y)</code> position, which might be
       implemented in some cases as one pixel in the intermediate image
       offscreen bitmap, which is a pixel-based coordinate system, and thus
       potentially not scalable. For some level of consistency across display
       media and user agents, it is necessary that a value be provided for at
       least one of <a>'filter/filterRes'</a> and <span
       class="attr-name">kernelUnitLength</span>. Discussion of intermediate
       images are in the <a href="#Introduction">Introduction</a> and in the
       description of attribute <a>'filter/filterRes'</a>.<br />
       If a negative or zero value is specified the default value will be used
       instead. <br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <p>The light source is defined by one of the child elements <a>'feDistantLight'</a>,
 <a>'fePointLight'</a> or <a>'feSpotLight'</a>. The light color is specified
 by property <a>'lighting-color'</a>.</p>
 <h2 id="feDisplacementMapElement">Filter primitive <span class="element-name">'feDisplacementMap'</span></h2>
 <edit:elementsummary name='feDisplacementMap'/>
 <p>This filter primitive uses the pixels values from the image from <a>'feDisplacementMap/in2'</a>
 to spatially displace the image from <a>'in'</a>.
 This is the transformation to be performed:</p>
 <pre> P'(x,y) ← P( x + scale * (XC(x,y) - .5), y + scale * (YC(x,y) - .5))
   </pre>
 <p>where P(x,y) is the input image, <a>'in'</a>, and
 P'(x,y) is the destination. XC(x,y) and YC(x,y) are the component values of
 the channel designated by the <a>'feDisplacementMap/xChannelSelector'</a> and
 <a>'feDisplacementMap/yChannelSelector'</a>. For example, to use the R component of <a>'feDisplacementMap/in2'</a>
 to control displacement in x and the G component of Image2 to control
 displacement in y, set <a>'feDisplacementMap/xChannelSelector'</a> to <span class="attr-value">"R"</span> and
 <a>'feDisplacementMap/yChannelSelector'</a> to <span class="attr-value">"G"</span>.</p>
 <p>The displacement map, <a>'feDisplacementMap/in2'</a>, defines the inverse of the mapping
 performed.</p>
 <p>The input image in is to remain premultiplied for this filter primitive. The calculations using the pixel values from <a>'feDisplacementMap/in2'</a> are performed using non-premultiplied color values. If the image from <a>'feDisplacementMap/in2'</a> consists of premultiplied color values, those values are automatically converted into non-premultiplied color values before performing this operation.</p>
 <p>This filter can have arbitrary non-localized effect on the input which
 might require substantial buffering in the processing pipeline. However with
 this formulation, any intermediate buffering needs can be determined by
 <a>'feDisplacementMap/scale'</a> which represents the maximum range of displacement in either x
 or y.</p>
 <p>When applying this filter, the source pixel location will often lie
 between several source pixels. In this case it is recommended that high
 quality viewers apply an interpolent on the surrounding pixels, for example
 bilinear or bicubic, rather than simply selecting the nearest source pixel.
 Depending on the speed of the available interpolents, this choice may be
 affected by the <a>'image-rendering'</a> property
 setting.</p>
 <p>The <a>'color-interpolation-filters'</a> property only applies to the
   <a>'feDisplacementMap/in2'</a> source image and does not apply to the <a>'in'</a> source image.
   The <a>'in'</a> source image must remain in its current color space.
 </p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feDisplacementMapScaleAttribute"><span class="adef">scale</span>
   = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Displacement scale factor. The amount is expressed in the coordinate
       system established by attribute <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a>
       element.<br />
       When the value of this attribute is <span class="attr-value">0</span>,
       this operation has no effect on the source image.<br />
       <p>The <a>lacuna value</a> for <a>'feDisplacementMap/scale'</a> is <span class="attr-value">0</span>.</p>
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feDisplacementMapXChannelSelectorAttribute"><span
   class="adef">xChannelSelector</span> = "<em>R | G | B | A</em>"</dt>
     <dd>Indicates which channel from <a>'feDisplacementMap/in2'</a> to use to displace the pixels in <a>'in'</a> along the x-axis.
     The <a>lacuna value</a> for <a>'feDisplacementMap/xChannelSelector'</a> is <span class="attr-value">A</span>.
     <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feDisplacementMapYChannelSelectorAttribute"><span
   class="adef">yChannelSelector</span> = "<em>R | G | B | A</em>"</dt>
     <dd>Indicates which channel from <a>'feDisplacementMap/in2'</a> to use to displace the pixels in <a>'in'</a> along the y-axis.
     The <a>lacuna value</a> for <a>'feDisplacementMap/yChannelSelector'</a> is <span class="attr-value">A</span>.
     <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feDisplacementMapIn2Attribute"><span class="adef">in2</span> =
   "<em>(see <a>'in'</a> attribute)</em>"</dt>
     <dd>The second input image, which is used to displace the pixels in the
       image from attribute <a>'in'</a>. This attribute can take on the same
       values as the <a>'in'</a> attribute.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <h2 id="feFloodElement">Filter primitive <span
 class="element-name">'feFlood'</span></h2>
 <edit:elementsummary name='feFlood'/>
 <p>This filter primitive creates a rectangle filled with the color and
 opacity values from properties <span class="prop-name">'flood-color'</span>
 and <span class="prop-name">'flood-opacity'</span>. The rectangle is as large
 as the <a href="#FilterPrimitiveSubRegion">filter primitive subregion</a>
 established by the <span class="element-name">'feFlood'</span> element.</p>
 <div class="adef-list">
   </div>
 <p>The <span class="prop-name">'flood-color'</span> property indicates what
 color to use to flood the current <a href="#FilterPrimitiveSubRegion">filter
 primitive subregion</a>. The keyword <span
 class="attr-value">currentColor</span> and ICC colors can be specified in the
 same manner as within a &lt;paint&gt; specification for the <span
 class="prop-name">'fill'</span> and <span class="prop-name">'stroke'</span>
 properties.</p>
 <div class="propdef">
 <dl>
   <dt id="FloodColorProperty"><span class="propdef-title prop-name">'flood-color'</span></dt>
     <dd>
       <table summary="flood-color property" class="propinfo" cellspacing="0"
       cellpadding="0">
         <tbody>
           <tr valign="baseline">
             <td><em>Value:</em>  </td>
             <td>currentColor |<br />
               <a>&lt;color&gt;</a>
               [<a>&lt;icccolor&gt;</a>] |<br />
               <a class="noxref"
               href="http://www.w3.org/TR/2009/CR-CSS2-20090423/cascade.html#value-def-inherit"><span
               class="value-inst-inherit noxref">inherit</span></a></td>
           </tr>
           <tr valign="baseline">
             <td><em>Initial:</em>  </td>
             <td>black</td>
           </tr>
           <tr valign="baseline">
             <td><em>Applies to:</em>  </td>
             <td><a href="#feFloodElement"><span
               class="element-name">'feFlood'</span></a> and <a
               href="#feDropShadowElement"><span
               class="element-name">'feDropShadow'</span></a> elements</td>
           </tr>
           <tr valign="baseline">
             <td><em>Inherited:</em>  </td>
             <td>no</td>
           </tr>
           <tr valign="baseline">
             <td><em>Percentages:</em>  </td>
             <td>N/A</td>
           </tr>
           <tr valign="baseline">
             <td><em>Media:</em>  </td>
             <td>visual</td>
           </tr>
           <tr valign="baseline">
             <td><em>Animatable:</em>  </td>
             <td>yes</td>
           </tr>
         </tbody>
       </table>
     </dd>
 </dl>
 </div>
 <p>The <span class="prop-name">'flood-opacity'</span> property defines the
 opacity value to use across the entire <a
 href="#FilterPrimitiveSubRegion">filter primitive subregion</a>.</p>
 <div class="propdef">
 <dl>
   <dt id="OpacityFloodOpacityProperty"><span class="propdef-title prop-name">'flood-opacity'</span></dt>
     <dd>
       <table summary="flood-opacity property" class="propinfo"
       cellspacing="0" cellpadding="0">
         <tbody>
           <tr valign="baseline">
             <td><em>Value:</em>  </td>
             <td>&lt;opacity-value&gt; | <a class="noxref"
               href="http://www.w3.org/TR/2009/CR-CSS2-20090423/cascade.html#value-def-inherit"><span
               class="value-inst-inherit noxref">inherit</span></a></td>
           </tr>
           <tr valign="baseline">
             <td><em>Initial:</em>  </td>
             <td>1</td>
           </tr>
           <tr valign="baseline">
             <td><em>Applies to:</em>  </td>
             <td><a href="#feFloodElement"><span
               class="element-name">'feFlood'</span></a> and <a
               href="#feDropShadowElement"><span
               class="element-name">'feDropShadow'</span></a> elements</td>
           </tr>
           <tr valign="baseline">
             <td><em>Inherited:</em>  </td>
             <td>no</td>
           </tr>
           <tr valign="baseline">
             <td><em>Percentages:</em>  </td>
             <td>N/A</td>
           </tr>
           <tr valign="baseline">
             <td><em>Media:</em>  </td>
             <td>visual</td>
           </tr>
           <tr valign="baseline">
             <td><em>Animatable:</em>  </td>
             <td>yes</td>
           </tr>
         </tbody>
       </table>
     </dd>
 </dl>
 </div>
 <h2 id="feGaussianBlurElement">Filter primitive <span
 class="element-name">'feGaussianBlur'</span></h2>
 <edit:elementsummary name='feGaussianBlur'/>
 <edit:with element='feGaussianBlur'>
 <p>This filter primitive performs a Gaussian blur on the input image.</p>
 <p>The Gaussian blur kernel is an approximation of the normalized
 convolution:</p>
 <p class="filterformula">G(x,y) = H(x)I(y)</p>
 <p>where</p>
 <p class="filterformula">H(x) = exp(-x<sup>2</sup>/ (2s<sup>2</sup>)) / sqrt(2* pi*s<sup>2</sup>)</p>
 <p>and</p>
 <p class="filterformula">I(x) = exp(-y<sup>2</sup>/ (2t<sup>2</sup>)) / sqrt(2* pi*t<sup>2</sup>)</p>
 <p>with 's' being the standard deviation in the x direction
 and 't' being the standard deviation in the y direction, as specified by <a>'stdDeviation'</a>.</p>
 <p>The value of <a>'stdDeviation'</a> can be either one or two numbers.
 If two numbers are provided, the first number represents a standard deviation
 value along the x-axis of the current coordinate system and the second value
 represents a standard deviation in Y. If one number is provided, then that
 value is used for both X and Y.</p>
 <p>Even if only one value is provided for <a>'stdDeviation'</a>, this can be implemented as a
 separable convolution.</p>
 <p>For larger values of 's' (s &gt;= 2.0), an approximation can be used:
 Three successive box-blurs build a piece-wise quadratic convolution kernel,
 which approximates the Gaussian kernel to within roughly 3%.</p>
 <p class="filterformula">let d = floor(s * 3*sqrt(2*pi)/4 + 0.5)</p>
 <p>... if d is odd, use three box-blurs of size 'd', centered on the output
 pixel.</p>
 <p>... if d is even, two box-blurs of size 'd' (the first one centered on the
 pixel boundary between the output pixel and the one to the left, the second
 one centered on the pixel boundary between the output pixel and the one to
 the right) and one box blur of size 'd+1' centered on the output pixel.</p>
 <p>The approximation formula also applies correspondingly to 't'.</p>
 <p>Frequently this operation will take place on alpha-only images, such as
 that produced by the built-in input, <a href="#SourceAlpha"><span
 class="attr-value">SourceAlpha</span></a>. The implementation may notice this
 and optimize the single channel case. If the input has infinite extent and is
 constant (e.g <span class="attr-value"><a href="#FillPaint">FillPaint</a></span>,
 this operation has no effect. If the input has infinite extent and the filter result
 is the input to an <a>'feTile'</a>, the filter is evaluated with periodic boundary conditions.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feGaussianBlurStdDeviationAttribute"><span
   class="adef">stdDeviation</span> =
   "<em><a>&lt;number-optional-number&gt;</a></em>"</dt>
     <dd>The standard deviation for the blur operation. If two <a>&lt;number&gt;</a>
       s are provided, the first number represents a standard deviation value
       along the x-axis of the coordinate system established by attribute <a>'filter/primitiveUnits'</a> on the <a
       href="#FilterElement"><span class="element-name">'filter'</span></a>
       element. The second value represents a standard deviation in Y. If one
       number is provided, then that value is used for both X and Y.<br />
       A value of zero disables the effect of the given filter primitive (i.e., the result is the filter input image).<br />
       If <a>'stdDeviation'</a> is <span class="attr-value">0</span> in only one of X or Y,
       then the effect is that the blur is only applied in the direction that has a non-zero value.
       <br />
       The <a>lacuna value</a> for <a>'stdDeviation'</a> is <span class="attr-value">0</span>.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <p><a href="#AnExample">The example</a> at the start of this chapter makes
 use of the <a>'feGaussianBlur'</a> filter primitive
 to create a drop shadow effect.</p>
 </edit:with>
 <h2 id="feUnsharpMaskElement">Filter primitive <span
 class="element-name">'feUnsharpMask'</span></h2>
 <edit:elementsummary name='feUnsharpMask'/>
 <p>This filter primitive performs an image sharpening operation on the input image. This is traditionally known as an unsharp mask operation.</p>
 <p>The filter first does a <a>'feGaussianBlur'</a> operation on the input image and then subtracts the difference between the input image and the blurred image.</p>
 <p>
 For controlling the result there are three attributes that can be used:
   <ul>
     <li>the <a>'feUnsharpMask/stdDeviation'</a> attribute controls how much to blur the input image</li>
     <li>the <a>'feUnsharpMask/threshold'</a> attribute can be used for controlling when the difference should not be subtracted</li>
     <li>the <a>'feUnsharpMask/amount'</a> attribute specifies an optional multiplier for the difference to subtract</li>
   </ul>
 </p>
 <h2 id="feImageElement">Filter primitive <span
 class="element-name">'feImage'</span></h2>
 <edit:elementsummary name='feImage'/>
 <edit:with element='feImage'>
 <p>This filter primitive refers to a graphic external to this filter element,
 which is loaded or rendered into an RGBA raster and becomes the result of the
 filter primitive.</p>
 <p>This filter primitive can refer to an external image or can be a reference
 to another piece of SVG. It produces an image similar to the built-in image
 source <a href="#SourceGraphic"><span
 class="attr-value">SourceGraphic</span></a> except that the graphic comes
 from an external source.</p>
 <p>If the <span class="attr-name">xlink:href</span> references a stand-alone
 image resource such as a JPEG, PNG or SVG file, then the image resource is
 rendered according to the behavior of the <span
 class="element-name">'image'</span> element; otherwise, the referenced
 resource is rendered according to the behavior of the <span
 class="element-name">'use'</span> element. In either case, the current user
 coordinate system depends on the value of attribute <a>'filter/primitiveUnits'</a> on the <a
 href="#FilterElement"><span class="element-name">'filter'</span></a> element.
 The processing of the <span class="attr-name">preserveAspectRatio</span>
 attribute on the <span class="element-name">'feImage'</span> element is
 identical to that of the <a href="struct.html#ImageElement"><span
 class="element-name">'image'</span></a> element.</p>
 <p><span class="requirement" id="assert_hqImageResampling">When the referenced image must be resampled to match the device coordinate
 system, it is recommended that high quality viewers make use of appropriate
 interpolation techniques, for example bilinear or bicubic.</span> Depending on the
 speed of the available interpolents, this choice may be affected by the <span
 class="prop-name">'image-rendering'</span> property setting.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feImageHrefAttribute"><span
   class="adef">xlink:href</span> =
   "<span class="attr-value">&lt;IRI&gt;</span>"</dt>
     <dd>An <a>IRI reference</a>
       to an image resource or to an element.
       <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feImageElementPreserveAspectRatioAttribute">
     <span class="adef">preserveAspectRatio</span> = "<span class='attr-value'>[defer] &lt;align&gt; [&lt;meetOrSlice&gt;]</span>"
      </dt>
      <dd>
        <p>
          See <a>'preserveAspectRatio'</a>.
        </p>
        <p>
          The lacuna value for <a>'preserveAspectRatio'</a> is <span class="attr-value">xMidYMid meet</span>.
        </p>
        <p><span class="anim-target"><a href="animate.html#Animatable">Animatable</a>: yes.</span></p>
      </dd>
    </dl>
 </div>
 <p><span class="example-ref">Example feImage</span> illustrates how images are placed relative
 to an object. From left to right:</p>
 <ul>
  <li>
    The default placement of an image. Note that the image is
    centered in the <a>filter region</a> and has the maximum size that will
    fit in the region consistent with preserving the aspect ratio.
  </li>
  <li>
    The image stretched to fit the bounding box of an object.
  </li>
  <li>
    The image placed using user coordinates. Note that the image is
    first centered in a box the size of the <a>filter region</a> and has the
    maximum size that will fit in the box consistent with preserving
    the aspect ratio. This box is then shifted by the given <a>'x'</a> and
    <a>'y'</a> values relative to the viewport the object is in.
  </li>
 </ul>
 <edit:example href='examples/feImage-01.svg' name='feImage' description='Examples of feImage use' image='yes' link='yes'/>
 </edit:with>
 <h2 id="feMergeElement">Filter primitive <span
 class="element-name">'feMerge'</span></h2>
 <edit:elementsummary name='feMerge'/>
 <edit:elementsummary name='feMergeNode'/>
 <p>This filter primitive composites input image layers on top of each other
 using the <em>over</em> operator with <em>Input1</em> (corresponding to the
 first <a href="#feMergeNodeElement"><span
 class="element-name">'feMergeNode'</span></a> child element) on the bottom
 and the last specified input, <em>InputN</em> (corresponding to the last <a
 href="#feMergeNodeElement"><span
 class="element-name">'feMergeNode'</span></a> child element), on top.</p>
 <p>Many effects produce a number of intermediate layers in order to create
 the final output image. This filter allows us to collapse those into a single
 image. Although this could be done by using n-1 Composite-filters, it is more
 convenient to have this common operation available in this form, and offers
 the implementation some additional flexibility.</p>
 <p>Each 'feMerge' element can have any number of 'feMergeNode' subelements,
 each of which has an <a href="#CommonAttributes"><span
 class="attr-name">in</span></a> attribute.</p>
 <p>The canonical implementation of feMerge is to render the entire effect
 into one RGBA layer, and then render the resulting layer on the output
 device. In certain cases (in particular if the output device itself is a
 continuous tone device), and since merging is associative, it might be a
 sufficient approximation to evaluate the effect one layer at a time and
 render each layer individually onto the output device bottom to top.</p>
 <p>If the topmost image input is <a href="#SourceGraphic"><span
 class="attr-value">SourceGraphic</span></a> and this <span
 class="element-name">'feMerge'</span> is the last filter primitive in the
 filter, the implementation is encouraged to render the layers up to that
 point, and then render the <a href="#SourceGraphic"><span
 class="attr-value">SourceGraphic</span></a> directly from its vector
 description on top.</p>
 <p id="feMergeNode"><a href="#AnExample">The example</a> at the start of this chapter makes
 use of the <span class="element-name">feMerge</span> filter primitive to
 composite two intermediate filter results together.</p>
 <h2 id="feMorphologyElement">Filter primitive <span
 class="element-name">'feMorphology'</span></h2>
 <edit:elementsummary name='feMorphology'/>
 <edit:with element='feMorphology'>
 <p>This filter primitive performs "fattening" or "thinning" of artwork. It is
 particularly useful for fattening or thinning an alpha channel.</p>
 <p>The dilation (or erosion) kernel is a rectangle with a width of
 *<em>x-radius</em> and a height of 2*<em>y-radius</em>. In dilation, the
 output pixel is the individual component-wise maximum of the corresponding
 R,G,B,A values in the input image's kernel rectangle. In erosion, the output
 pixel is the individual component-wise minimum of the corresponding R,G,B,A
 values in the input image's kernel rectangle.</p>
 <p>Frequently this operation will take place on alpha-only images, such as
 that produced by the built-in input, <a href="#SourceAlpha"><span
 class="attr-value">SourceAlpha</span></a>. In that case, the implementation
 might want to optimize the single channel case.</p>
 <p>If the input has infinite extent and is constant (e.g <span class="attr-value"><a href="#FillPaint">FillPaint</a></span>
 where the fill is a solid color), this operation has no effect.
 If the input has infinite extent and the filter result
 is the input to an <a>'feTile'</a>, the filter is evaluated with
 periodic boundary conditions.</p>
 <p>Because <span class="element-name">'feMorphology'</span> operates on
 premultipied color values, it will always result in color values less than or
 equal to the alpha channel.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feMorphologyOperatorAttribute"><span
   class="adef">operator</span> = "<em>erode | dilate</em>"</dt>
     <dd>A keyword indicating whether to erode (i.e., thin) or dilate (fatten)
       the source graphic.
       The lacuna value for <a>'operator'</a> is <span class="attr-value">erode</span>.
       <br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feMorphologyRadiusAttribute"><span class="adef">radius</span> =
   "<em><a>&lt;number-optional-number&gt;</a></em>"</dt>
     <dd>The radius (or radii) for the operation. If two <a>&lt;number&gt;</a>
       s are provided, the first number represents a x-radius and the second
       value represents a y-radius. If one number is provided, then that value
       is used for both X and Y. The values are in the coordinate system
       established by attribute <a>'filter/primitiveUnits'</a> on the <a
       href="#FilterElement"><span class="element-name">'filter'</span></a>
       element.<br />
       A negative or zero value disables the effect of the given filter
       primitive (i.e., the result is a transparent black image).<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">0</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 </edit:with>
 <edit:example href="examples/feMorphology.svg" image="yes" link="yes"/>
 <h2 id="feOffsetElement">Filter primitive <span
 class="element-name">'feOffset'</span></h2>
 <edit:elementsummary name='feOffset'/>
 <p>This filter primitive offsets the input image relative to its current
 position in the image space by the specified vector.</p>
 <p>This is important for effects like drop shadows.</p>
 <p>When applying this filter, the destination location may be offset by a
 fraction of a pixel in device space. <span class="requirement" id="assert_hqFeOffsetInterpolation">In this case a high quality viewer
 should make use of appropriate interpolation techniques, for example bilinear
 or bicubic.</span> This is especially recommended for dynamic viewers where this
 interpolation provides visually smoother movement of images. For static
 viewers this is less of a concern. Close attention should be made to the
 <span class="prop-name">'image-rendering'</span> property setting to
 determine the authors intent.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feOffsetDxAttribute"><span
   class="adef">dx</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>The amount to offset the input graphic along the x-axis. The offset
       amount is expressed in the coordinate system established by attribute
       <a>'filter/primitiveUnits'</a> on the <a>'filter element'</a>
       element.<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">0</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feOffsetDyAttribute"><span
   class="adef">dy</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>The amount to offset the input graphic along the y-axis. The offset
       amount is expressed in the coordinate system established by attribute
       <a>'filter/primitiveUnits'</a> on the <a
       href="#FilterElement"><span class="element-name">'filter'</span></a>
       element.<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">0</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <p><a href="#AnExample">The example</a> at the start of this chapter makes
 use of the <span class="element-name">feOffset</span> filter primitive to
 offset the drop shadow from the original source graphic.</p>
 <h2 id="feSpecularLightingElement">Filter primitive <span
 class="element-name">'feSpecularLighting'</span></h2>
 <edit:elementsummary name='feSpecularLighting'/>
 <p>This filter primitive lights a source graphic using the alpha channel as a
 bump map. The resulting image is an RGBA image based on the light color. The
 lighting calculation follows the standard specular component of the Phong
 lighting model. The resulting image depends on the light color, light
 position and surface geometry of the input bump map. The result of the
 lighting calculation is added. The filter primitive assumes that the viewer
 is at infinity in the z direction (i.e., the unit vector in the eye direction
 is (0,0,1) everywhere).</p>
 <p>This filter primitive produces an image which contains the specular
 reflection part of the lighting calculation. Such a map is intended to be
 combined with a texture using the <em>add</em> term of the
 <em>arithmetic</em> <a href="#feCompositeElement"><span
 class="element-name">'feComposite'</span></a> method. Multiple light sources
 can be simulated by adding several of these light maps before applying it to
 the texture image.</p>
 <p>The resulting RGBA image is computed as follows:</p>
 <p class="filterformula">S<sub>r</sub> = k<sub>s</sub> * pow(N.H,
 specularExponent) * L<sub>r<br />
 </sub> S<sub>g</sub> = k<sub>s</sub> * pow(N.H, specularExponent) *
 L<sub>g<br />
 </sub> S<sub>b</sub> = k<sub>s</sub> * pow(N.H, specularExponent) *
 L<sub>b<br />
 </sub> S<sub>a</sub> = max(S<sub>r,</sub> S<sub>g,</sub> S<sub>b</sub>)</p>
 <p>where</p>
 <dl>
     <dd>k<sub>s</sub> = specular lighting constant<br />
       N = surface normal unit vector, a function of x and y<br />
       H = "halfway" unit vector between eye unit vector and light unit
       vector<br />
       <br />
       L<sub>r</sub>,L<sub>g</sub>,L<sub>b</sub> = RGB components of light</dd>
 </dl>
 <p>See <a href="#feDiffuseLighting"><span
 class="element-name">'feDiffuseLighting'</span></a> for definition of N and
 (L<sub>r</sub>, L<sub>g</sub>, L<sub>b</sub>).</p>
 <p>The definition of H reflects our assumption of the constant eye vector E =
 (0,0,1):</p>
 <p class="filterformula">H = (L + E) / Norm(L+E)</p>
 <p>where L is the light unit vector.</p>
 <p>Unlike the <a href="#feDiffuseLighting"><span
 class="element-name">'feDiffuseLighting'</span></a>, the <span
 class="element-name">'feSpecularLighting'</span> filter produces a non-opaque
 image. This is due to the fact that the specular result
 (S<sub>r</sub>,S<sub>g</sub>,S<sub>b</sub>,S<sub>a</sub>) is meant to be
 added to the textured image. The alpha channel of the result is the max of
 the color components, so that where the specular light is zero, no additional
 coverage is added to the image and a fully white highlight will add
 opacity.</p>
 <p>The <a href="#feDiffuseLighting"><span
 class="element-name">'feDiffuseLighting'</span></a> and <span
 class="element-name">'feSpecularLighting'</span> filters will often be
 applied together. An implementation may detect this and calculate both maps
 in one pass, instead of two.</p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feSpecularLightingSurfaceScaleAttribute"><span
   class="adef">surfaceScale</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>height of surface when A<sub>in</sub> = 1.<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">1</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpecularLightingSpecularConstantAttribute"><span
   class="adef">specularConstant</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>ks in Phong lighting model. In SVG, this can be any non-negative
       number.<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">1</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpecularLightingSpecularExponentAttribute"><span
   class="adef">specularExponent</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>Exponent for specular term, larger is more "shiny". Range 1.0 to
 .0.<br />
       If the attribute is not specified, then the effect is as if a value of
       <span class="attr-value">1</span> were specified.<br />
       <span class="anim-target">Animatable: yes.</span></dd>
   <dt id="feSpecularLightingKernelUnitLengthAttribute"><span
   class="adef">kernelUnitLength</span> = "<span
   class="attr-value"><a>&lt;number-optional-number&gt;</a></span>"</dt>
     <dd>The first number is the &lt;dx&gt; value. The second number is the
       &lt;dy&gt; value. If the &lt;dy&gt; value is not specified, it defaults
       to the same value as &lt;dx&gt;. Indicates the intended distance in
       current filter units (i.e., units as determined by the value of
       attribute <a>'filter/primitiveUnits'</a>) for <code>dx</code> and
       <code>dy</code>, respectively, in the <a
       href="#SurfaceNormalCalculations">surface normal calculation
       formulas</a>. By specifying value(s) for <span
       class="attr-name">kernelUnitLength</span>, the kernel becomes defined
       in a scalable, abstract coordinate system. If <span
       class="attr-name">kernelUnitLength</span> is not specified, the
       <code>dx</code> and <code>dy</code> values should represent very small
       deltas relative to a given <code>(x,y)</code> position, which might be
       implemented in some cases as one pixel in the intermediate image
       offscreen bitmap, which is a pixel-based coordinate system, and thus
       potentially not scalable. For some level of consistency across display
       media and user agents, it is necessary that a value be provided for at
       least one of <span class="attr-name">filterRes</span> and <span
       class="attr-name">kernelUnitLength</span>. Discussion of intermediate
       images are in the <a href="#Introduction">Introduction</a> and in the
       description of attribute <a>'filter/filterRes'</a>.<br />
       If a negative or zero value is specified the default value will be used
       instead. <br />
       <span class="anim-target">Animatable: yes.</span></dd>
 </dl>
 </div>
 <p>The light source is defined by one of the child elements <a>'feDistantLight'</a>,
 <a>'fePointLight'</a> or <a>'feDistantLight'</a>. The light color is
 specified by property <a>'lighting-color'</a>.</p>
 <p><a href="#AnExample">The example</a> at the start of this chapter makes
 use of the <span class="element-name">feSpecularLighting</span> filter
 primitive to achieve a highly reflective, 3D glowing effect.</p>
 <h2 id="feTileElement">Filter primitive <span
 class="element-name">'feTile'</span></h2>
 <edit:elementsummary name='feTile'/>
 <p>This filter primitive fills a target rectangle with a repeated, tiled
 pattern of an input image.
 The target rectangle is as large as the <a>filter primitive subregion</a> established
 by the <span class="element-name">'feTile'</span> element.
 </p>
 <p>Typically, the input image has been defined with its own <a>filter primitive subregion</a> in order to
 define a reference tile. <span class="element-name">'feTile'</span>
 replicates the reference tile in both X and Y to completely fill the target
 rectangle. The top/left corner of each given tile is at location
 <code>(x+i*width,y+j*height)</code>, where <code>(x,y)</code> represents the
 top/left of the input image's <a>filter primitive subregion</a>, <code>width</code>
 and <code>height</code> represent the width and height of the input image's
 <a>filter primitive subregion</a>, and <code>i</code> and <code>j</code> can be any
 integer value. In most cases, the input image will have a smaller <a>filter
 primitive subregion</a> than the <span class="element-name">'feTile'</span> in
 order to achieve a repeated pattern effect.</p>
 <p class="requirement" id="assertTileArtifacts">Implementers must take appropriate measures in constructing the tiled
 image to avoid artifacts between tiles, particularly in situations where the
 user to device transform includes shear and/or rotation. Unless care is
 taken, interpolation can lead to edge pixels in the tile having opacity
 values lower or higher than expected due to the interaction of painting
 adjacent tiles which each have partial overlap with particular pixels.</p>
 <div class="adef-list">
   </div>
 <h2 id="feTurbulenceElement">Filter primitive <span
 class="element-name">'feTurbulence'</span></h2>
 <edit:with element="feTurbulence">
 <p class="specissue">ISSUE: Consider phasing out this C algorithm in favor of Simplex noise, which is more HW friendly.</p>
 <p>This filter primitive creates an image using the Perlin turbulence
 function. It allows the synthesis of artificial textures like clouds or
 marble. For a detailed description the of the Perlin turbulence function, see
 "Texturing and Modeling", Ebert et al, AP Professional, 1994. The resulting
 image will fill the entire <a>filter primitive subregion</a> for this filter primitive.</p>
 <p>It is possible to create bandwidth-limited noise by synthesizing only one
 octave.</p>
 <p>The C code below shows the exact algorithm used for this filter effect.
 The <a>filter primitive subregion</a> is to be passed as the arguments fTileX,
 fTileY, fTileWidth and fTileHeight.</p>
 <p>For fractalSum, you get a turbFunctionResult that is aimed at a range of
 -1 to 1 (the actual result might exceed this range in some cases). To convert
 to a color value, use the formula <code>colorValue = ((turbFunctionResult *
 ) + 255) / 2</code>, then clamp to the range 0 to 255.</p>
 <p>For turbulence, you get a turbFunctionResult that is aimed at a range of 0
 to 1 (the actual result might exceed this range in some cases). To convert to
 a color value, use the formula <code>colorValue = (turbFunctionResult *
 )</code>, then clamp to the range 0 to 255.</p>
 <p>The following order is used for applying the pseudo random numbers. An
 initial seed value is computed based on the <a>'seed'</a> attribute.
 Then the implementation computes the lattice
 points for R, then continues getting additional pseudo random numbers
 relative to the last generated pseudo random number and computes the lattice
 points for G, and so on for B and A.</p>
 <p>The generated color and alpha values are in the color space determined by
 the <a>'color-interpolation-filters'</a> property:</p>
 <pre class="svgsamplecompressed">/* Produces results in the range [1, 2**31 - 2].
 Algorithm is: r = (a * r) mod m
 where a = 16807 and m = 2**31 - 1 = 2147483647
 See [Park &amp; Miller], CACM vol. 31 no. 10 p. 1195, Oct. 1988
 To test: the algorithm should produce the result 1043618065
 as the 10,000th generated number if the original seed is 1.
 */
 #define RAND_m 2147483647 /* 2**31 - 1 */
 #define RAND_a 16807 /* 7**5; primitive root of m */
 #define RAND_q 127773 /* m / a */
 #define RAND_r 2836 /* m % a */
 long setup_seed(long lSeed)
 {
   if (lSeed &lt;= 0) lSeed = -(lSeed % (RAND_m - 1)) + 1;
   if (lSeed &gt; RAND_m - 1) lSeed = RAND_m - 1;
   return lSeed;
 }
 long random(long lSeed)
 {
   long result;
   result = RAND_a * (lSeed % RAND_q) - RAND_r * (lSeed / RAND_q);
   if (result &lt;= 0) result += RAND_m;
   return result;
 }
 #define BSize 0x100
 #define BM 0xff
 #define PerlinN 0x1000
 #define NP 12 /* 2^PerlinN */
 #define NM 0xfff
 static uLatticeSelector[BSize + BSize + 2];
 static double fGradient[4][BSize + BSize + 2][2];
 struct StitchInfo
 {
   int nWidth; // How much to subtract to wrap for stitching.
   int nHeight;
   int nWrapX; // Minimum value to wrap.
   int nWrapY;
 };
 static void init(long lSeed)
 {
   double s;
   int i, j, k;
   lSeed = setup_seed(lSeed);
   for(k = 0; k &lt; 4; k++)
   {
     for(i = 0; i &lt; BSize; i++)
     {
       uLatticeSelector[i] = i;
       for (j = 0; j &lt; 2; j++)
         fGradient[k][i][j] = (double)(((lSeed = random(lSeed)) % (BSize + BSize)) - BSize) / BSize;
       s = double(sqrt(fGradient[k][i][0] * fGradient[k][i][0] + fGradient[k][i][1] * fGradient[k][i][1]));
       fGradient[k][i][0] /= s;
       fGradient[k][i][1] /= s;
     }
   }
   while(--i)
   {
     k = uLatticeSelector[i];
     uLatticeSelector[i] = uLatticeSelector[j = (lSeed = random(lSeed)) % BSize];
     uLatticeSelector[j] = k;
   }
   for(i = 0; i &lt; BSize + 2; i++)
   {
     uLatticeSelector[BSize + i] = uLatticeSelector[i];
     for(k = 0; k &lt; 4; k++)
       for(j = 0; j &lt; 2; j++)
         fGradient[k][BSize + i][j] = fGradient[k][i][j];
   }
 }
 #define s_curve(t) ( t * t * (3. - 2. * t) )
 #define lerp(t, a, b) ( a + t * (b - a) )
 double noise2(int nColorChannel, double vec[2], StitchInfo *pStitchInfo)
 {
   int bx0, bx1, by0, by1, b00, b10, b01, b11;
   double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
   register i, j;
   t = vec[0] + PerlinN;
   bx0 = (int)t;
   bx1 = bx0+1;
   rx0 = t - (int)t;
   rx1 = rx0 - 1.0f;
   t = vec[1] + PerlinN;
   by0 = (int)t;
   by1 = by0+1;
   ry0 = t - (int)t;
   ry1 = ry0 - 1.0f;
   // If stitching, adjust lattice points accordingly.
   if(pStitchInfo != NULL)
   {
     if(bx0 &gt;= pStitchInfo-&gt;nWrapX)
       bx0 -= pStitchInfo-&gt;nWidth;
     if(bx1 &gt;= pStitchInfo-&gt;nWrapX)
       bx1 -= pStitchInfo-&gt;nWidth;
     if(by0 &gt;= pStitchInfo-&gt;nWrapY)
       by0 -= pStitchInfo-&gt;nHeight;
     if(by1 &gt;= pStitchInfo-&gt;nWrapY)
       by1 -= pStitchInfo-&gt;nHeight;
   }
   bx0 &amp;= BM;
   bx1 &amp;= BM;
   by0 &amp;= BM;
   by1 &amp;= BM;
   i = uLatticeSelector[bx0];
   j = uLatticeSelector[bx1];
   b00 = uLatticeSelector[i + by0];
   b10 = uLatticeSelector[j + by0];
   b01 = uLatticeSelector[i + by1];
   b11 = uLatticeSelector[j + by1];
   sx = double(s_curve(rx0));
   sy = double(s_curve(ry0));
   q = fGradient[nColorChannel][b00]; u = rx0 * q[0] + ry0 * q[1];
   q = fGradient[nColorChannel][b10]; v = rx1 * q[0] + ry0 * q[1];
   a = lerp(sx, u, v);
   q = fGradient[nColorChannel][b01]; u = rx0 * q[0] + ry1 * q[1];
   q = fGradient[nColorChannel][b11]; v = rx1 * q[0] + ry1 * q[1];
   b = lerp(sx, u, v);
   return lerp(sy, a, b);
 }
 double turbulence(int nColorChannel, double *point, double <a href="#feTurbulenceBaseFrequencyAttribute">fBaseFreqX</a>, double <a href="#feTurbulenceBaseFrequencyAttribute">fBaseFreqY</a>,
           int <a href="#feTurbulenceNumOctavesAttribute">nNumOctaves</a>, bool bFractalSum, bool bDoStitching,
           double <a href="#FilterPrimitiveSubRegion">fTileX</a>, double <a href="#FilterPrimitiveSubRegion">fTileY</a>, double <a href="#FilterPrimitiveSubRegion">fTileWidth</a>, double <a href="#FilterPrimitiveSubRegion">fTileHeight</a>)
 {
   StitchInfo stitch;
   StitchInfo *pStitchInfo = NULL; // Not stitching when NULL.
   // Adjust the base frequencies if necessary for stitching.
   if(bDoStitching)
   {
     // When stitching tiled turbulence, the frequencies must be adjusted
     // so that the tile borders will be continuous.
     if(fBaseFreqX != 0.0)
     {
       double fLoFreq = double(floor(fTileWidth * fBaseFreqX)) / fTileWidth;
       double fHiFreq = double(ceil(fTileWidth * fBaseFreqX)) / fTileWidth;
       if(fBaseFreqX / fLoFreq &lt; fHiFreq / fBaseFreqX)
         fBaseFreqX = fLoFreq;
       else
         fBaseFreqX = fHiFreq;
     }
     if(fBaseFreqY != 0.0)
     {
       double fLoFreq = double(floor(fTileHeight * fBaseFreqY)) / fTileHeight;
       double fHiFreq = double(ceil(fTileHeight * fBaseFreqY)) / fTileHeight;
       if(fBaseFreqY / fLoFreq &lt; fHiFreq / fBaseFreqY)
         fBaseFreqY = fLoFreq;
       else
         fBaseFreqY = fHiFreq;
     }
     // Set up initial stitch values.
     pStitchInfo = &amp;stitch;
     stitch.nWidth = int(fTileWidth * fBaseFreqX + 0.5f);
     stitch.nWrapX = fTileX * fBaseFreqX + PerlinN + stitch.nWidth;
     stitch.nHeight = int(fTileHeight * fBaseFreqY + 0.5f);
     stitch.nWrapY = fTileY * fBaseFreqY + PerlinN + stitch.nHeight;
   }
   double fSum = 0.0f;
   double vec[2];
   vec[0] = point[0] * fBaseFreqX;
   vec[1] = point[1] * fBaseFreqY;
   double ratio = 1;
   for(int nOctave = 0; nOctave &lt; nNumOctaves; nOctave++)
   {
     if(bFractalSum)
       fSum += double(noise2(nColorChannel, vec, pStitchInfo) / ratio);
     else
       fSum += double(fabs(noise2(nColorChannel, vec, pStitchInfo)) / ratio);
     vec[0] *= 2;
     vec[1] *= 2;
     ratio *= 2;
     if(pStitchInfo != NULL)
     {
       // Update stitch values. Subtracting PerlinN before the multiplication and
       // adding it afterward simplifies to subtracting it once.
       stitch.nWidth *= 2;
       stitch.nWrapX = 2 * stitch.nWrapX - PerlinN;
       stitch.nHeight *= 2;
       stitch.nWrapY = 2 * stitch.nWrapY - PerlinN;
     }
   }
   return fSum;
 }</pre>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feTurbulenceBaseFrequencyAttribute"><span
   class="adef">baseFrequency</span> =
   "<em><a>&lt;number-optional-number&gt;</a></em>"</dt>
     <dd>
     <p>The base frequency (frequencies) parameter(s) for the noise function.
       If two <a>&lt;number&gt;</a>s are provided, the first number represents a base frequency in the X
       direction and the second value represents a base frequency in the Y
       direction. If one number is provided, then that value is used for both
       X and Y.</p>
     <p>The <a>lacuna value</a> for <a>'baseFrequency'</a> is <span class="attr-value">0</span>.</p>
     <p>Negative values are <a>unsupported</a>.</p>
         <p><span class="anim-target">Animatable: yes.</span></p>
 </dd>
   <dt id="feTurbulenceNumOctavesAttribute"><span
   class="adef">numOctaves</span> = "<em><a>&lt;integer&gt;</a></em>"</dt>
     <dd>
     <p>The numOctaves parameter for the noise function.</p>
         <p><span class="requirement" id="assert_turbulenceNumOctavesLacunaValue">The <a>lacuna value</a> for <a>'numOctaves'</a> is <span class="attr-value">1</span>.</span></p>
     <p><span class="requirement" id="assert_turbulenceNumOctavesUnsupportedValue">Negative values are <a>unsupported</a>.</span></p>
         <p><span class="requirement" id="assert_turbulenceNumOctavesAnimatable"><span class="anim-target">Animatable: yes.</span></span></p>
   </dd>
   <dt id="feTurbulenceSeedAttribute">
   <span class="adef">seed</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>
     <p>The starting number for the pseudo random number generator.</p>
     <p><span class="requirement" id="assert_turbulenceSeedLacunaValue">The <a>lacuna value</a> for <a>'seed'</a> is <span class="attr-value">0</span>.</span></p>
       <p><span class="requirement" id="assert_turbulenceSeedTruncation">When the seed number is handed over to the algorithm above it must first be
     truncated, i.e. rounded to the closest integer value towards zero.</span></p>
         <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="feTurbulenceStitchTilesAttribute"><span
   class="adef">stitchTiles</span> = "<em>stitch | noStitch</em>"</dt>
     <dd>
   <p>If <span class="attr-value">stitchTiles="noStitch"</span>, no attempt
       it made to achieve smooth transitions at the border of tiles which
       contain a turbulence function. Sometimes the result will show clear
       discontinuities at the tile borders.<br />
       If <span class="attr-value">stitchTiles="stitch"</span>, then the user
       agent will automatically adjust baseFrequency-x and baseFrequency-y
       values such that the <a>'feTurbulence'</a> node's width and height (i.e., the
       width and height of the current subregion) contains an integral number
       of the Perlin tile width and height for the first octave. The
       baseFrequency will be adjusted up or down depending on which way has
       the smallest relative (not absolute) change as follows: Given the
       frequency, calculate <code>lowFreq=floor(width*frequency)/width</code>
       and <code>hiFreq=ceil(width*frequency)/width</code>. If
       frequency/lowFreq &lt; hiFreq/frequency then use lowFreq, else use
       hiFreq. While generating turbulence values, generate lattice vectors as
       normal for Perlin Noise, except for those lattice points that lie on
       the right or bottom edges of the active area (the size of the resulting
       tile). In those cases, copy the lattice vector from the opposite edge
       of the active area.</p>
     <p><span class="requirement" id="assert_turbulenceStitchTilesLacunaValue">The <a>lacuna value</a> for <a>'stitchTiles'</a> is <span class="attr-value">noStitch</span>.</span></p>
       <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="feTurbulenceTypeAttribute">
   <span class="adef">type</span> = "<em>fractalNoise | turbulence</em>"</dt>
     <dd>
     <p>Indicates whether the filter primitive should perform a noise or
       turbulence function.</p>
     <p><span class="requirement" id="assert_turbulenceTypeLacunaValue">The <a>lacuna value</a> for <a>'type'</a> is <span class="attr-value">turbulence</span>.</span></p>
         <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
 </dl>
 </div>
 <edit:example href="examples/feTurbulence.svg" image="yes" link="yes"/>
 </edit:with>
 <h2 id="feDropShadowElement">Filter primitive <span
 class="element-name">'feDropShadow'</span></h2>
 <edit:elementsummary name='feDropShadow'/>
 <p>This filter creates a drop shadow of the input image. It is a shorthand
 filter, and is defined in terms of combinations of other <a>filter primitives</a>.
 The expectation is that it can be optimized more easily by
 implementations.</p>
 <p>The result of a <a>'feDropShadow'</a> filter
 primitive is equivalent to the following:
 <pre class="examplesource">
   &lt;feGaussianBlur in="<b>alpha-channel-of-feDropShadow-in</b>" stdDeviation="<b>stdDeviation-of-feDropShadow</b>"/&gt;
   &lt;feOffset dx="<b>dx-of-feDropShadow</b>" dy="<b>dy-of-feDropShadow</b>" result="offsetblur"/&gt;
   &lt;feFlood flood-color="<b>flood-color-of-feDropShadow</b>" flood-opacity="<b>flood-opacity-of-feDropShadow</b>"/&gt;
   &lt;feComposite in2="offsetblur" operator="in"/&gt;
   &lt;feMerge&gt;
     &lt;feMergeNode/&gt;
     &lt;feMergeNode in="<b>in-of-feDropShadow</b>"/&gt;
   &lt;/feMerge&gt;
 </pre>
 </p>
 <p>
 The above divided into steps:
 <ol>
   <li>Take the alpha channel of the input to the <a>'feDropShadow'</a> filter primitive and the <a>'feDropShadow/stdDeviation'</a> on the <a>'feDropShadow'</a> and do processing as if the
     following <a>'feGaussianBlur'</a> was applied:
     <pre class="examplesource"> &lt;feGaussianBlur in="<b>alpha-channel-of-feDropShadow-in</b>" stdDeviation="<b>stdDeviation-of-feDropShadow</b>"/&gt;</pre>
     <br />
   </li>
   <li>Offset the result of step 1 by <a>'feDropShadow/dx'</a> and <a>'feDropShadow/dy'</a> as
     specified on the <a>'feDropShadow'</a>
     element, equivalent to applying an <a>'feOffset'</a> with these parameters:
     <pre class="examplesource"> &lt;feOffset dx="<b>dx-of-feDropShadow</b>" dy="<b>dy-of-feDropShadow</b>" result="offsetblur"/&gt;</pre>
     <br />
   </li>
   <li>Do processing as if an <a>'feFlood'</a> element with <a>'flood-color'</a> and
   <a>'flood-opacity'</a> as specified on the <a>'feDropShadow'</a> was applied:
     <pre class="examplesource"> &lt;feFlood flood-color="<b>flood-color-of-feDropShadow</b>" flood-opacity="<b>flood-opacity-of-feDropShadow</b>"/&gt;</pre>
     <br />
   </li>
   <li>Composite the result of the <a href="#feFloodElement"><span
     class="element-name">'feFlood'</span></a> in step 3 with the result of
     the <a href="#feOffsetElement"><span
     class="element-name">'feOffset'</span></a> in step 2 as if an <a>'feComposite'</a> filter primitive with <a
     href="#feCompositeOperatorAttribute"><span
     class="attr-name">operator</span></a>='in' was applied:
     <pre class="examplesource"> &lt;feComposite in2="offsetblur" operator="in"/&gt;</pre>
     <br />
   </li>
   <li>Finally merge the result of the previous step, doing processing as if
     the following <a>'feMerge'</a> was performed:
     <pre class="examplesource"> &lt;feMerge&gt;
       &lt;feMergeNode/&gt;
       &lt;feMergeNode in="<b>in-of-feDropShadow</b>"/&gt;
   &lt;/feMerge&gt;</pre>
   </li>
 </ol>
 </p>
 <p class="note implementation">Note that while the definition of the <span
 class="element-name">'feDropShadow'</span> filter primitive says that it can
 be expanded into an equivalent tree it is not required that it is implemented
 like that. The expectation is that user agents can optimize the handling by not having to do all the steps separately.
 </p>
 <p>Beyond the DOM interface <a
 href="#InterfaceSVGFEDropShadowElement">SVGFEDropShadowElement</a> there is no way
 of accessing the internals of the <a>'feDropShadow'</a> filter primitive, meaning <span class="requirement" id="assert_dropShadowShadowTrees">if the
 filter primitive is implemented as an equivalent tree then that tree must not
 be exposed to the DOM.</span> </p>
 <div class="adef-list">
 <p><em>Attribute definitions:</em></p>
 <dl>
   <dt id="feDropShadowDxAttribute">
   <span class="adef">dx</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>
     <p>The x offset of the drop shadow.</p>
     <p>The <a>lacuna value</a> for <a>'feDropShadow/dx'</a> is <span class="attr-value">2</span>.</p>
     <p>This attribute is then forwarded to the <a>'feOffset/dx'</a> attribute of the internal <a>'feOffset'</a> element.</p>
     <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="feDropShadowDyAttribute">
   <span class="adef">dy</span> = "<em><a>&lt;number&gt;</a></em>"</dt>
     <dd>
     <p>The y offset of the drop shadow.</p>
     <p>The <a>lacuna value</a> for <a>'feDropShadow/dy'</a> is <span class="attr-value">2</span>. </p>
     <p>This attribute is then forwarded to the <a>'feOffset/dy'</a> attribute of the internal <a>'feOffset'</a> element.</p>
     <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
   <dt id="feDropShadowStdDeviationAttribute"><span
   class="adef">stdDeviation</span> =
   "<em><a>&lt;number-optional-number&gt;</a></em>"</dt>
     <dd>
     <p>The standard deviation for the blur operation in the drop shadow.</p>
     <p>The <a>lacuna value</a> for <a>'feDropShadow/stdDeviation'</a> is <span class="attr-value">2</span>.</p>
     <p>This attribute is then forwarded to the <a>'feGaussianBlur/stdDeviation'</a> attribute of the internal
       <a>'feGaussianBlur'</a> element.</p>
     <p><span class="anim-target">Animatable: yes.</span></p>
   </dd>
 </dl>
 </div>
 <div class="note">
 <h2 id="feDiffuseSpecularElement">Filter primitive <span
 class="element-name">'feDiffuseSpecular'</span></h2>
 The WG is looking at providing a shorthand for diffuse+specular.
 </div>
 <div class="note">
 <h2 id="feCustomElement">Filter primitive <span
 class="element-name">'feCustom'</span></h2>
 The WG is considering a proposal to add a filter primitive that would reference a
 programmable operation, similar to an OpenCL kernel or GLSL fragment shader. At
 this time, the WG is intending to <strong>not</strong> include such a feature
 in the current version of this specification. If you feel it is necessary, please
 submit feedback to the WG (by email, described in the introduction) with your
 reasons and, preferably, use cases.
 </div>
 <h2 id="FilterCSSImageValue">The filter CSS &lt;image&gt; value</h2>
 <p>
   The filter() function produces a CSS &lt;image&gt; value. It has the following syntax:
 </p>
 <h4 class='no-toc' id='filter-syntax'>
 filter() syntax</h4>
 <pre class='prod'><code><dfn>&lt;filter></dfn> = filter(
   &lt;image>,
   none | &lt;filter-function&gt; [ &lt;filter-function&gt; ]*
 )
 </code></pre>
 <p>
   The function takes two parameters. The first is a CSS &lt;image&gt; value. The second
   is the value of a <span class="prop-name">filter</span> property. The function take the
   input image parameter and apply the filter rules, returning a processing image.
 </p>
 <h2 id="RelaxNG">RelaxNG Schema for Filter Effects 1.0</h2>
 <p>The schema for Filter Effects 1.0 is written in <a
 href="http://www.y12.doe.gov/sgml/sc34/document/0362_files/relaxng-is.pdf">RelaxNG</a>
 [<a href="#ref-RNG">RelaxNG</a>], a namespace-aware schema language that uses
 the datatypes from <a
 href="http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/">XML Schema Part
 </a> [<a href="#ref-Schema2">Schema2</a>]. This allows namespaces and
 modularity to be much more naturally expressed than using DTD syntax. The
 RelaxNG schema for Filter Effects 1.0 may be imported by other RelaxNG schemas,
 or combined with other schemas in other languages into a multi-namespace,
 multi-grammar schema using <a
 href="http://www.asahi-net.or.jp/~eb2m-mrt/dsdl/">Namespace-based Validation
 Dispatching Language</a> [<a href="#ref-NVDL">NVDL</a>].</p>
 <p>Unlike a DTD, the schema used for validation is not hardcoded into the
 document instance. There is no equivalent to the DOCTYPE declaration. Simply
 point your editor or other validation tool to the IRI of the schema (or your
 local cached copy, as you prefer).</p>
 <p>
 The RNG is under construction, and only the individual RNG snippets are available at this time. They have not yet been integrated into a functional schema. The individual RNG files are available <a href="rng">here</a>.
 </p>
 <h2 id="ShorthandEquivalents">Shorthands defined in terms of the <span class="element-name">'filter'</span> element</h2>
 <p>
   Below are the equivalents for each of the filter functions expressed in terms of
   the 'filter element' element. The parameters from the function are labelled with
   brackets in the following style: [amount].
 </p>
 <h3 id="grayscaleEquivalent">grayscale</h3>
 <pre class="examplesource"> &lt;filter id="grayscale"&gt;
     &lt;feColorMatrix type="matrix"
                values="(0.2127 * [amount]) (0.7152 * [amount]) (0.0722 * [amount]) 0 0
                        (0.2127 * [amount]) (0.7152 * [amount]) (0.0722 * [amount]) 0 0
                        (0.2127 * [amount]) (0.7152 * [amount]) (0.0722 * [amount]) 0 0
 0 0 1 0"/&gt;
   &lt;/filter&gt; </pre>
 <h3 id="sepiaEquivalent">sepia</h3>
 <pre class="examplesource"> &lt;filter id="sepia"&gt;
     &lt;feColorMatrix type="matrix"
                values="(0.393 * [amount]) (0.769 * [amount]) (0.189 * [amount]) 0 0
                        (0.349 * [amount]) (0.686 * [amount]) (0.168 * [amount]) 0 0
                        (0.272 * [amount]) (0.534 * [amount]) (0.131 * [amount]) 0 0
 0 0 1 0"/&gt;
   &lt;/filter&gt; </pre>
 <h3 id="saturateEquivalent">saturate</h3>
 <pre class="examplesource"> &lt;filter id="saturate"&gt;
     &lt;feColorMatrix type="saturate"
                values="(1 - [amount])"/&gt;
   &lt;/filter&gt; </pre>
 <h3 id="huerotateEquivalent">hue-rotate</h3>
 <pre class="examplesource"> &lt;filter id="hue-rotate"&gt;
     &lt;feColorMatrix type="hueRotate"
                values="[angle]"/&gt;
   &lt;/filter&gt; </pre>
 <h3 id="invertEquivalent">invert</h3>
 <pre class="examplesource"> &lt;filter id="invert"&gt;
     &lt;feComponentTransfer&gt;
         &lt;feFuncR type="table" tableValues="[amount] (1 - [amount])"/&gt;
         &lt;feFuncG type="table" tableValues="[amount] (1 - [amount])"/&gt;
         &lt;feFuncB type="table" tableValues="[amount] (1 - [amount])"/&gt;
     &lt;/feComponentTransfer&gt;
   &lt;/filter&gt; </pre>
 <h3 id="opacityEquivalent">opacity</h3>
 <pre class="examplesource"> &lt;filter id="opacity"&gt;
     &lt;feComponentTransfer&gt;
         &lt;feFuncA type="table" tableValues="0 [amount]"/&gt;
     &lt;/feComponentTransfer&gt;
   &lt;/filter&gt; </pre>
 <h3 id="gammaEquivalent">gamma</h3>
 <pre class="examplesource"> &lt;filter id="gamma"&gt;
     &lt;feComponentTransfer&gt;
         &lt;feFuncR type="gamma" amplitude="[amplitude]" exponent="[exponent]" offset="[offset]"/&gt;
         &lt;feFuncG type="gamma" amplitude="[amplitude]" exponent="[exponent]" offset="[offset]"/&gt;
         &lt;feFuncB type="gamma" amplitude="[amplitude]" exponent="[exponent]" offset="[offset]"/&gt;
     &lt;/feComponentTransfer&gt;
   &lt;/filter&gt; </pre>
 <h3 id="blurEquivalent">blur</h3>
 <pre class="examplesource"> &lt;filter id="blur"&gt;
     &lt;feGaussianBlur stdDeviation="[radiusX radiusY]"&gt;
   &lt;/filter&gt; </pre>
 <h3 id="sharpenEquivalent">sharpen</h3>
 <pre class="examplesource"> &lt;filter id="unsharp"&gt;
     &lt;feUnsharpMask stdDeviation="[radius]" threshold="[threshold]" amount="[amount]"&gt;
   &lt;/filter&gt; </pre>
 <h3 id="dropshadowEquivalent">drop-shadow</h3>
 <pre class="examplesource"> &lt;filter id="drop-shadow"&gt;
     &lt;feGaussianBlur in="[alpha-channel-of-input]" stdDeviation="[radius]"/&gt;
     &lt;feOffset dx="[offset-x]" dy="[offset-y]" result="offsetblur"/&gt;
     &lt;feFlood flood-color="[color]"/&gt;
     &lt;feComposite in2="offsetblur" operator="in"/&gt;
     &lt;feMerge&gt;
       &lt;feMergeNode/&gt;
       &lt;feMergeNode in="input-image"/&gt;
     &lt;/feMerge&gt;
   &lt;/filter&gt; </pre>
 <h2 id="DOMInterfaces">DOM interfaces</h2>
 <div class="note">
 The interfaces below will be made available in a IDL file for an upcoming draft.
 </div>
 <h3 id="InterfaceImageData">Interface ImageData</h3>
 <edit:interface name='::svg::ImageData'/>
 <h3 id="InterfaceSVGFilterElement">Interface SVGFilterElement</h3>
 <edit:with element='filter'>
 <edit:interface name='::svg::SVGFilterElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFilterPrimitiveStandardAttributes">Interface SVGFilterPrimitiveStandardAttributes</h3>
 <edit:with element='feTile'>
 <edit:interface name='::svg::SVGFilterPrimitiveStandardAttributes'/>
 </edit:with>
 <h3 id="InterfaceSVGFEBlendElement">Interface SVGFEBlendElement</h3>
 <edit:with element='feBlend'>
 <edit:interface name='::svg::SVGFEBlendElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEColorMatrixElement">Interface SVGFEColorMatrixElement</h3>
 <edit:with element='feColorMatrix'>
 <edit:interface name='::svg::SVGFEColorMatrixElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEComponentTransferElement">Interface SVGFEComponentTransferElement</h3>
 <edit:with element='feComponentTransfer'>
 <edit:interface name='::svg::SVGFEComponentTransferElement'/>
 </edit:with>
 <h3 id="InterfaceSVGComponentTransferFunctionElement">Interface SVGComponentTransferFunctionElement</h3>
 <edit:with element='feFuncR'>
 <edit:interface name='::svg::SVGComponentTransferFunctionElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEFuncRElement">Interface SVGFEFuncRElement</h3>
 <edit:with element='feFuncR'>
 <edit:interface name='::svg::SVGFEFuncRElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEFuncGElement">Interface SVGFEFuncGElement</h3>
 <edit:with element='feFuncG'>
 <edit:interface name='::svg::SVGFEFuncGElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEFuncBElement">Interface SVGFEFuncBElement</h3>
 <edit:with element='feFuncB'>
 <edit:interface name='::svg::SVGFEFuncBElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEFuncAElement">Interface SVGFEFuncAElement</h3>
 <edit:with element='feFuncA'>
 <edit:interface name='::svg::SVGFEFuncAElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFECompositeElement">Interface SVGFECompositeElement</h3>
 <edit:with element='feComposite'>
 <edit:interface name='::svg::SVGFECompositeElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEConvolveMatrixElement">Interface SVGFEConvolveMatrixElement</h3>
 <edit:with element='feConvolveMatrix'>
 <edit:interface name='::svg::SVGFEConvolveMatrixElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEDiffuseLightingElement">Interface SVGFEDiffuseLightingElement</h3>
 <edit:with element='feDiffuseLighting'>
 <edit:interface name='::svg::SVGFEDiffuseLightingElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEDistantLightElement">Interface SVGFEDistantLightElement</h3>
 <edit:with element='feDistantLight'>
 <edit:interface name='::svg::SVGFEDistantLightElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEPointLightElement">Interface SVGFEPointLightElement</h3>
 <edit:with element='fePointLight'>
 <edit:interface name='::svg::SVGFEPointLightElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFESpotLightElement">Interface SVGFESpotLightElement</h3>
 <edit:with element='feSpotLight'>
 <edit:interface name='::svg::SVGFESpotLightElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEDisplacementMapElement">Interface SVGFEDisplacementMapElement</h3>
 <edit:with element='feDisplacementMap'>
 <edit:interface name='::svg::SVGFEDisplacementMapElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEFloodElement">Interface SVGFEFloodElement</h3>
 <edit:with element='feFlood'>
 <edit:interface name='::svg::SVGFEFloodElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEGaussianBlurElement">Interface SVGFEGaussianBlurElement</h3>
 <edit:with element='feGaussianBlur'>
 <edit:interface name='::svg::SVGFEGaussianBlurElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEImageElement">Interface SVGFEImageElement</h3>
 <edit:with element='feImage'>
 <edit:interface name='::svg::SVGFEImageElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEMergeElement">Interface SVGFEMergeElement</h3>
 <edit:with element='feMerge'>
 <edit:interface name='::svg::SVGFEMergeElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEMergeNodeElement">Interface SVGFEMergeNodeElement</h3>
 <edit:with element='feMergeNode'>
 <edit:interface name='::svg::SVGFEMergeNodeElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEMorphologyElement">Interface SVGFEMorphologyElement</h3>
 <edit:with element='feMorphology'>
 <edit:interface name='::svg::SVGFEMorphologyElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEOffsetElement">Interface SVGFEOffsetElement</h3>
 <edit:with element='feOffset'>
 <edit:interface name='::svg::SVGFEOffsetElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFESpecularLightingElement">Interface SVGFESpecularLightingElement</h3>
 <edit:with element='feSpecularLighting'>
 <edit:interface name='::svg::SVGFESpecularLightingElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFETileElement">Interface SVGFETileElement</h3>
 <edit:with element='feTile'>
 <edit:interface name='::svg::SVGFETileElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFETurbulenceElement">Interface SVGFETurbulenceElement</h3>
 <edit:with element='feTurbulence'>
 <edit:interface name='::svg::SVGFETurbulenceElement'/>
 </edit:with>
 <h3 id="InterfaceSVGFEDropShadowElement">Interface SVGFEDropShadowElement</h3>
 <edit:with element='feDropShadow'>
 <edit:interface name='::svg::SVGFEDropShadowElement'/>
 </edit:with>
 <h2 id="references1">References</h2>
 <h3 id="normref">Normative References</h3>
 <dl>
   <dt id="ref-CSS21"><strong class="normref">[CSS21]</strong></dt>
     <dd><strong>Cascading Style Sheets Level 2 Revision 1 (CSS 2.1) Specification</strong>,
     Bert Bos, Tantek Çelik, Ian Hickson, Håkon Wium Lie, eds.,
     W3C, 23 April 2009, (Candidate Recommendation) </dd>
   <dt id="ref-NVDL"><strong class="normref">[NVDL]</strong></dt>
     <dd><strong>Document Schema Definition Languages (DSDL) — Part 4:
       Namespace-based Validation Dispatching Language — NVDL. ISO/IEC FCD
 -4</strong>, See <a
       href="http://www.asahi-net.or.jp/~eb2m-mrt/dsdl/">http://www.asahi-net.or.jp/~eb2m-mrt/dsdl/</a>
     </dd>
   <dt id="ref-PORTERDUFF"><strong class="normref">[PORTERDUFF]</strong></dt>
     <dd><strong>Compositing Digital Images</strong>, T. Porter, T. Duff,
       SIGGRAPH '84 Conference Proceedings, Association for Computing
       Machinery, Volume 18, Number 3, July 1984. </dd>
   <dt id="ref-SVG-COMPOSITING"><strong class="normref">[SVG-COMPOSITING]</strong></dt>
   <dd>
     <cite class="w3cwd"><a href="http://www.w3.org/TR/2009/WD-SVGCompositing-20090430/">SVG Compositing Specification</a></cite>,
     A. Grasso, ed.
     World Wide Web Consortium, 30 April 2009.
     <br/>This edition of SVG Compositing is http://www.w3.org/TR/2009/WD-SVGCompositing-20090430/.
     <br/>The <a href="http://www.w3.org/TR/SVGCompositing/">latest edition of SVG Compositing</a> is available at
     http://www.w3.org/TR/SVGCompositing/.
   </dd>
   <dt id="ref-RNG"><strong class="normref">[RelaxNG]</strong></dt>
     <dd><strong>Document Schema Definition Languages (DSDL) — Part 2:
       Regular grammar- based validation — RELAX NG. ISO/IEC FDIS
 -2:2002(E)</strong>, J. Clark, <span class="ruby"><span
       xml:lang="ja" lang="ja" class="rb">村田 真</span> <span
       class="rp">(</span><span class="rt"><span
       class="familyname">Murata</span> M.</span><span
       class="rp">)</span></span>, eds., 12 December 2002. See <a
       href="http://www.y12.doe.gov/sgml/sc34/document/0362_files/relaxng-is.pdf">http://www.y12.doe.gov/sgml/sc34/document/0362_files/relaxng-is.pdf</a>
     </dd>
   <dt id="ref-Schema2"><strong class="normref">[Schema2]</strong></dt>
     <dd><strong>XML Schema Part 2: Datatypes Second Edition</strong>, P.
       Biron, A. Malhotra, eds. W3C, 28 October 2004 (Recommendation). Latest
       version available at <a
       href="http://www.w3.org/TR/xmlschema-2/">http://www.w3.org/TR/xmlschema-2/</a>.
       See also <a
       href="http://www.w3.org/TR/2005/NOTE-xml11schema10-20050511/">Processing
       XML 1.1 documents with XML Schema 1.0 processors</a>. </dd>
   <dt id="ref-svg11"><strong class="normref">[SVG11]</strong></dt>
     <dd><strong>Scalable Vector Graphics (SVG) 1.1 Specification</strong>,
       Dean Jackson editor, W3C, 14 January 2003 (Recommendation). See <a
       href="http://www.w3.org/TR/2003/REC-SVG11-20030114/">http://www.w3.org/TR/2003/REC-SVG11-20030114/</a>
     </dd>
   <dt id="ref-svgt12"><strong class="normref">[SVGT12]</strong></dt>
     <dd><strong>Scalable Vector Graphics (SVG) Tiny 1.2 Specification</strong>,
       Dean Jackson editor, W3C, 22 December 2008 (Recommendation). See <a
       href="http://www.w3.org/TR/2008/REC-SVGTiny12-20081222/">http://www.w3.org/TR/2008/REC-SVGTiny12-20081222/</a>
     </dd>
 </dl>
 <h3 id="informref">Informative References</h3>
 <dl>
   <dt id="ref-html5"><strong class="informref">[HTML5]</strong></dt>
     <dd><strong>HTML5</strong>, Ian Hickson editor, Google,
 June 2008 (Working Draft). See <a
       href="http://www.w3.org/TR/2008/WD-html5-20080610/">http://www.w3.org/TR/2008/WD-html5-20080610/</a>
     </dd>
 </dl>
   <h2 id="changes">Changes</h2>
   <p>For changes since the last published draft, see the public <a href="http://dev.w3.org/cvsweb/SVG/modules/filters/publish/">cvs log</a>.</p>
 </body>
 </html>

Mercurial > drafts / annotate

filters/master/Filters.html@b31bb9367aef (annotated)

filters/master/Filters.html