mathematical 1.4.2 → 1.5.0

data/ext/mathematical/lasem/src/lsmsvgenumtypes.h

@@ -0,0 +1,129 @@
+
+/* Generated data (by glib-mkenums) */
+
+#ifndef LSM_SVG_ENUM_TYPES_H
+#define LSM_SVG_ENUM_TYPES_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* Enumerations from "lsmsvgenums.h" */
+
+#define LSM_TYPE_SVG_ANGLE_TYPE	(lsm_svg_angle_type_get_type())
+GType lsm_svg_angle_type_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_BLENDING_MODE	(lsm_svg_blending_mode_get_type())
+GType lsm_svg_blending_mode_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_ENABLE_BACKGROUND	(lsm_svg_enable_background_get_type())
+GType lsm_svg_enable_background_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_PAINT_TYPE	(lsm_svg_paint_type_get_type())
+GType lsm_svg_paint_type_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_LENGTH_DIRECTION	(lsm_svg_length_direction_get_type())
+GType lsm_svg_length_direction_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_LENGTH_TYPE	(lsm_svg_length_type_get_type())
+GType lsm_svg_length_type_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_FILL_RULE	(lsm_svg_fill_rule_get_type())
+GType lsm_svg_fill_rule_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_LINE_JOIN	(lsm_svg_line_join_get_type())
+GType lsm_svg_line_join_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_LINE_CAP	(lsm_svg_line_cap_get_type())
+GType lsm_svg_line_cap_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_TRANSFORM_TYPE	(lsm_svg_transform_type_get_type())
+GType lsm_svg_transform_type_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_OVERFLOW	(lsm_svg_overflow_get_type())
+GType lsm_svg_overflow_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_PATTERN_UNITS	(lsm_svg_pattern_units_get_type())
+GType lsm_svg_pattern_units_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_MARKER_UNITS	(lsm_svg_marker_units_get_type())
+GType lsm_svg_marker_units_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_SPREAD_METHOD	(lsm_svg_spread_method_get_type())
+GType lsm_svg_spread_method_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_ALIGN	(lsm_svg_align_get_type())
+GType lsm_svg_align_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_MEET_OR_SLICE	(lsm_svg_meet_or_slice_get_type())
+GType lsm_svg_meet_or_slice_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_COMP_OP	(lsm_svg_comp_op_get_type())
+GType lsm_svg_comp_op_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_FONT_STRETCH	(lsm_svg_font_stretch_get_type())
+GType lsm_svg_font_stretch_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_FONT_STYLE	(lsm_svg_font_style_get_type())
+GType lsm_svg_font_style_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_FONT_WEIGHT	(lsm_svg_font_weight_get_type())
+GType lsm_svg_font_weight_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_TEXT_ANCHOR	(lsm_svg_text_anchor_get_type())
+GType lsm_svg_text_anchor_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_FILTER_INPUT	(lsm_svg_filter_input_get_type())
+GType lsm_svg_filter_input_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_DISPLAY	(lsm_svg_display_get_type())
+GType lsm_svg_display_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_VISIBILITY	(lsm_svg_visibility_get_type())
+GType lsm_svg_visibility_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_ELEMENT_CATEGORY	(lsm_svg_element_category_get_type())
+GType lsm_svg_element_category_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_WRITING_MODE	(lsm_svg_writing_mode_get_type())
+GType lsm_svg_writing_mode_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_COLOR_FILTER_TYPE	(lsm_svg_color_filter_type_get_type())
+GType lsm_svg_color_filter_type_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_MORPHOLOGY_OPERATOR	(lsm_svg_morphology_operator_get_type())
+GType lsm_svg_morphology_operator_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_EDGE_MODE	(lsm_svg_edge_mode_get_type())
+GType lsm_svg_edge_mode_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_STITCH_TILES	(lsm_svg_stitch_tiles_get_type())
+GType lsm_svg_stitch_tiles_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_TURBULENCE_TYPE	(lsm_svg_turbulence_type_get_type())
+GType lsm_svg_turbulence_type_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_SVG_CHANNEL_SELECTOR	(lsm_svg_channel_selector_get_type())
+GType lsm_svg_channel_selector_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmsvgview.h" */
+
+#define LSM_TYPE_SVG_VIEW_SURFACE_TYPE	(lsm_svg_view_surface_type_get_type())
+GType lsm_svg_view_surface_type_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmsvgmatrix.h" */
+
+#define LSM_TYPE_SVG_MATRIX_FLAGS	(lsm_svg_matrix_flags_get_type())
+GType lsm_svg_matrix_flags_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmsvguseelement.h" */
+
+#define LSM_TYPE_SVG_USE_ELEMENT_FLAGS	(lsm_svg_use_element_flags_get_type())
+GType lsm_svg_use_element_flags_get_type	(void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* LSM_SVG_ENUM_TYPES_H */
+
+/* Generated data ends here */
+

data/ext/mathematical/lasem/src/lsmsvgfiltercolormatrix.c

@@ -0,0 +1,115 @@
+/* Lasem
+ * 
+ * Copyright © 2012 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmsvgfiltercolormatrix.h>
+#include <lsmsvgview.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_svg_filter_color_matrix_get_node_name (LsmDomNode *node)
+{
+	return "feColorMatrix";
+}
+
+/* LsmSvgElement implementation */
+
+static void
+lsm_svg_filter_color_matrix_apply  (LsmSvgFilterPrimitive *self, LsmSvgView *view,
+				    const char *input, const char *output, const LsmBox *subregion)
+{
+	LsmSvgFilterColorMatrix *color_matrix = LSM_SVG_FILTER_COLOR_MATRIX (self);
+
+	lsm_svg_view_apply_color_matrix (view, input, output, subregion,
+					 color_matrix->type.value,
+					 color_matrix->values.value.n_values,
+					 color_matrix->values.value.values);
+}
+
+/* LsmSvgFilterColorMatrix implementation */
+
+static const LsmSvgColorFilterType color_filter_type_default = LSM_SVG_COLOR_FILTER_TYPE_MATRIX;
+static const LsmSvgVector values_default = { .n_values = 0, .values = NULL};
+
+LsmDomNode *
+lsm_svg_filter_color_matrix_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_FILTER_COLOR_MATRIX, NULL);
+}
+
+static void
+lsm_svg_filter_color_matrix_init (LsmSvgFilterColorMatrix *self)
+{
+	self->type.value = color_filter_type_default;
+	self->values.value = values_default;
+}
+
+static void
+lsm_svg_filter_color_matrix_finalize (GObject *object)
+{
+	parent_class->finalize (object);
+}
+
+/* LsmSvgFilterColorMatrix class */
+
+static const LsmAttributeInfos lsm_svg_filter_color_matrix_attribute_infos[] = {
+	{
+		.name = "type",
+		.attribute_offset = offsetof (LsmSvgFilterColorMatrix, type),
+		.trait_class = &lsm_svg_color_filter_type_trait_class,
+		.trait_default = &color_filter_type_default
+	},
+	{
+		.name = "values",
+		.attribute_offset = offsetof (LsmSvgFilterColorMatrix, values),
+		.trait_class = &lsm_svg_vector_trait_class,
+		.trait_default = &values_default
+	}
+};
+
+static void
+lsm_svg_filter_color_matrix_class_init (LsmSvgFilterColorMatrixClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (klass);
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_CLASS (klass);
+	LsmSvgFilterPrimitiveClass *f_primitive_class = LSM_SVG_FILTER_PRIMITIVE_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->finalize = lsm_svg_filter_color_matrix_finalize;
+
+	d_node_class->get_node_name = lsm_svg_filter_color_matrix_get_node_name;
+
+	s_element_class->attribute_manager = lsm_attribute_manager_duplicate (s_element_class->attribute_manager);
+
+	lsm_attribute_manager_add_attributes (s_element_class->attribute_manager,
+					      G_N_ELEMENTS (lsm_svg_filter_color_matrix_attribute_infos),
+					      lsm_svg_filter_color_matrix_attribute_infos);
+
+	f_primitive_class->apply = lsm_svg_filter_color_matrix_apply;
+}
+
+G_DEFINE_TYPE (LsmSvgFilterColorMatrix, lsm_svg_filter_color_matrix, LSM_TYPE_SVG_FILTER_PRIMITIVE)

data/ext/mathematical/lasem/src/lsmsvgfiltercolormatrix.h

@@ -0,0 +1,58 @@
+/* Lasem
+ *
+ * Copyright © 2015 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_SVG_FILTER_COLOR_MATRIX_H
+#define LSM_SVG_FILTER_COLOR_MATRIX_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgfilterprimitive.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_FILTER_COLOR_MATRIX             (lsm_svg_filter_color_matrix_get_type ())
+#define LSM_SVG_FILTER_COLOR_MATRIX(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_FILTER_COLOR_MATRIX, LsmSvgFilterColorMatrix))
+#define LSM_SVG_FILTER_COLOR_MATRIX_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_FILTER_COLOR_MATRIX, LsmSvgFilterColorMatrixClass))
+#define LSM_IS_SVG_FILTER_COLOR_MATRIX(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_FILTER_COLOR_MATRIX))
+#define LSM_IS_SVG_FILTER_COLOR_MATRIX_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_FILTER_COLOR_MATRIX))
+#define LSM_SVG_FILTER_COLOR_MATRIX_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_FILTER_COLOR_MATRIX, LsmSvgFilterColorMatrixClass))
+
+typedef struct _LsmSvgFilterColorMatrixClass LsmSvgFilterColorMatrixClass;
+
+struct _LsmSvgFilterColorMatrix {
+	LsmSvgFilterPrimitive base;
+
+	LsmSvgColorFilterTypeAttribute type;
+	LsmSvgVectorAttribute values;
+};
+
+struct _LsmSvgFilterColorMatrixClass {
+	LsmSvgFilterPrimitiveClass  element_class;
+};
+
+GType lsm_svg_filter_color_matrix_get_type (void);
+
+LsmDomNode * 	lsm_svg_filter_color_matrix_new 		(void);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lasem/src/lsmsvgfilterconvolvematrix.c

@@ -0,0 +1,206 @@
+/* Lasem
+ * 
+ * Copyright © 2015 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmsvgfilterconvolvematrix.h>
+#include <lsmsvgview.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_svg_filter_convolve_matrix_get_node_name (LsmDomNode *node)
+{
+	return "feConvolveMatrix";
+}
+
+/* LsmSvgElement implementation */
+
+static void
+lsm_svg_filter_convolve_matrix_apply  (LsmSvgFilterPrimitive *self, LsmSvgView *view,
+				       const char *input, const char *output, const LsmBox *subregion)
+{
+	double divisor;
+	int order_x;
+	int order_y;
+	int target_x;
+	int target_y;
+
+	LsmSvgFilterConvolveMatrix *convolve_matrix = LSM_SVG_FILTER_CONVOLVE_MATRIX (self);
+
+	order_x = convolve_matrix->order.value.a;
+	order_y = convolve_matrix->order.value.b;
+
+	if (lsm_attribute_is_defined (&convolve_matrix->target_x.base))
+		target_x = convolve_matrix->target_x.value;
+	else
+		target_x = order_x / 2;
+
+	if (lsm_attribute_is_defined (&convolve_matrix->target_y.base))
+		target_y = convolve_matrix->target_y.value;
+	else
+		target_y = order_y / 2;
+
+	target_x = CLAMP (target_x, 0, order_x);
+	target_y = CLAMP (target_y, 0, order_y);
+
+	if (lsm_attribute_is_defined (&convolve_matrix->divisor.base))
+		divisor = convolve_matrix->divisor.value;
+	else {
+		int i;
+
+		divisor = 0.0;
+
+		for (i = 0; i < convolve_matrix->kernel.value.n_values; i++)
+			divisor += convolve_matrix->kernel.value.values[i];
+	}
+
+	if (divisor <= 0.0) {
+		lsm_warning_dom ("[SvgFilterConvolveMatrix::apply] Invalid divisor");
+		return;
+	}
+
+	lsm_svg_view_apply_convolve_matrix (view, input, output, subregion,
+					    order_x, order_y,
+					    convolve_matrix->kernel.value.n_values,
+					    convolve_matrix->kernel.value.values,
+					    divisor,
+					    convolve_matrix->bias.value,
+					    target_x,
+					    target_y,
+					    convolve_matrix->edge_mode.value,
+					    convolve_matrix->preserve_alpha.value);
+}
+
+/* LsmSvgFilterConvolveMatrix implementation */
+
+LsmDomNode *
+lsm_svg_filter_convolve_matrix_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_FILTER_CONVOLVE_MATRIX, NULL);
+}
+
+static const LsmSvgOneOrTwoInteger order_default = {0, 0};
+static const LsmSvgVector kernel_default = { .n_values = 0, .values = NULL};
+static const double divisor_default = 0.0;
+static const double bias_default = 0.0;
+static const int target_default = -1;
+static const LsmSvgEdgeMode edge_mode_default = LSM_SVG_EDGE_MODE_NONE;
+static const gboolean preserve_alpha_default = FALSE;
+
+static void
+lsm_svg_filter_convolve_matrix_init (LsmSvgFilterConvolveMatrix *self)
+{
+	self->order.value = order_default;
+	self->kernel.value = kernel_default;
+	self->divisor.value = divisor_default;
+	self->bias.value = bias_default;
+	self->target_x.value = target_default;
+	self->target_y.value = target_default;
+	self->edge_mode.value = edge_mode_default;
+	self->preserve_alpha.value = preserve_alpha_default;
+}
+
+static void
+lsm_svg_filter_convolve_matrix_finalize (GObject *object)
+{
+	parent_class->finalize (object);
+}
+
+/* LsmSvgFilterConvolveMatrix class */
+
+static const LsmAttributeInfos lsm_svg_filter_convolve_matrix_attribute_infos[] = {
+	{
+		.name = "order",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, order),
+		.trait_class = &lsm_svg_one_or_two_integer_trait_class,
+		.trait_default = &order_default
+	},
+	{
+		.name = "kernelMatrix",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, kernel),
+		.trait_class = &lsm_svg_vector_trait_class,
+		.trait_default = &kernel_default
+	},
+	{
+		.name = "divisor",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, divisor),
+		.trait_class = &lsm_double_trait_class,
+		.trait_default = &divisor_default
+	},
+	{
+		.name = "bias",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, bias),
+		.trait_class = &lsm_double_trait_class,
+		.trait_default = &bias_default
+	},
+	{
+		.name = "targetX",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, target_x),
+		.trait_class = &lsm_integer_trait_class,
+		.trait_default = &target_default
+	},
+	{
+		.name = "targetY",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, target_y),
+		.trait_class = &lsm_integer_trait_class,
+		.trait_default = &target_default
+	},
+	{
+		.name = "edgeMode",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, edge_mode),
+		.trait_class = &lsm_svg_edge_mode_trait_class,
+		.trait_default = &edge_mode_default
+	},
+	{
+		.name = "preserveAlpha",
+		.attribute_offset = offsetof (LsmSvgFilterConvolveMatrix, preserve_alpha),
+		.trait_class = &lsm_boolean_trait_class,
+		.trait_default = &preserve_alpha_default
+	}
+};
+
+static void
+lsm_svg_filter_convolve_matrix_class_init (LsmSvgFilterConvolveMatrixClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (klass);
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_CLASS (klass);
+	LsmSvgFilterPrimitiveClass *f_primitive_class = LSM_SVG_FILTER_PRIMITIVE_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->finalize = lsm_svg_filter_convolve_matrix_finalize;
+
+	d_node_class->get_node_name = lsm_svg_filter_convolve_matrix_get_node_name;
+
+	s_element_class->attribute_manager = lsm_attribute_manager_duplicate (s_element_class->attribute_manager);
+
+	lsm_attribute_manager_add_attributes (s_element_class->attribute_manager,
+					      G_N_ELEMENTS (lsm_svg_filter_convolve_matrix_attribute_infos),
+					      lsm_svg_filter_convolve_matrix_attribute_infos);
+
+	f_primitive_class->apply = lsm_svg_filter_convolve_matrix_apply;
+}
+
+G_DEFINE_TYPE (LsmSvgFilterConvolveMatrix, lsm_svg_filter_convolve_matrix, LSM_TYPE_SVG_FILTER_PRIMITIVE)

data/ext/mathematical/lasem/src/lsmsvgfilterconvolvematrix.h

@@ -0,0 +1,64 @@
+/* Lasem
+ *
+ * Copyright © 2015 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_SVG_FILTER_CONVOLVE_MATRIX_H
+#define LSM_SVG_FILTER_CONVOLVE_MATRIX_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgfilterprimitive.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_FILTER_CONVOLVE_MATRIX             (lsm_svg_filter_convolve_matrix_get_type ())
+#define LSM_SVG_FILTER_CONVOLVE_MATRIX(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_FILTER_CONVOLVE_MATRIX, LsmSvgFilterConvolveMatrix))
+#define LSM_SVG_FILTER_CONVOLVE_MATRIX_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_FILTER_CONVOLVE_MATRIX, LsmSvgFilterConvolveMatrixClass))
+#define LSM_IS_SVG_FILTER_CONVOLVE_MATRIX(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_FILTER_CONVOLVE_MATRIX))
+#define LSM_IS_SVG_FILTER_CONVOLVE_MATRIX_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_FILTER_CONVOLVE_MATRIX))
+#define LSM_SVG_FILTER_CONVOLVE_MATRIX_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_FILTER_CONVOLVE_MATRIX, LsmSvgFilterConvolveMatrixClass))
+
+typedef struct _LsmSvgFilterConvolveMatrixClass LsmSvgFilterConvolveMatrixClass;
+
+struct _LsmSvgFilterConvolveMatrix {
+	LsmSvgFilterPrimitive base;
+
+	LsmSvgOneOrTwoIntegerAttribute order;
+	LsmSvgVectorAttribute kernel;
+	LsmSvgDoubleAttribute divisor;
+	LsmSvgDoubleAttribute bias;
+	LsmSvgIntegerAttribute target_x;
+	LsmSvgIntegerAttribute target_y;
+	LsmSvgEdgeModeAttribute edge_mode;
+	LsmSvgBooleanAttribute preserve_alpha;
+};
+
+struct _LsmSvgFilterConvolveMatrixClass {
+	LsmSvgFilterPrimitiveClass  element_class;
+};
+
+GType lsm_svg_filter_convolve_matrix_get_type (void);
+
+LsmDomNode * 	lsm_svg_filter_convolve_matrix_new 		(void);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lasem/src/lsmsvgfilterdisplacementmap.c

@@ -0,0 +1,124 @@
+/* Lasem
+ * 
+ * Copyright © 2015 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmsvgfilterdisplacementmap.h>
+#include <lsmsvgview.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_svg_filter_displacement_map_get_node_name (LsmDomNode *node)
+{
+	return "feDisplacementMap";
+}
+
+/* LsmSvgElement implementation */
+
+static void
+lsm_svg_filter_displacement_map_apply  (LsmSvgFilterPrimitive *self, LsmSvgView *view,
+			     const char *input, const char *output, const LsmBox *subregion)
+{
+	LsmSvgFilterDisplacementMap *displacement_map = LSM_SVG_FILTER_DISPLACEMENT_MAP (self);
+
+	lsm_svg_view_apply_displacement_map (view, input, displacement_map->in2.value, output, subregion,
+					     displacement_map->scale.value,
+					     displacement_map->x_channel_selector.value,
+					     displacement_map->y_channel_selector.value);
+}
+
+/* LsmSvgFilterDisplacementMap implementation */
+
+LsmDomNode *
+lsm_svg_filter_displacement_map_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_FILTER_DISPLACEMENT_MAP, NULL);
+}
+
+static double scale_default = 0.0; 
+static LsmSvgChannelSelector channel_selector_default = LSM_SVG_CHANNEL_SELECTOR_ALPHA;
+
+static void
+lsm_svg_filter_displacement_map_init (LsmSvgFilterDisplacementMap *self)
+{
+}
+
+static void
+lsm_svg_filter_displacement_map_finalize (GObject *object)
+{
+	parent_class->finalize (object);
+}
+
+/* LsmSvgFilterDisplacementMap class */
+
+static const LsmAttributeInfos lsm_svg_filter_displacement_map_attribute_infos[] = {
+	{
+		.name = "in2",
+		.attribute_offset = offsetof (LsmSvgFilterDisplacementMap, in2),
+		.trait_class = &lsm_null_trait_class
+	},
+	{
+		.name = "scale",
+		.attribute_offset = offsetof (LsmSvgFilterDisplacementMap, scale),
+		.trait_class = &lsm_double_trait_class,
+		.trait_default = &scale_default
+	},
+	{
+		.name = "xChannelSelector",
+		.attribute_offset = offsetof (LsmSvgFilterDisplacementMap, x_channel_selector),
+		.trait_class = &lsm_svg_channel_selector_trait_class,
+		.trait_default = &channel_selector_default
+	},
+	{
+		.name = "yChannelSelector",
+		.attribute_offset = offsetof (LsmSvgFilterDisplacementMap, y_channel_selector),
+		.trait_class = &lsm_svg_channel_selector_trait_class,
+		.trait_default = &channel_selector_default
+	}
+};
+
+static void
+lsm_svg_filter_displacement_map_class_init (LsmSvgFilterDisplacementMapClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (klass);
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_CLASS (klass);
+	LsmSvgFilterPrimitiveClass *f_primitive_class = LSM_SVG_FILTER_PRIMITIVE_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->finalize = lsm_svg_filter_displacement_map_finalize;
+
+	d_node_class->get_node_name = lsm_svg_filter_displacement_map_get_node_name;
+
+	s_element_class->attribute_manager = lsm_attribute_manager_duplicate (s_element_class->attribute_manager);
+
+	lsm_attribute_manager_add_attributes (s_element_class->attribute_manager,
+					      G_N_ELEMENTS (lsm_svg_filter_displacement_map_attribute_infos),
+					      lsm_svg_filter_displacement_map_attribute_infos);
+
+	f_primitive_class->apply = lsm_svg_filter_displacement_map_apply;
+}
+
+G_DEFINE_TYPE (LsmSvgFilterDisplacementMap, lsm_svg_filter_displacement_map, LSM_TYPE_SVG_FILTER_PRIMITIVE)