Call this function before using any other GEGL functions. It will initialize everything needed to operate GEGL and parses some standard command line options. argc and argv are adjusted accordingly so your own code will never see those standard arguments. gegl_init() will call g_thread_init(), unless you, or some other code already has initialized gthread.

Note that there is an alternative way to initialize GEGL: if you are calling g_option_context_parse() with the option group returned by gegl_get_option_group(), you don't have to call gegl_init() but you have to call g_thread_init() before any glib or glib dependant code yourself.

Arguments:

Call this function when you're done using GEGL. It will clean up caches and write/dump debug information if the correct debug flags are set.

Arguments:

Arguments:

Create a new graph that can contain further processing nodes.

Creates a new processing node that performs the specified operation with a NULL terminated list of key/value pairs for initial parameter values configuring the operation. Usually the first pair should be "operation" and the type of operation to be associated. If no operation is provided the node doesn't have an initial operation and can be used to construct a subgraph with special middle-man routing nodes created with gegl_node_get_output_proxy and gegl_node_get_input_proxy.

Arguments:

Makes a connection between the pads of two nodes.

Arguments:

Makes a connection between the pads of two nodes.

Arguments:

Synthetic sugar for linking the "output" pad of source to the "input" pad of sink.

Arguments:

Synthetic sugar for linking a chain of nodes with "input"->"output". The list is NULL terminated.

Arguments:

Disconnects node connected to input_pad of node (if any).

Arguments:

Set properties on a node, possible properties to be set are the properties of the currently set operations as well as "name" and "operation". "operation" changes the current operations set for the node, "name" doesn't have any role internally in GEGL.

Arguments:

valist version of gegl_node_set

Arguments:

Gets properties of a GeglNode.

Arguments:

valist version of gegl_node_get

Arguments:

Render a rectangular region from a node.

Arguments:

Render a composition. This can be used for instance on a node with a "png-save" operation to render all neccesary data, and make it be written to file. This function wraps the usage of a GeglProcessor in a single blocking function call. If you need a non-blocking operation, then make a direct use of gegl_processor_work. See GeglProcessor.

Arguments:

Adds child to the responsibilities of node, this makes the parent node take a reference on the child that is kept as long as the parent itself is being referenced. The node is stolen from an existing parent if there is one, or a presumed existing reference is used. If parent is NULL the child will be orphaned and the developer is given a reference to be responsible of.

Arguments:

Make the GeglNode graph, take a reference on child. This reference will be dropped when the reference count on the graph reaches zero.

Arguments:

Removes a child from a GeglNode. The reference previously held will be dropped so increase the reference count before removing when reparenting a child between two graphs.

Arguments:

Arguments:

Performs hit detection by returning the node providing data at a given coordinate pair. Currently operates only on bounding boxes and not pixel data.

Arguments:

Arguments:

Arguments:

Arguments:

Retrieve which pads on which nodes are connected to a named output_pad, and the number of connections. Both the location for the generated nodes array and pads array can be left as NULL. If they are non NULL both should be freed with g_free. The arrays are NULL terminated.

Arguments:

Proxies are used to route between nodes of a subgraph contained within a node.

Arguments:

Arguments:

Proxies are used to route between nodes of a subgraph contained within a node.

Arguments:

Arguments:

Creates a new processing node that performs the specified operation. All properties of the operation will have their default values. This is included as an addiiton to gegl_node_new_child in the public API to have a non varargs entry point for bindings as well as sometimes simpler more readable code.

Arguments:

This is mainly included for language bindings. Using gegl_node_get is more convenient when programming in C.

Arguments:

This is mainly included for language bindings. Using gegl_node_set is more convenient when programming in C.

Arguments:

The GeglNode returned contains the graph described by the tree of stacks in the XML document. The tree is connected to the "output" pad of the returned node and thus can be used directly for processing.

Arguments:

The GeglNode returned contains the graph described by the tree of stacks in the XML document. The tree is connected to the "output" pad of the returned node and thus can be used directly for processing.

Arguments:

Arguments:

Arguments:

Change the rectangle a GeglProcessor is working on.

Arguments:

Do an iteration of work for the processor.

Arguments:

Frees up resources used by a processing handle.

Arguments:

Construct a GEGL node, connecting it to needed input nodes. The returned node does not have a parent but a single reference it is meant to be passed to gegl_graph () for gegl_graph () to assume its ownership. This is syntactic sugar for use from C, similar conveniences can easily be built externally in other languages.

gegl_node(op_type, [key, value, [...]], NULL, [input, [aux]])

Arguments:

Creates a GeglNode containing a free floating graph constructed using gegl_node(). The GeglGraph adopts all the passed in nodes making it sufficient to unref the resulting graph.

gegl_graph (gegl_node ("gegl:over", NULL, gegl_node (..), gegl_node (..)));

Arguments:

This function fetches the version of the GEGL library being used by the running process.

Arguments:

Create a new GeglBuffer of a given format with a given extent. It is possible to pass in NULL for both extent and format, a NULL extent creates an empty buffer and a NULL format makes the buffer default to "RGBA float".

Arguments:

Open an existing on-disk GeglBuffer, this buffer is opened in a monitored state so multiple instances of gegl can share the same buffer. Sets on one buffer are reflected in the other.

Arguments:

Write a GeglBuffer to a file.

Arguments:

Loads an existing GeglBuffer from disk, if it has previously been saved with gegl_buffer_save it should be possible to open through any GIO transport, buffers that have been used as swap needs random access to be opened.

Arguments:

Flushes all unsaved data to disk, this is not neccesary for shared geglbuffers opened with gegl_buffer_open since they auto-sync on writes.

Arguments:

Create a new sub GeglBuffer, that is a view on a larger buffer.

Arguments:

Destroys a buffer and frees up the resources used by a buffer, internally this is done with reference counting and gobject, and gegl_buffer_destroy is a thin wrapper around g_object_unref.

Arguments:

Arguments:

Changes the size and position that is considered active in a buffer, this operation is valid on any buffer, reads on subbuffers outside the master buffer's extent are at the moment undefined.

Arguments:

Evaluates to the X coordinate of the upper left corner of the buffer's extent.

Arguments:

Evaluates to the Y coordinate of the upper left corner of the buffer's extent.

Arguments:

Evaluates to the width of the buffer's extent.

Arguments:

Evaluates to the height of the buffer's extent.

Arguments:

Arguments:

Fetch a rectangular linear buffer of pixel data from the GeglBuffer, the data is converted to the desired BablFormat, if the BablFormat stored and fetched is the same this amounts to a series of memcpy's aligned to demux the tile structure into a linear buffer.

Arguments:

Store a linear raster buffer into the GeglBuffer.

Arguments:

Get the native babl format of the buffer.

Arguments:

Clears the provided rectangular region by setting all the associated memory to 0

Arguments:

copies a region from source buffer to destination buffer.

If the babl_formats of the buffers are the same, and the tile boundaries align, this should optimally lead to shared tiles that are copy on write, this functionality is not implemented yet.

Arguments:

duplicate a buffer (internally uses gegl_buffer_copy), this should ideally lead to a buffer that shares the raster data with the original on a tile by tile COW basis. This is not yet implemented

Arguments:

Query interpolate pixel values at a given coordinate using a specified form of interpolation. The samplers used cache for a small neighbourhood of the buffer for more efficient access.

Arguments:

Clean up resources used by sampling framework of buffer (will be freed automatically later when the buffer is destroyed, for long lived buffers cleaning up the sampling infrastructure when it has been used for its purpose will sometimes be more efficient).

Arguments:

Looks up the GeglInterpolation corresponding to a string, if no matching interpolation is found returns GEGL_INTERPOLATION_NEAREST.

Arguments:

Creates a GeglBuffer backed by a linear memory buffer, of the given extent in the specified format. babl_format ("R'G'B'A u8") for instance to make a normal 8bit buffer.

Arguments:

Creates a GeglBuffer backed by a linear memory buffer that already exists, of the given extent in the specified format. babl_format ("R'G'B'A u8") for instance to make a normal 8bit buffer.

Arguments:

Raw direct random access to the full data of a buffer in linear memory.

Arguments:

This function makes sure GeglBuffer and underlying code is aware of changes being made to the linear buffer. If the request was not a compatible one it is written back to the buffer. Multiple concurrent users can be handed the same buffer (both raw access and converted).

Arguments:

Return the abyss extent of a buffer, this expands out to the parents extent in subbuffers.

Arguments:

Sets the x, y, width and height on rectangle.

Arguments:

Check if two GeglRectangles are equal.

Arguments:

Check if a rectangle is equal to a set of parameters.

Arguments:

Copies the rectangle information stored in source over the information in destination.

Arguments:

Computes the bounding box of the rectangles source1 and source2 and stores the resulting bounding box in destination.

Arguments:

Calculates the intersection of two rectangles. It is allows for dest to be the same as either src1 or src2. If the rectangles do not intersect, dest's width and height are set to 0 and its x and y values are undefined.

Arguments:

Checks if the GeglRectangle child is fully contained within parent.

Arguments:

Arguments:

For debugging purposes, not stable API.

Arguments:

Allocates n_bytes of memory. If n_bytes is 0 it returns NULL.

Arguments:

Frees the memory pointed to by mem, if mem is NULL it will warn and abort.

Arguments:

Creates a new GeglColor.

Arguments:

Retrieves the current set color as linear light non premultipled RGBA data, any of the return pointers can be omitted.

Arguments:

Retrieves the current set color as linear light non premultipled RGBA data, and stores it at the memory location in buf

Arguments:

Retrieves the current set color as linear light non premultipled RGBA data

Arguments:

Set the provided matrix to the identity matrix.

Arguments:

Check if two matrices are equal.

Arguments:

Check if a matrix is the identity matrix.

Arguments:

Check if a matrix only does scaling.

Arguments:

Check if a matrix only does translation.

Arguments:

Copies the matrix in src into dst.

Arguments:

Arguments:

Inverts matrix.

Arguments:

Multiples product = left · right

Arguments:

Arguments:

Arguments:

Parse a transofmation matrix from a string.

Arguments:

Serialize a GeglMatrix to a string.

Arguments:

A GeglPathItem contains the type of instruction to perform as well as it's arguments. In the public API the PathItem always has 4 points internally only the needed amount of memory is stored for a GeglPathItem.

typedef struct Point
 {
   gfloat x;
   gfloat y;
 } Point;

typedef struct GeglPathItem
 {
   gchar  type;
   Point  point[4]; 
 } GeglPathItem;

Creates a new GeglPath with no nodes.

Creates a new GeglPath with the nodes described in the string instructions. See gegl_path_parse_string() for details of the format of the string.

Arguments:

Check if the path contains any nodes.

Arguments:

Retrieves the number of nodes in the path.

Return value: the number of nodes in the path.

Arguments:

Arguments:

Retrieve the node of the path at positiong pos.

Arguments:

Serialize the paths nodes to a string.

Return value: return a string with instructions describing the string you need to free this with g_free().

Arguments:

Set the matrix of the path, the path is thransformed through this matrix when being evaluated. Causing the calcuated positions and length to be changed by the transform.

Arguments:

Retrieve the node of the path at positiong pos.

Return value: pointer to the node of the path at position pos or NULL if no such node.

Arguments:

Figure out what and where on a path is closest to arbitrary coordinates.

Arguments:

Compute the coordinates of the path at the position (length measured from start of path, not including discontinuities).

Arguments:

Copmute num_samples for a path into the provided arrays xs and ys the returned values include the start and end positions of the path.

Arguments:

Compute the bounding box of a path.

Arguments:

Execute a provided function for every node in the path (useful for drawing and otherwise traversing a path.)

Arguments:

Execute a provided function for the segments of a poly line approximating the path.

Arguments:

Remove all nods from a path.

Arguments:

Insert the new node node at position pos in path.

Arguments:

Replaces the exiting node at position pos in path.

Arguments:

Removes the node number pos in path.

Arguments:

Parses instructions and appends corresponding nodes to path (call gegl_path_clean() first if you want to replace the existing path.

Arguments:

Use as follows: gegl_path_append (path, 'M', 0.0, 0.0); and gegl_path_append (path, 'C', 10.0, 10.0, 50.0, 10.0, 60.0, 0.0) the number of arguments are determined from the instruction provided.

Arguments:

Make the GeglPath stop firing signals as it changes must be paired with a gegl_path_thaw() for the signals to start again.

Arguments:

Restart firing signals (unless the path has been frozen multiple times).

Arguments:

Adds a new type to the path system, FIXME this should probably return something on registration conflicts, for now it expects all registered paths to be aware of each other.

Arguments:

Create a GeglCurve that can store a curve with values between y_min and y_max.

Arguments:

Get the bounds on the values of the curve and store the values in the return locaitons provided in min_y and max_y.

Arguments:

Add a point to the curve at x y (replacing the value exactly for x if it already exists.

Arguments:

Retrive the coordinates for an index.

Arguments:

Replace an existing point in a curve.

Arguments:

Retrieve the number of points in the curve.

Arguments:

Retrieve the number of points in the curve.

Arguments:

Compute a set (lookup table) of coordinates.

Arguments: