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.

Return value: (transfer container): An alphabetically sorted array of available operation names. The list should be freed with g_free after use.

Arguments:

Return value: (transfer container): An allocated array of GParamSpecs describing the properties of the operation available when a node has operation_type set.

Arguments:

Create a new graph that can contain further processing nodes.

Return value: (transfer full): A new top level GeglNode (which can be used as a graph). When you are done using this graph instance it should be unreferenced with g_object_unref. This will also free any sub nodes created from this node.

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.

Return value: (transfer none): A newly created GeglNode. The node will be destroyed by the parent. Calling g_object_unref on a node will cause the node to be dropped by the parent. (You may also add additional references using g_object_ref/g_object_unref, but in general relying on the parents reference counting is easiest.)

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:

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

Return value: (transfer none): the child.

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.

Return value: (transfer none): the child.

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.

Return value: (transfer none): the GeglNode providing the data ending up at x,y in the output of node.

Arguments:

Arguments:

Arguments:

Return value: (element-type Gegl.Node) (transfer container): a list of the nodes contained within a GeglNode that is a subgraph. Use g_list_free () on the list when done.

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:

Return value: (transfer none): the node providing data or NULL if no node is connected to the input_pad.

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.

Return value: (transfer none):a newly created node. The node will be destroyed by the parent. Calling g_object_unref on a node will cause the node to be dropped by the parent. (You may also add additional references using g_object_ref/g_object_unref, but in general relying on the parents reference counting is easiest.)

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.

Return value: (transfer full): a GeglNode containing the parsed XML as a subgraph.

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.

Return value: (transfer full): a GeglNode containing the parsed XML as a subgraph.

Arguments:

Arguments:

Return value: (transfer full): a new GeglProcessor.

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]])

Return value: (transfer full): a new Gegl node.

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 (..)));

Return value: (transfer full):a GeglNode graph.

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:

Create a new GeglBuffer from a backend, if NULL is passed in the extent of the buffer will be inherited from the extent of the backend.

returns a GeglBuffer, that holds a reference to the provided backend.

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 GEGL_SAMPLER_NEAREST is returned.

Arguments:

Create a new sampler, when you are done with the sampler, g_object_unref it.

Arguments:

Perform a sampling with the provided sampler.

Arguments:

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:

Check if a rectangle has zero area.

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:

Return: A newly allocated GeglMatrix3

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:

Arguments:

Inverts matrix.

Arguments:

Multiples product = left · right

Arguments:

Hmm not quite sure what this does.

Arguments:

transforms the coordinates provided in x and y and changes to the coordinates gotten when the transformed with the matrix.

Arguments:

Parse a transofmation matrix from a string.

Arguments:

Serialize a GeglMatrix to a string.

Arguments:

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 position 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 transformation matrix of the path.

The path is transformed through this matrix when being evaluated, causing the calculated positions and length to be changed by the transform.

Arguments:

Get the transformation matrix of the path.

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:

Compute 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. if pos = -1, the node is added in the last position.

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:

Appends to path list, if head is NULL a new list is created

Arguments:

Frees up a path list

Arguments:

Add a new flattener, the flattener should produce a type of path that GeglPath already understands, if the flattener is unable to flatten the incoming path (doesn't understand the instructions), the original path should be returned.

Arguments:

Return the internal untouched GeglPathList

Arguments:

Return a polyline version of path

Arguments:

linear interpolation between two GeglPathPoint

Arguments:

Compute the distance between GeglPathPoint a and b

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: