gimp_composite_generic_init ()

gboolean            gimp_composite_generic_init         (void);

Initialise the generic set of compositing functions.

gimp_composite_generic_install ()

gboolean            gimp_composite_generic_install      (void);

gimp_composite_addition_any_any_any_generic ()

void                gimp_composite_addition_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] addition operation of the pixel sources ctx->A and ctx->B.

gimp_composite_anti_erase_any_any_any_generic ()

void                gimp_composite_anti_erase_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] "anti-erase" operation of the pixel source ctx->A using the alpha information in ctx->B.

gimp_composite_behind_any_any_any_generic ()

void                gimp_composite_behind_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a behind operation to between the pixel sources ctx->A and ctx->B.

gimp_composite_blend_any_any_any_generic ()

void                gimp_composite_blend_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a blend operation between sources ctx->A and ctx->B, using the generalised algorithm: D = A * (255 - β) + B * β

The result is left in ctx->D

gimp_composite_burn_any_any_any_generic ()

void                gimp_composite_burn_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] dodge operation between the pixel sources ctx->A and ctx->B, using the generalised algorithm:

D = saturation of 255 or depletion of 0, of ((255 - A) * 256) / (B + 1)

gimp_composite_color_any_any_any_generic ()

void                gimp_composite_color_any_any_any_generic
                                                        (guchar *dest,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);

gimp_composite_color_erase_any_any_any_generic ()

void                gimp_composite_color_erase_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] "color-erase" operation of the pixel source ctx->A using the alpha information in ctx->B.

gimp_composite_color_only_any_any_any_generic ()

void                gimp_composite_color_only_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a conversion to of the source ctx->A using the hue and saturation values of ctx->B.

gimp_composite_convert_any_any_any_generic ()

void                gimp_composite_convert_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

gimp_composite_darken_any_any_any_generic ()

void                gimp_composite_darken_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a darken operation between sources ctx->A and ctx->B, using the generalised algorithm: D_r = min(A_r, B_r); D_g = min(A_g, B_g); D_b = min(A_b, B_b); D_a = min(A_a, B_a);

gimp_composite_difference_any_any_any_generic ()

void                gimp_composite_difference_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] difference operation between the pixel sources ctx->A and ctx->B.

gimp_composite_dissolve_any_any_any_generic ()

void                gimp_composite_dissolve_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] alpha dissolve operation between the pixel sources ctx->A and ctx->B.

gimp_composite_divide_any_any_any_generic ()

void                gimp_composite_divide_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] divide operation between the pixel sources ctx->A and ctx->B. ctx->A is the numerator, ctx->B the denominator.

gimp_composite_dodge_any_any_any_generic ()

void                gimp_composite_dodge_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] dodge operation between the pixel sources ctx->A and ctx->B, using the generalised algorithm:

D = saturation of 255 or (A * 256) / (256 - B)

gimp_composite_erase_any_any_any_generic ()

void                gimp_composite_erase_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] "erase" operation of the pixel source ctx->A using the alpha information in ctx->B.

gimp_composite_grain_extract_any_any_any_generic ()

void                gimp_composite_grain_extract_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] grain-extract operation between the pixel sources ctx->A and ctx->B.

gimp_composite_grain_merge_any_any_any_generic ()

void                gimp_composite_grain_merge_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] grain-merge operation between the pixel sources ctx->A and ctx->B.

gimp_composite_hardlight_any_any_any_generic ()

void                gimp_composite_hardlight_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] hardlight operation between the pixel sources ctx->A and ctx->B.

gimp_composite_hue_any_any_any_generic ()

void                gimp_composite_hue_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a conversion to hue only of the source ctx->A using the hue of ctx->B.

gimp_composite_lighten_any_any_any_generic ()

void                gimp_composite_lighten_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a lighten operation between sources ctx->A and ctx->B, using the generalised algorithm: D_r = max(A_r, B_r); D_g = max(A_g, B_g); D_b = max(A_b, B_b); D_a = min(A_a, B_a);

gimp_composite_multiply_any_any_any_generic ()

void                gimp_composite_multiply_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] multiply operation between the pixel sources ctx->A and ctx->B.

gimp_composite_normal_any_any_any_generic ()

void                gimp_composite_normal_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] over operation of the pixel source ctx->B on ctx->A.

gimp_composite_overlay_any_any_any_generic ()

void                gimp_composite_overlay_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] overlay operation between the pixel sources ctx->A and ctx->B, using the generalised algorithm:

D = A * (A + (2 * B) * (255 - A))

gimp_composite_replace_any_any_any_generic ()

void                gimp_composite_replace_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] replace operation of the pixel source ctx->A with the ctx->B.

gimp_composite_saturation_any_any_any_generic ()

void                gimp_composite_saturation_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a conversion to saturation only of the source ctx->A using the saturation level of ctx->B.

gimp_composite_scale_any_any_any_generic ()

void                gimp_composite_scale_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] scale operation of the pixel source ctx->A using the scale coefficient on the compositing context, ctx.

gimp_composite_screen_any_any_any_generic ()

void                gimp_composite_screen_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] screen operation between the pixel sources ctx->A and ctx->B, using the generalised algorithm:

D = 255 - (255 - A) * (255 - B)

gimp_composite_softlight_any_any_any_generic ()

void                gimp_composite_softlight_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] softlight operation between the pixel sources ctx->A and ctx->B.

gimp_composite_subtract_any_any_any_generic ()

void                gimp_composite_subtract_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform an RGB[A] subtract operation of the pixel source ctx-B from ctx->A.

gimp_composite_swap_any_any_any_generic ()

void                gimp_composite_swap_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Swap the contents of ctx->A and ctx->B.

gimp_composite_value_any_any_any_generic ()

void                gimp_composite_value_any_any_any_generic
                                                        (GimpCompositeContext *ctx);

Perform a conversion to value only of the source ctx->A using the value of ctx->B.