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.

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

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) (array length=n_operations_p): An alphabetically sorted array of available operation names. This excludes any compat-name registered by operations. The list should be freed with g_free after use.

Arguments:

Return value: A boolean telling whether the operation is present or not. This also returns true for any compat-name registered by operations.

Arguments:

Return value: (transfer container) (array length=n_properties_p): An allocated array of GParamSpecs describing the properties of the operation available when a node has operation_type set. The list should be freed with g_free after use.

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 rectangular region from a node to the given buffer.

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:

Return value: (transfer none): the GParamSpec of property or NULL if no such property exists.

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:

Return value: The type of processing operation associated with this node, or NULL if there is no op associated. The special name "GraphNode" is returned if the node is the container of a subgraph.

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:

Load all gegl modules found in the given directory.

Arguments:

Apply the operation to buffer, overwritting the contents of buffer.

Arguments:

Apply the operation to source_buffer, returning the result in a new buffer.

Return value: (transfer full): the result of the filter

Arguments:

Apply the operation to source_buffer, writing the results to target_buffer.

Arguments:

Apply the operation to buffer, overwritting the contents of buffer.

Arguments:

Apply the operation to source_buffer, returning the result in a new buffer.

Return value: (transfer full): the result of the filter

Arguments:

Apply the operation to source_buffer, writing the results to target_buffer.

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:

Return a random floating point number in the range specified, for the given x,y coordinates and seed provided, if multiple different numbers are needed pass in incrementing n's.

Arguments:

Return a random integer point number in the range specified, for the given x,y coordinates and seed provided, if multiple different numbers are needed pass in incrementing n's.

Arguments:

Return a random integer number in range 0 .. MAX_UINT

Arguments:

Return a random floating point number in range 0.0 .. 1.0.

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:

Add a new tile handler in the existing chain of tile handler of a GeglBuffer.

Arguments:

Remove the provided tile handler in the existing chain of tile handler of a GeglBuffer.

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.

Return value: (transfer full): the new sub buffer

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:

Changes the size and position of the abyss rectangle of a buffer.

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:

Sets the region covered by rect to the specified color.

Arguments:

Fill a region with a repeating pattern.

Arguments:

Get the babl format of the buffer, this might not be the format the buffer was originally created with, you need to use gegl_buffer_set_format (buf, NULL); to retireve the original format (potentially having save away the original format of the buffer to re-set it.)

Arguments:

Set the babl format of the buffer, setting the babl format of the buffer requires the new format to have exactly the same bytes per pixel as the original format. If NULL is passed in the format of the buffer is reset to the original format.

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 will create copy-on-write tiles in the destination buffer.

This function never does any scaling. When src_rect and dst_rect do not have the same width and height, the size of src_rect is used.

Arguments:

Duplicate a buffer (internally uses gegl_buffer_copy). Aligned tiles will create copy-on-write clones in the new buffer.

Return value: (transfer full): the new buffer

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.

Samplers only hold weak references to buffers, so if its buffer is freed the sampler will become invalid.

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:

Create a new buffer iterator, this buffer will be iterated through in linear chunks, some chunks might be full tiles the coordinates, see the documentation of gegl_buffer_iterator_next for how to use it and destroy it.

Arguments:

Adds an additional buffer iterator that will be processed in sync with the original one, if the buffer doesn't align with the other for tile access the corresponding scans and regions will be serialized automatically using gegl_buffer_get.

Arguments:

Cancels the current iteration, freeing up any temporary resources. The iterator handle is no longer valid after invoking this function.

Arguments:

Do an iteration, this causes a new set of iterator->data[] to become available if there is more data to process. Changed data from a previous iteration step will also be saved now. When there is no more data to be processed FALSE will be returned (and the iterator handle is no longer valid).

Arguments:

Creates a new rectangle set with the values from x, y, width and height.

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:

Create a new copy of rectangle.

Return value: (transfer full): a GeglRectangle

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:

allocated 0'd memory.

Arguments:

Fill dst_ptr with count copies of the byes in src_ptr.

Arguments:

Creates a new GeglColor.

Arguments:

Creates a copy of color.

Return value: (transfer full): A new copy of color.

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

Arguments:

Set a GeglColor from a pointer to a pixel and it's babl format.

Arguments:

Store the color in a pixel in the given format.

Arguments:

Creates a new GParamSpec instance specifying a GeglColor property.

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:

Creates a new GParamSpec instance specifying a GeglPath property.

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:

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:

Create a default GeglCurve with an identify mapping of (0.0..1.0) -> (0.0..1.0).

Create a copy of curve.

Return value: (transfer full): A new copy of curve.

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: