File: index.html

package info (click to toggle)
gegl 0.0.18-1
links: PTS
area: main
in suites: lenny
size: 6,784 kB
ctags: 4,389
sloc: ansic: 45,496; sh: 9,223; ruby: 1,361; makefile: 740; cpp: 509; xml: 256
file content (1442 lines) | stat: -rw-r--r-- 43,062 bytes
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8" />
<meta name="generator" content="AsciiDoc 8.2.5" />
<style type="text/css">
      li>p {
          display: inline;
      }
      body {
        margin-left: 12.5em;
        margin-right: 2em;
        padding: 0;
        background-color: #fff;
	color: black;
      }
      div.paper {
        background-color: #fff;
	color: black;
        margin: 1em;
        /*margin-left: 12.5em;*/
      }
      iframe {
        background-color: #aaa;
      }
      div.content {
        padding: 1em;
        padding-right: 3em;
        padding-left: 2em;
        max-width: 45em;
      }
      div.graphic {
        position: absolute;
        position: fixed;
        color: #fff;
        width:  297px;
        height: 230px;
        bottom: 0;
        left: 0;
        text-align: right;
        padding-bottom: 1em;
      }
      p {
        line-height: 1.2em;
      }
      h1 {
        margin-top: 0em;
      }
      h1, h2, h3, h4{
        color: #112266;
      }
      h1 {
        font-size: 2em;
      }
      h2 {
        font-size: 1.5em;
      }
      h3 {
        font-size: 1.2em;
      }
      h4 {
        font-size: 1.0em;
      }
      dl {
        margin-top: 1em;
        margin-bottom: 1em;
      }

      div.expander {
        border: 1px solid #bbb;
      }
      div.expander_title {
        /*border-bottom: 0px solid #aaa;*/
      }
      div.expander_content {
        margin-left: 2em;
        display: none;
        padding-bottom: 1em;
      }
      div.expander_content dl{
        margin: 0;
        padding: 0;
      }


      table th {
        font-weight: normal;
        background-color: #ccc;
        text-align: left;
      }
      span.component {
        background-color: #060;
        padding-left: 0.5em;
        padding-top: 0.1em;
        padding-bottom: 0.1em;
        display: block;
        float: left;
        overflow: hidden;
        width: 4em;
        color: white;
        border: 1px solid gray;
        border: 1px solid white;
        clear: both;
      }
      span.type {
        display: block;
        background-color: #006;
        padding-left: 0.5em;
        clear: both;
        padding-top: 0.1em;
        padding-bottom: 0.1em;
        float: left;
        overflow: hidden;
        width: 4em;
        color: white;
        border: 1px solid white;
      }

      .nopad {
        margin :0;
        padding:0;
      }

      td.component {
        background-color: #060;
        padding-left: 0.5em;
        padding-top: 0.1em;
        padding-bottom: 0.1em;
        overflow: hidden;
        width: 4em;
        color: white;
        border: 1px solid white;
      }
      td.type {
        background-color: #006;
        padding-left: 0.5em;
        padding-top: 0.1em;
        padding-bottom: 0.1em;
        overflow: hidden;
        width: 4em;
        color: white;
        border: 1px solid white;
      }
      span.spacer {
        float: left;
        display: block;
        overflow: hidden;
        width: 0.2em;
      }
      span.name {
        width: 100%;
        display: block;
        overflow: hidden;
        border-top: 1px solid #ccc;
      }
      span.string {
        color: #060;
      }
      span.function {
        color: #006;
      }
      span.paren {
        color: #555;
      }
      span.NULL {
        color: #555;
      }
      pre.authors {
        font-size: 100%;
        font-family: FreeSans, Verdana, sans-serif;
        position: relative;
        top: -2em;
      }
      img.BablFish {
         float: right;
         position: relative;
         top: -8px;
         border: none;
      }
      td.op_name {
          padding-top: 2.5em;
          padding-bottom: 1.0em;
          font-weight: bold;
          font-size: 120%;
      }
      td.op_description {
          padding-bottom: 1em;
      }
      td.prop_type {
          color: gray;
          font-style: italic;
      }
      td.prop_name {
          font-weight: bold;
      }
      td.prop_blurb {
          padding-bottom: 0.5em;
      }

      @media screen {
        body {
          font-family: FreeSans, Verdana, sans-serif;
          max-width: 45em;
        }
        a {
          text-decoration: none;
        }
        pre {
          overflow: auto;
        }
        h1 {
            display: none;
        }

        div#toc {
          background-color: #333;
          position: absolute;
          position: fixed;
          width: 12em;
          top: 0;
          left: 0;
          z-index: 2;
          height: 100%;
          overflow: auto;
          float: left;
          padding-top: 0.5em;
        }
        div#toc ul {
          padding-top: 0em;
          padding-left: 0em;
          margin: 0;
        }
        div#toc li {
          display: block;
          padding-right: 1em;
        }
        div#toc li a,
        div#toc div a{
          display: block;
          padding-left: 1em;
          padding-right: 1em;
          color: #fff;
        }
        div#toc li a:hover,
        div#toc div a:hover{
          color: #fff;
          background-color: #445;
        }
        div#toc li a:active,
        div#toc div a:active{
          color: #000;
          background-color: #445;
        }
        div#toc .toclevel1 {
          padding-top: 0.5em;
          padding-left: 0em;
        }
        div#toc .toclevel2 {
          padding-left: 1em;
        }
        #toctitle {
            display: none;
        }
        div.paper {
          max-width: 45em;
          -moz-border-radius: 1em;
        }
        div.content {
        }
        div.graphic {
           /*background: url("gallery/data/gegl.png");
           background-repeat: no-repeat;
           z-index: 1;*/
        }
        div.print {
          display: none;
        }
        ul.crucible {margin:0; padding:0}
        ul.crucible li{display: inline;}
      }

      @media print {
        body {
          background-color: none;
          font-family: FreeSans, Verdana, sans-serif;
        }
        a, em {
          /* XXX: work-around for rendering bug, should investigate whether
           * this issue is fixed in the latest gecko
           */
          padding-right: 3em;
          padding-left: 1em;
        }
        a {
          text-decoration: none;
        }

        div#toc ul {
          padding-left: 0em;
          float: right;
          margin: 0;
        }
        div#toc li {
          display: block;
          padding-right: 1em;
        }
        div#toc li a{
          display: block;
          padding-left: 1em;
          padding-right: 1em;
          color: #fff;
        }
        div#toc li a:hover {
          color: #fff;
          background-color: #333;
        }
        div#toc ul {
          padding-left: 0em;
          float: none;
          margin: 0;
          margin-left: 1em;
        }
        div#toc {
          position: absolute;
          width: 200px;
          top: 0;
          left: 2em;
          padding-top: 2em;
          z-index: 2;
        }
        div#toc ul {
          margin-left: 0;
        }
        div#toc li a {
          color : #000;
        }
        div#toc h2 {
          margin: 0;
          padding: 0;
        }
        h1 {
          margin-left: -0.75em;
        }
        h2 {
          padding-top: 4em;
          margin-left: -1em;
        }
        h3 {
          padding-top: 4em;
          margin-left: -1em;
        }
        span.component {
          background-color: #7f7;
          color: black;
        }
        span.type {
          background-color: #aaf;
          color: black;
        }
        table th {
          font-weight: bold;
        }
        div.print_title {
          position: absolute;
          top: 3em;
          padding-left: 2em;
          margin-left: 280px;
        }
        div.paper {
          padding-top: 4em;
        }
        div.graphic {
          display: none;
          background-color: #bbf;
          height: 100%;
        }
        div.graphic img {
          position: absolute;
          bottom: 0;
          left: 0;
        }
        div.screen {
          display: none;
        }
      }
</style>
<script type="text/javascript">
/*<![CDATA[*/
window.onload = function(){generateToc(2)}
/* Author: Mihai Bazon, September 2002
 * http://students.infoiasi.ro/~mishoo
 *
 * Table Of Content generator
 * Version: 0.4
 *
 * Feel free to use this script under the terms of the GNU General Public
 * License, as long as you do not remove or alter this notice.
 */

 /* modified by Troy D. Hanson, September 2006. License: GPL */
 /* modified by Stuart Rackham, October 2006. License: GPL */

function getText(el) {
  var text = "";
  for (var i = el.firstChild; i != null; i = i.nextSibling) {
    if (i.nodeType == 3 /* Node.TEXT_NODE */) // IE doesn't speak constants.
      text += i.data;
    else if (i.firstChild != null)
      text += getText(i);
  }
  return text;
}

function TocEntry(el, text, toclevel) {
  this.element = el;
  this.text = text;
  this.toclevel = toclevel;
}

function tocEntries(el, toclevels) {
  var result = new Array;
  var re = new RegExp('[hH]([2-'+(toclevels+1)+'])');
  // Function that scans the DOM tree for header elements (the DOM2
  // nodeIterator API would be a better technique but not supported by all
  // browsers).
  var iterate = function (el) {
    for (var i = el.firstChild; i != null; i = i.nextSibling) {
      if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
        var mo = re.exec(i.tagName)
        if (mo)
          result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
        iterate(i);
      }
    }
  }
  iterate(el);
  return result;
}

// This function does the work. toclevels = 1..4.
function generateToc(toclevels) {
  var toc = document.getElementById("toc");
  var entries = tocEntries(document.getElementsByTagName("body")[0], toclevels);
  for (var i = 0; i < entries.length; ++i) {
    var entry = entries[i];
    if (entry.element.id == "")
      entry.element.id = "toc" + i;
    var a = document.createElement("a");
    a.href = "#" + entry.element.id;
    a.appendChild(document.createTextNode(entry.text));
    var div = document.createElement("div");
    div.appendChild(a);
    div.className = "toclevel" + entry.toclevel;
    toc.appendChild(div);
  }
}
/*]]>*/
</script>
<title>GEGL-0.0.18</title>
</head>
<body>
<div id="header">
<h1>GEGL-0.0.18</h1>
<div id="toc">
  <div id="toctitle">Table of Contents</div>
  <noscript><p><b>JavaScript must be enabled in your browser to display the table of contents.</b></p></noscript>
</div>
</div>
<div id="preamble">
<div class="sectionbody">
</div>
</div>
<h2 id="gegl">GEGL</h2>
<div class="sectionbody">
<div class="para"><p>GEGL (Generic Graphics Library) is a graph based image processing framework.</p></div>
<div class="para"><p>GEGL provides infratructure to do demand based cached non destructive image
editing on larger than RAM buffers. Through <a href="http://gegl.org/babl/">babl</a>
it provides support for a wide range of color models and pixel storage formats
for input and output.</p></div>
<h3 id="features">Features</h3>
<div class="ilist"><ul>
<li>
<p>
Floating point handling and processing and output of larger 8bit, 16bit
    integer and 32bit floating point per component buffers larger than RAM.
</p>
</li>
<li>
<p>
C, <a href="http://gegl.org/gegl-vala">vala</a>, <a href="http://gegl.org/gegl-sharp/">C#</a>, http://
    <a href="http://gegl.org/pygegl/">Python</a> and <a href="http://gegl.org/rgegl/">Ruby</a> interfaces
    using a consistent DOM like graph API to manage processing graphs.
</p>
</li>
<li>
<p>
Processing
</p>
<div class="ilist"><ul>
<li>
<p>
Iterative chunk-wise processing.
</p>
</li>
<li>
<p>
Processes subregions and dependencies.
</p>
</li>
<li>
<p>
Subgraph caches to aid non destructive editing performance.
</p>
</li>
</ul></div>
</li>
<li>
<p>
<a href="api.html#GeglBuffer">GeglBuffer</a>
</p>
<div class="ilist"><ul>
<li>
<p>
Storage of all babl supported formats.
</p>
</li>
<li>
<p>
Tiled sparse buffers (larger than RAM images).
</p>
</li>
<li>
<p>
On demand tiled mipmapping.
</p>
</li>
<li>
<p>
inter process shared storage
</p>
</li>
</ul></div>
</li>
<li>
<p>
Operations
</p>
<div class="ilist"><ul>
<li>
<p>
PNG, JPEG, SVG, EXR, RAW, ffmpeg, v4l and other image sources.
</p>
</li>
<li>
<p>
<a href="operations.html#cat_render">Pattern renderers</a>
</p>
</li>
<li>
<p>
<a href="operations.html#math">Arithmetic operations</a>
</p>
</li>
<li>
<p>
link_operations.html#porter_duff[porter duff compositing]
</p>
</li>
<li>
<p>
SVG filter modes and full set of compositing ops from SVG-1.2 draft.
</p>
</li>
<li>
<p>
Gaussian blur, bilateral-filter, symmetric nearest neighbour, unsharp
        mask.
</p>
</li>
<li>
<p>
<a href="operations.html#cat_color">Color correction</a>.
</p>
</li>
<li>
<p>
Text rendering using cairo and <a href="http://pango.org/">pango</a>.
</p>
</li>
<li>
<p>
Most operations operates in
        <a href="http://en.wikipedia.org/wiki/ScRGB_color_space">scRGB</a> (using 32bit
        linear light RGBA)
</p>
</li>
</ul></div>
</li>
<li>
<p>
Bounding box based hit detection.
</p>
</li>
<li>
<p>
XML serialization format (not-finalized)
</p>
</li>
</ul></div>
<h3 id="_news">News</h3>
<div class="para"><p>This website is built at the time of the previous GEGL tarball release,
for information about what might change on the way to the next release
follow the following news sources:</p></div>
<div class="vlist"><dl>
<dt>
<a href="http://svn.gnome.org/viewvc/gegl/trunk/ChangeLog?view=markup">ChangeLog</a>
</dt>
<dd>
<p>
  For day to day fixes, contributions and changes.
</p>
</dd>
<dt>
<a href="http://svn.gnome.org/viewvc/gegl/trunk/NEWS?view=markup">NEWS</a>
</dt>
<dd>
<p>
  The NEWS file for a list of major new features (also contains older NEWS).
</p>
</dd>
<dt>
<a href="http://bugzilla.gnome.org/buglist.cgi?product=GEGL&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=UNCONFIRMED&amp;bug_status=NEEDINFO">bugzilla</a>
</dt>
<dd>
<p>
 for known and tracked issues with GEGL and perhaps see the
</p>
</dd>
<dt>
<a href="http://blog.gmane.org/gmane.comp.video.gegl.devel?set_blog_all=yes">mail</a>
</dt>
<dd>
<p>
  The mailinglist archives for some discussion and announcement.
</p>
</dd>
</dl></div>
<h3 id="_gallery">Gallery</h3>
<div class="para"><p>For examples of what GEGLs rendering engine currently can do look at the
<a href="gallery/index.html">gallery</a>.</p></div>
<h3 id="_bugzilla">Bugzilla</h3>
<div class="para"><p>The GEGL project uses <a href="http://bugzilla.gnome.org/">GNOME Bugzilla</a>, a
bug-tracking system that allows us to coordinate bug reports. Bugzilla is also
used for enhancement requests and the preferred way to submit patches for GEGL
is to open a bug report and attach the patch to it. Bugzilla is also the
closest you will find to a roadmap for GEGL.</p></div>
<div class="para"><p>Below is a list of links to get you started with Bugzilla:</p></div>
<div class="ilist"><ul>
<li>
<p>
<a href="http://bugzilla.gnome.org/buglist.cgi?product=GEGL&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED">List of Open Bugs</a>
</p>
</li>
<li>
<p>
<a href="http://bugzilla.gnome.org/buglist.cgi?product=GEGL&amp;bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_severity=blocker&amp;bug_severity=critical&amp;bug_severity=major&amp;bug_severity=normal&amp;bug_severity=minor&amp;bug_severity=trivial">List of Open Bugs</a> (excluding enhancement requests)
</p>
</li>
<li>
<p>
<a href="http://bugzilla.gnome.org/buglist.cgi?product=GEGL&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=UNCONFIRMED&amp;bug_status=NEEDINFO&amp;bug_severity=enhancement">List of Enhancement Proposals</a>
</p>
</li>
<li>
<p>
<a href="http://bugzilla.gnome.org/reports/weekly-bug-summary.cgi">Bugzilla Weekly Summary</a>
</p>
</li>
</ul></div>
<h3 id="_mailinglist">Mailinglist</h3>
<div class="para"><p>You can subscribe to gegl-developer and view the archives
<a href="https://lists.XCF.Berkeley.EDU/mailman/listinfo/gegl-developer">here</a>. The GEGL
developer list is the appopriate place to ask development questions, and get
more information about GEGL development in general. You can email this list at
<a href="mailto:gegldev%20at%20gegl.org">gegldev%20at%20gegl.org</a>.</p></div>
<h3 id="_copyright">Copyright</h3>
<div class="para"><p>GEGL is free software; you can redistribute it and/or modify it under the terms
of the <a href="LGPL">GNU Lesser General Public License</a> as published by the Free
Software Foundation; either version 3 of the License, or (at your option) any
later version.</p></div>
<h3 id="_contributors">Contributors</h3>
<div class="para"><p>Multiple people have contributed to GEGL
<a href="http://www.ohloh.net/projects/4349/analyses/latest">over time</a> the following
lists are are ordered chronologically according to when they are mentioned in
the ChangeLog.</p></div>
<h4 id="_code">Code:</h4>
<div class="para"><p>Calvin Williamson, Caroline Dahloff, Manish Singh, Jay Cox Daniel Rogers,
Sven Neumann, Michael Natterer, Øyvind Kolås, Philip Lafleur, Dominik Ernst,
Richard Kralovic, Kevin Cozens, Victor Bogado, Martin Nordholts, Geert
Jordaens, Michael Schumacher, John Marshall, Étienne Bersac, Mark Probst, Håkon
Hitland, Tor Lillqvist, Hans Breuer, Deji Akingunola and Bradley Broom,
Hans Petter Jansson, Jan Heller, dmacks@netscpace.org, Sven Anders and
Hubert Figuiere.</p></div>
<h4 id="_documentation">Documentation:</h4>
<div class="para"><p>Garry R. Osgood, Øyvind Kolås, Kevin Cozens and Shlomi Fish,</p></div>
<h4 id="_artwork">Artwork:</h4>
<div class="para"><p>Jakub Steiner</p></div>
</div>
<h2 id="_building_from_source">Building from source</h2>
<div class="sectionbody">
<div class="para"><p>GEGL and it's dependencies are known to work on Linux based systems, windows
with msys/mingw, and probably other platforms.</p></div>
<h3 id="_download">Download</h3>
<div class="para"><p>The latest development snapshot, and eventually stable versions of GEGL are
available at <a href="ftp://ftp.gimp.org/pub/gegl/">ftp://ftp.gimp.org/pub/gegl/</a>.</p></div>
<div class="para"><p>The current code under development can be
<a href="http://svn.gnome.org/viewvc/gegl/trunk/">browsed online</a> and checked out from
GNOME Subversion using:</p></div>
<div class="literalblock">
<div class="content">
<pre><tt>$ svn co http://svn.gnome.org/svn/babl/trunk/ babl
$ svn co http://svn.gnome.org/svn/gegl/trunk/ gegl</tt></pre>
</div></div>
<h3 id="_dependencies">Dependencies</h3>
<div class="para"><p>GEGL currently builds and works on linux, win32 and OSX most probably also on
other systems where glib and gtk+ work.</p></div>
<div class="ilist"><ul>
<li>
<p>
Core
</p>
<div class="ilist"><ul>
<li>
<p>
glib (including gobject, and gmodule) 2.12 or newer, which provides
        inheritance, dynamic modules, common algorithms and data structures for
        C programming.
</p>
</li>
<li>
<p>
<a href="http://gegl.org/babl/">babl</a> 0.0.22 or newer (for pixel-format
        agnostisism).
</p>
</li>
<li>
<p>
libpng (png load/export ops, and image magick fallback import)
</p>
</li>
<li>
<p>
ruby (only if building from svn)
</p>
</li>
</ul></div>
</li>
<li>
<p>
GUI (sandbox for testing ops and the API)
</p>
<div class="ilist"><ul>
<li>
<p>
GTK+
</p>
</li>
</ul></div>
</li>
<li>
<p>
Optional dependencies for operations.
</p>
<div class="ilist"><ul>
<li>
<p>
SDL (display op)
</p>
</li>
<li>
<p>
libjpeg (jpg loader op)
</p>
</li>
<li>
<p>
libopenexr (exr loader op)
</p>
</li>
<li>
<p>
cairo, pango (text source op)
</p>
</li>
<li>
<p>
avcodec, avformat (ff-load and experimental ff-save)
</p>
</li>
<li>
<p>
librsvg (svg loader)
</p>
</li>
</ul></div>
</li>
<li>
<p>
Documentation (this document)
</p>
<div class="ilist"><ul>
<li>
<p>
asciidoc
</p>
</li>
</ul></div>
</li>
</ul></div>
<h3 id="_compiling">Compiling</h3>
<div class="para"><p>To build GEGL type the following in the toplevel source directory:</p></div>
<div class="literalblock">
<div class="content">
<pre><tt>$ ./configure  # or: ./autogen.sh if building from svn
$ make
$ sudo make install</tt></pre>
</div></div>
</div>
<h2 id="_documentation_2">Documentation</h2>
<div class="sectionbody">
<div class="para"><p>With GEGL you chain together image processing operations represented by nodes
into a graph. GEGL provides such operations for loading and storing images,
adjusting colors, filtering images in different ways, translating images and</p></div>
<div class="para"><p>GEGLs programmer/user interface is a Directed Acyclic Graph of nodes. The DAG
expresses a processing chain of operations. A DAG, or any node in it, expresses
a composited and processed image. It is possible to request rectangular regions
in a wide range of pixel formats from any node.</p></div>
<h3 id="_public_api">Public API</h3>
<div class="para"><p>The <a href="api.html">public API reference</a> documents the API used for creating
things with GEGL, this API does not change much at all and is also the API
provided by language bindings. To make the public API available when compiling
a .c file add #include &lt;<a href="gegl.h.html">gegl.h</a>&gt;, compile and link with the
flags provided by pkg-config and you should be all set. When you are
comfortable with the public API, or are using GEGL in some project looking at
the <a href="operations.html">Operation reference</a> might be useful.</p></div>
<div class="para"><p>The public API also includes <a href="api.html#GeglBuffer">GeglBuffer</a>, a flexible
tiled and linear raster buffer storage system.</p></div>
<h4 id="_bindings">Bindings</h4>
<div class="para"><p>The bindings for use of GEGL in other programming languages than C are
co-hosted with GEGL in GNOME subversion but are not part of the regular GEGL
distribution. The following language bindings are currently available:</p></div>
<div class="para"><p><a href="http://gegl.org/gegl-vala">vala</a>, <a href="http://gegl.org/gegl-sharp/">C#</a>, http://
<a href="http://gegl.org/pygegl/">Python</a> and <a href="http://gegl.org/rgegl/">Ruby</a>.</p></div>
<h4 id="_hello_world">Hello world</h4>
<div class="para"><p>The follwing is a small sample GEGL application that animates a zoom on a
mandelbrot fractal compile it with:</p></div>
<div class="literalblock">
<div class="content">
<pre><tt>$ gcc hello-world.c `pkg-config --libs --cflags gegl` -o hello-world</tt></pre>
</div></div>
<div class="para"><p>This example and others can be found in the examples subdir of the GEGL distribution.</p></div>
<div class="listingblock">
<div class="content">
<pre><tt>#include &lt;gegl.h&gt;

gint
main (gint    argc,
      gchar **argv)
{
  gegl_init (&amp;argc, &amp;argv);  /* initialize the GEGL library */

  {
    /* instantiate a graph */
    GeglNode *gegl = gegl_node_new ();

/*
This is the graph we're going to construct:

.-----------.
| display   |
`-----------'
   |
.-------.
| layer |
`-------'
   |   \
   |    \
   |     \
   |      |
   |   .------.
   |   | text |
   |   `------'
.------------------.
| fractal-explorer |
`------------------'

*/

    /*&lt; The image nodes representing operations we want to perform */
    GeglNode *display    = gegl_node_create_child (gegl, "display");
    GeglNode *layer      = gegl_node_new_child (gegl,
                                 "operation", "layer",
                                 "x", 2.0,
                                 "y", 4.0,
                                 NULL);
    GeglNode *text       = gegl_node_new_child (gegl,
                                 "operation", "text",
                                 "size", 10.0,
                                 "color", gegl_color_new ("rgb(1.0,1.0,1.0)"),
                                 NULL);
    GeglNode *mandelbrot = gegl_node_new_child (gegl,
                                "operation", "fractal-explorer",
                                "width", 512,
                                "height", 384,
                                NULL);

    gegl_node_link_many (mandelbrot, layer, display, NULL);
    gegl_node_connect_to (text, "output",  layer, "aux");

    /* request that the save node is processed, all dependencies will
     * be processed as well
     */
    {
      gint frame;
      gint frames = 200;

      for (frame=0; frame&lt;frames; frame++)
        {
          gchar string[512];
          gdouble t = frame * 1.0/frames;
          gdouble cx = -1.76;
          gdouble cy = 0.0;

#define INTERPOLATE(min,max) ((max)*(t)+(min)*(1.0-t))

          gdouble xmin = INTERPOLATE(  cx-0.02, cx-2.5);
          gdouble ymin = INTERPOLATE(  cy-0.02, cy-2.5);
          gdouble xmax = INTERPOLATE(  cx+0.02, cx+2.5);
          gdouble ymax = INTERPOLATE(  cy+0.02, cy+2.5);

          if (xmin&lt;-3.0)
            xmin=-3.0;
          if (ymin&lt;-3.0)
            ymin=-3.0;

          gegl_node_set (mandelbrot, "xmin", xmin,
                                     "ymin", ymin,
                                     "xmax", xmax,
                                     "ymax", ymax,
                                     NULL);
          g_sprintf (string, "%1.3f,%1.3f %1.3f×%1.3f",
            xmin, ymin, xmax-xmin, ymax-ymin);
          gegl_node_set (text, "string", string, NULL);
          gegl_node_process (display);
        }
    }

    /* free resources used by the graph and the nodes it owns */
    g_object_unref (gegl);
  }

  /* free resources globally used by GEGL */
  gegl_exit ();

  return 0;
}</tt></pre>
</div></div>
<h3 id="_operation_api">Operation API</h3>
<div class="para"><p>An API to extend the functionality of GEGL with new image processing primitive,
file loaders, export formats or similar.</p></div>
<div class="para"><p>Each GEGL operation is defined in a .c file that gets turned into a single
shared object that is loaded. Each operation is a subclass of one of the
provided base classes:</p></div>
<div class="vlist"><dl>
<dt>
<a href="gegl-operation.h.html">GeglOperation</a>
</dt>
<dd>
<p>
    The base operation class, which all the other base classes are derived
    from, deriving from this is often quite a bit of work and is encouraged
    only when your operation doesn't fit into any of the other categories
</p>
</dd>
<dt>
<a href="gegl-operation-filter.h.html">GeglOperationFilter</a>
</dt>
<dd>
<p>
    The filter base class sets up GeglBuffers for input and output pads
</p>
</dd>
<dt>
<a href="gegl-operation-point-filter.h.html">GeglOperationPointFilter</a>
</dt>
<dd>
<p>
    The point-filter base class is for filters where an output pixel only
    depends on the color and alpha values of the corresponding input pixel.
    This allows you to do the processing on linear buffers, in the future
    versions of GEGL operations implemented using the point-filter will get
    speed increases due to more intelligent processing possible in the point
    filter class
</p>
</dd>
<dt>
<a href="gegl-operation-area-filter.h.html">GeglOperationAreaFilter</a>
</dt>
<dd>
<p>
    The AreaFilter base class allows defining operations where the output data
    depends on a neighbourhood with an input window that extends beyond the
    output window, the information about needed extra pixels in different
    directions should be set up in the prepare callback for the operation.
</p>
</dd>
<dt>
<a href="gegl-operation-composer.h.html">GeglOperationComposer</a>
</dt>
<dd>
<p>
    Composer operations are operations that take two inputs named <em>input</em> and
    <em>aux</em> and writes their output to the output pad <em>output</em>
</p>
</dd>
<dt>
<a href="gegl-operation-point-composer.h.html">GeglOperationPointComposer</a>
</dt>
<dd>
<p>
    A baseclass for composer functions where the output pixels values depends
    only on the values of the single corresponding input and aux pixels.
</p>
</dd>
<dt>
<a href="gegl-operation-source.h.html">GeglOperationSource</a>
</dt>
<dd>
<p>
    Operations used as render sources or file loaders, the process method
    receives a GeglBuffer to write it's output into
</p>
</dd>
<dt>
<a href="gegl-operation-sink.h.html">GeglOperationSink</a>
</dt>
<dd>
<p>
    An operation that consumes a GeglBuffer, used for filewriters, display (for
    the sdl display node)
</p>
</dd>
<dt>
<a href="gegl-operation-temporal.h.html">GeglOperationTemporal</a>
</dt>
<dd>
<p>
    Base class for operations that want access to previous frames in a video
    sequence, it contains API to configure the amounts of frames to store as
    well as getting a GeglBuffer pointing to any of the previously stored
    frames.
</p>
</dd>
<dt>
<a href="gegl-operation-meta.h.html">GeglOperationMeta</a>
</dt>
<dd>
<p>
    Used for GEGL operations that are implemented as a sub-graph, at the moment
    these are defined as C files but should in the future be possible to
    declare as XML instead.
</p>
</dd>
</dl></div>
<div class="para"><p>To create your own operations you should start by looking for one that does
approximatly what you already need. Copy it to a new .c source file, and
replace the occurences of the filename (operation name in the source.)</p></div>
<div class="para"><p>Take a look at <a href="brightness-contrast.c.html">the brightness contrast
operation</a> for a point operation well sprinkled with comments as a starting point.</p></div>
<h3 id="_environment">Environment</h3>
<div class="para"><p>Some environment variables can be set to alter how GEGL runs, all of these
options are also available as properties on a singleton GObject returned from
gegl_config ().</p></div>
<div class="vlist"><dl>
<dt>
GEGL_QUALITY
</dt>
<dd>
<p>
    A value between 0.0 and 1.0 indicating a trade-off between quality and
    speed. Defaults to 1.0 (max quality).
</p>
</dd>
<dt>
BABL_TOLERANCE
</dt>
<dd>
<p>
    The amount of error that babl tolerates, set it to for instance 0.1 to use
    some conversions that trade some quality for speed.
</p>
</dd>
<dt>
GEGL_CHUNK_SIZE
</dt>
<dd>
<p>
    The number of pixels processed simulatnously.
</p>
</dd>
<dt>
GEGL_TILE_SIZE
</dt>
<dd>
<p>
    The tile size used internally by GEGL, defaults to 128x64
</p>
</dd>
<dt>
GEGL_SWAP
</dt>
<dd>
<p>
    The directory where temporary swap files are written, if not specified GEGL
    will not swap to disk. Be aware that swapping to disk is still experimental
    and GEGL is currently not removing the per process swap files.
</p>
</dd>
<dt>
GEGL_CACHE_SIZE
</dt>
<dd>
<p>
    The size of the tile cache used by GeglBuffer specified in megabytes.
</p>
</dd>
<dt>
GEGL_DEBUG
</dt>
<dd>
<p>
    set it to "all" to enable all debugging, more specific domains for
    debugging information are also available.
</p>
</dd>
<dt>
BABL_STATS
</dt>
<dd>
<p>
    When set babl will write a html file (/tmp/babl-stats.html) containing a
    matrix of used conversions, as well as all existing conversions and which
    optimized paths are followed.
</p>
</dd>
<dt>
GEGL_DEBUG_BUFS
</dt>
<dd>
<p>
    Display tile/buffer leakage statistics.
</p>
</dd>
<dt>
GEGL_DEBUG_RECTS
</dt>
<dd>
<p>
    Show the results of have/need rect negotiations.
</p>
</dd>
<dt>
GEGL_DEBUG_TIME
</dt>
<dd>
<p>
    Print a performance instrumentation breakdown of GEGL and it's operations.
</p>
</dd>
</dl></div>
<h3 id="_gegl">gegl</h3>
<div class="para"><p>GEGL provides a commandline tool called gegl, for working with the XML data
model from file, stdin or the commandline. It can display the result of
processing the layer tree or save it to file.</p></div>
<div class="para"><p>Some examples:</p></div>
<div class="para"><p>Render a composition to a PNG file:</p></div>
<div class="literalblock">
<div class="content">
<pre><tt>$ gegl composition.xml -o composition.png</tt></pre>
</div></div>
<div class="para"><p>Invoke gegl like a viewer for gegl compositions:</p></div>
<div class="literalblock">
<div class="content">
<pre><tt>$ gegl -ui -d 5 composition.xml</tt></pre>
</div></div>
<div class="para"><p>Using gegl with png's passing through stdin/stdout piping.</p></div>
<div class="literalblock">
<div class="content">
<pre><tt>$ cat input.png | gegl -o - -x "&lt;gegl&gt;
   &lt;tree&gt;
     &lt;node class='invert'/&gt;
     &lt;node class='scale' x='0.5' y='0.5'/&gt;
     &lt;node class='png-load' path='-'/&gt;&lt;/tree&gt;&lt;/gegl&gt;" &gt; output.png</tt></pre>
</div></div>
<div class="para"><p>The latest development version is available in the gegl module in GNOME
Subversion.</p></div>
<h4 id="_gegl_usage">gegl usage</h4>
<div class="para"><p>The following is the usage information of the gegl binary, this documentation
might not be complete.</p></div>
<div class="listingblock">
<div class="content">
<pre><tt>usage: /home/pippin/src/clean/gegl/bin/.libs/lt-gegl [options] &lt;file | -- [op [op] ..]&gt;

  Options:
     --help      this help information
     -h

     --file      read xml from named file
     -i

     --xml       use xml provided in next argument
     -x

     --dot       output a graphviz graph description
     --output    output generated image to named file
     -o          (file is saved in PNG format)

     -p          (increment frame counters of various elements when
                  processing is done.)

     -X          output the XML that was read in

     --verbose   print diagnostics while running
      -v

All parameters following -- are considered ops to be chained together
into a small composition instead of using an xml file, this allows for
easy testing of filters. Be aware that the default value will be used
for all properties.</tt></pre>
</div></div>
</div>
<h2 id="_appendixes">Appendixes</h2>
<div class="sectionbody">
<h3 id="_operations">Operations</h3>
<div class="para"><p>The main source of documentation as GEGL grows is the
<a href="operations.html">operations reference</a>. Plug-ins themselves register
information about the categories they belong to, what they do, and
documentation of the available parameters.</p></div>
<h3 id="_glossary">Glossary</h3>
<div class="vlist"><dl>
<dt>
connection
</dt>
<dd>
<p>
    A link/pipe routing image flow between operations within the graph goes
    from an output pad to an input pad, in graph glossary this might also be
    reffered to as an edge.
</p>
</dd>
<dt>
DAG
</dt>
<dd>
<p>
    Directed Acyclic Graph, see graph.
</p>
</dd>
<dt>
graph
</dt>
<dd>
<p>
    A composition of nodes, the graph is a DAG.
</p>
</dd>
<dt>
node
</dt>
<dd>
<p>
    The nodes are connected in the graph. A node has an associated operation or
    can be constructed graph.
</p>
</dd>
<dt>
operation
</dt>
<dd>
<p>
    The processing primitive of GEGL, is where the actual image processing
    takes place. Operations are plug-ins and provide the actual functionality
    of GEGL
</p>
</dd>
<dt>
pad
</dt>
<dd>
<p>
    The part of a node that exchanges image content. The place where image
    "pipes" are used to connect the various operations in the composition.
</p>
</dd>
<dt>
input pad
</dt>
<dd>
<p>
  consumes image data, might also be seen as an image parameter to the
  operation.
</p>
</dd>
<dt>
output pad
</dt>
<dd>
<p>
  a place where data can be requested, multiple input pads can reference
  the same output pad.
</p>
</dd>
<dt>
property
</dt>
<dd>
<p>
    Properties are what control the behavior of operations, through the use of
    GParamSpecs properties are self documenting through introspection.
</p>
</dd>
</dl></div>
<h3 id="_directory_overview">Directory overview</h3>
<h4 id="_gegl_dirs">GEGL dirs</h4>
<div class="para"><p>Directories marked with ⊙ use GNU make extensions to include any .c file
dropped into the directory in the build.</p></div>
<div class="literalblock">
<div class="content">
<pre><tt>gegl-dist-root
 │
 │
 ├──gegl               core source of GEGL, library init/deinit,
 │   │
 │   ├──buffer         contains the implementation of GeglBuffer
 │   │                  - sparse (tiled)
 │   │                  - recursivly subbuffer extendable
 │   │                  - clipping rectangle (defaults to bounds when making
 │   │                    subbuffers)
 │   │                  - storage in any babl supported pixel format
 │   │                  - read/write rectangular region as linear buffer for
 │   │                    any babl supported pixel format.
 │   ├──graph          graph storage and manipulation code.
 │   ├──module         The code to load plug-ins located in a colon seperated
 │   │                 list of paths from the environment variable GEGL_PATH
 │   ├──operation      The GeglOperation base class, and subclasses that act
 │   │                 as baseclasses for implementeting different types of
 │   │                 operation plug-ins.
 │   ├──process        The code controlling data processing.
 │   └──property-types specialized classes/paramspecs for GeglOperation
 │                     properties.
 │
 ├──examples ⊙        hello-world and other example uses of the GEGL API.
 │
 ├──tests             various tests used to maintain stability when developing
 │                    GEGL.
 │
 ├──operations        Runtime loaded plug-ins for image processing operations.
 │   │
 │   ├──core ⊙        Basic operations tightly coupled with GEGL.
 │   ├──affine        Transforming operations (rotate/scale/translate)
 │   ├──generated ⊙   Operations generated from scripts (currently
 │   ├──external      Operations with external dependencies.
 │   ├──common ⊙      Other operations.
 │   └──workshop ⊙    Works in progress, (you must pass --enable-workshop
 │       │            when configurig to build these by default, you can enter
 │       │            the directory manually and type make &amp;&amp; sudo make install
 │       │            as well.
 │       │
 │       ├──external  operations in the workshop with external dependencies.
 │       └──generated generated operations that are in the workshop.
 │
 │
 ├──docs              The GEGL website (this documentation), built for your
 │   │                the corresponding sourcetree with correct documentation
 │   │                etc.
 │   │
 │   └──gallery ⊙     A gallery of sample GEGL compositions, using the
 │       │            (not yet stabilized) XML format.
 │       │
 │       └──data      Image data used by the sample compositions.
 │
 ├──bin               gegl binary, for processing XML compositions to png files.
 │
 ├──bindings          bindings for using GEGL from other programming languages
 │                    not included in the tarball distribution but exist in
 │                    the subversion repository.
 │
 └──tools             some small utilities to help the build.</tt></pre>
</div></div>
<div id='toc'>
<div id="toctitle">Table of Contents</div>
<div class="toclevel1"><a href="#gegl">GEGL</a></div>
<div class="toclevel2"><a href="#features">Features</a></div>
<div class="toclevel2"><a href="#_news">News</a></div>
<div class="toclevel2"><a href="gallery/index.html">Gallery</a></div>
<!--<div class="toclevel2"><a href="http://bugzilla.gnome.org/buglist.cgi?product=GEGL&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED">Bugzilla</a></div>
<div class="toclevel2"><a href="#_mailinglist">Mailinglist</a></div>-->
<div class="toclevel2"><a href="#_copyright">Copyright</a></div>
<div class="toclevel2"><a href="#_code">Contributors</a></div>
<div class="toclevel1"><a href="#_building_from_source">Building from source</a></div>
<div class="toclevel2"><a href="#_download">Download</a></div>
<div class="toclevel2"><a href="#_dependencies">Dependencies</a></div>
<div class="toclevel2"><a href="#_compiling">Compiling</a></div>
<div class="toclevel1"><a href="#_documentation_2">Documentation</a></div>
<div class="toclevel2"><a href="operations.html">Operations</a></div>
<div class="toclevel2"><a href="api.html">Public API</a></div>
<div class="toclevel2"><a href="#_operation_api">Operation API</a></div>
<div class="toclevel2"><a href="#_environment">Environment</a></div>
<div class="toclevel2"><a href="#_gegl">gegl</a></div>
<div class="toclevel1"><a href="#_appendixes">Appendixes</a></div>
<div class="toclevel2"><a href="operations.html">Operations</a></div>
<div class="toclevel2"><a href="#_glossary">Glossary</a></div>
<div class="toclevel2"><a href="#_directory_overview">Directory overview</a></div>

<div>&nbsp;</div>
<div class="toclevel1">&nbsp;</div>
<div class="toclevel2"><a href="http://svn.gnome.org/viewvc/gegl/trunk/ChangeLog?view=markup">changes</a></div>
<div class="toclevel2"><a href="http://bugzilla.gnome.org/buglist.cgi?product=GEGL&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_status=UNCONFIRMED&bug_status=NEEDINFO">bugzilla</a></div>
<div class="toclevel2"><a href="http://blog.gmane.org/gmane.comp.video.gegl.devel?set_blog_all=yes">mailarchive</a></div>
<div class="toclevel2"><a href="http://svn.gnome.org/viewvc/gegl/trunk/">viewvc</a></div>


</div>
</div>
<div id="footer">
<div id="footer-text">
Last updated 2008-06-14 18:45:09 BST
</div>
</div>
</body>
</html>