mathematical 1.4.2 → 1.5.0

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

@@ -25,7 +25,9 @@
 #define LSM_SVG_FILTER_SURFACE_H
 
 #include <lsmtypes.h>
+#include <lsmsvgtraits.h>
 #include <cairo.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
 
 G_BEGIN_DECLS
 
@@ -40,7 +42,6 @@ LsmSvgFilterSurface * 	lsm_svg_filter_surface_new 		(const char *name, unsigned
 LsmSvgFilterSurface * 	lsm_svg_filter_surface_new_with_content	(const char *name, cairo_surface_t *surface, const LsmBox *subregion);
 LsmSvgFilterSurface *	lsm_svg_filter_surface_new_similar	(const char *name, LsmSvgFilterSurface *model, const LsmBox *subregion);
 
-void 			lsm_svg_filter_surface_copy_data 	(LsmSvgFilterSurface *to, LsmSvgFilterSurface *from);
 const char * 		lsm_svg_filter_surface_get_name 	(LsmSvgFilterSurface *surface);
 cairo_surface_t *	lsm_svg_filter_surface_get_cairo_surface(LsmSvgFilterSurface *surface);
 const LsmBox *		lsm_svg_filter_surface_get_subregion 	(LsmSvgFilterSurface *surface);
@@ -52,7 +53,7 @@ void 			lsm_svg_filter_surface_blend 		(LsmSvgFilterSurface *input_1,
 								 LsmSvgFilterSurface *input_2,
 								 LsmSvgFilterSurface *output,
 								 int blending_mode);
-void 			lsm_svg_filter_surface_fast_blur 	(LsmSvgFilterSurface *input, LsmSvgFilterSurface *output,
+void 			lsm_svg_filter_surface_blur 		(LsmSvgFilterSurface *input, LsmSvgFilterSurface *output,
 								 double sx, double sy);
 void 			lsm_svg_filter_surface_flood 		(LsmSvgFilterSurface *surface,
 								 double red, double green, double blue, double opacity);
@@ -60,6 +61,31 @@ void 			lsm_svg_filter_surface_offset 		(LsmSvgFilterSurface *input, LsmSvgFilte
 								 int dx, int dy);
 void 			lsm_svg_filter_surface_merge 		(LsmSvgFilterSurface *input, LsmSvgFilterSurface *output);
 void 			lsm_svg_filter_surface_tile 		(LsmSvgFilterSurface *input, LsmSvgFilterSurface *output);
+void 			lsm_svg_filter_surface_color_matrix 	(LsmSvgFilterSurface *input, LsmSvgFilterSurface *output,
+								 LsmSvgColorFilterType type, unsigned n_values, const double *values);
+void 			lsm_svg_filter_surface_convolve_matrix 	(LsmSvgFilterSurface *input, LsmSvgFilterSurface *output,
+								 unsigned x_order, unsigned y_order,
+								 unsigned n_values, const double *values,
+								 double divisor, double bias, unsigned target_x, unsigned target_y,
+								 LsmSvgEdgeMode edge_mode, gboolean preserve_alpha);
+void			lsm_svg_filter_surface_displacement_map (LsmSvgFilterSurface *input_1,
+								 LsmSvgFilterSurface *input_2,
+								 LsmSvgFilterSurface *output,
+								 double x_scale, double y_scale,
+								 LsmSvgChannelSelector x_channel_selector,
+								 LsmSvgChannelSelector y_channel_selector);
+void			lsm_svg_filter_surface_image 		(LsmSvgFilterSurface *output, GdkPixbuf *pixbuf,
+								 LsmSvgPreserveAspectRatio preserve_aspect_ratio);
+void 			lsm_svg_filter_surface_morphology 	(LsmSvgFilterSurface *input_surface, LsmSvgFilterSurface *output_surface,
+								 LsmSvgMorphologyOperator op, double rx, double ry);
+void 			lsm_svg_filter_surface_specular_lighting(LsmSvgFilterSurface *output_surface,
+								 double surface_scale, double specular_constant, double specular_exponent,
+								 double dx, double dy);
+void			lsm_svg_filter_surface_turbulence 	(LsmSvgFilterSurface *output_surface,
+								 double base_frequency_x, double base_frequency_y,
+								 int n_octaves, double seed,
+								 LsmSvgStitchTiles stitch_tiles, LsmSvgTurbulenceType type,
+								 const cairo_matrix_t *transform);
 
 G_END_DECLS
 

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

@@ -0,0 +1,142 @@
+/* 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 <lsmsvgfilterturbulence.h>
+#include <lsmsvgview.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_svg_filter_turbulence_get_node_name (LsmDomNode *node)
+{
+	return "feTurbulence";
+}
+
+/* LsmSvgElement implementation */
+
+static void
+lsm_svg_filter_turbulence_apply  (LsmSvgFilterPrimitive *self, LsmSvgView *view,
+			     const char *input, const char *output, const LsmBox *subregion)
+{
+	LsmSvgFilterTurbulence *turbulence = LSM_SVG_FILTER_TURBULENCE (self);
+
+	lsm_svg_view_apply_turbulence (view, output, subregion,
+				       turbulence->base_frequency.value.a,
+				       turbulence->base_frequency.value.b,
+				       turbulence->n_octaves.value,
+				       turbulence->seed.value,
+				       turbulence->stitch_tiles.value,
+				       turbulence->type.value);
+}
+
+/* LsmSvgFilterTurbulence implementation */
+
+LsmDomNode *
+lsm_svg_filter_turbulence_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_FILTER_TURBULENCE, NULL);
+}
+
+static const LsmSvgOneOrTwoDouble base_frequency_default = {0.0, 0.0};
+static const int n_octaves_default = 1;
+static const double seed_default = 0.0;
+static const LsmSvgStitchTiles stitch_tiles_default = LSM_SVG_STITCH_TILES_NO_STITCH;
+static const LsmSvgTurbulenceType type_default = LSM_SVG_TURBULENCE_TYPE_TURBULENCE;
+
+static void
+lsm_svg_filter_turbulence_init (LsmSvgFilterTurbulence *self)
+{
+	self->base_frequency.value = base_frequency_default;
+	self->n_octaves.value = n_octaves_default;
+	self->seed.value = seed_default;
+	self->stitch_tiles.value = stitch_tiles_default;
+	self->type.value = type_default;
+}
+
+static void
+lsm_svg_filter_turbulence_finalize (GObject *object)
+{
+	parent_class->finalize (object);
+}
+
+/* LsmSvgFilterTurbulence class */
+
+static const LsmAttributeInfos lsm_svg_filter_turbulence_attribute_infos[] = {
+	{
+		.name = "baseFrequency",
+		.attribute_offset = offsetof (LsmSvgFilterTurbulence, base_frequency),
+		.trait_class = &lsm_svg_one_or_two_double_trait_class,
+ 		.trait_default = &base_frequency_default
+	},
+	{
+		.name = "numOctaves",
+		.attribute_offset = offsetof (LsmSvgFilterTurbulence, n_octaves),
+		.trait_class = &lsm_integer_trait_class,
+		.trait_default = &n_octaves_default
+	},
+	{
+		.name = "seed",
+		.attribute_offset = offsetof (LsmSvgFilterTurbulence, seed),
+		.trait_class = &lsm_double_trait_class,
+		.trait_default = &seed_default
+	},
+	{
+		.name = "stitchTiles",
+		.attribute_offset = offsetof (LsmSvgFilterTurbulence, stitch_tiles),
+		.trait_class = &lsm_svg_stitch_tiles_trait_class,
+		.trait_default = &stitch_tiles_default
+	},
+	{
+		.name = "type",
+		.attribute_offset = offsetof (LsmSvgFilterTurbulence, type),
+		.trait_class = &lsm_svg_turbulence_type_trait_class,
+		.trait_default = &type_default
+	}
+};
+
+static void
+lsm_svg_filter_turbulence_class_init (LsmSvgFilterTurbulenceClass *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_turbulence_finalize;
+
+	d_node_class->get_node_name = lsm_svg_filter_turbulence_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_turbulence_attribute_infos),
+					      lsm_svg_filter_turbulence_attribute_infos);
+
+	f_primitive_class->apply = lsm_svg_filter_turbulence_apply;
+}
+
+G_DEFINE_TYPE (LsmSvgFilterTurbulence, lsm_svg_filter_turbulence, LSM_TYPE_SVG_FILTER_PRIMITIVE)

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

@@ -0,0 +1,61 @@
+/* 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_TURBULENCE_H
+#define LSM_SVG_FILTER_TURBULENCE_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgfilterprimitive.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_FILTER_TURBULENCE             (lsm_svg_filter_turbulence_get_type ())
+#define LSM_SVG_FILTER_TURBULENCE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_FILTER_TURBULENCE, LsmSvgFilterTurbulence))
+#define LSM_SVG_FILTER_TURBULENCE_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_FILTER_TURBULENCE, LsmSvgFilterTurbulenceClass))
+#define LSM_IS_SVG_FILTER_TURBULENCE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_FILTER_TURBULENCE))
+#define LSM_IS_SVG_FILTER_TURBULENCE_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_FILTER_TURBULENCE))
+#define LSM_SVG_FILTER_TURBULENCE_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_FILTER_TURBULENCE, LsmSvgFilterTurbulenceClass))
+
+typedef struct _LsmSvgFilterTurbulenceClass LsmSvgFilterTurbulenceClass;
+
+struct _LsmSvgFilterTurbulence {
+	LsmSvgFilterPrimitive base;
+
+	LsmSvgOneOrTwoDoubleAttribute base_frequency;
+	LsmSvgIntegerAttribute n_octaves;
+	LsmSvgDoubleAttribute seed;
+	LsmSvgStitchTilesAttribute stitch_tiles;
+	LsmSvgTurbulenceTypeAttribute type;
+};
+
+struct _LsmSvgFilterTurbulenceClass {
+	LsmSvgFilterPrimitiveClass  element_class;
+};
+
+GType lsm_svg_filter_turbulence_get_type (void);
+
+LsmDomNode * 	lsm_svg_filter_turbulence_new 		(void);
+
+G_END_DECLS
+
+#endif

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

@@ -103,6 +103,71 @@ const LsmTraitClass lsm_svg_enable_background_trait_class = {
 	.to_string = lsm_svg_enable_background_trait_to_string
 };
 
+static gboolean
+lsm_svg_vector_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgVector *vector = (LsmSvgVector *) abstract_trait;
+	unsigned int n_values = 1;
+	gboolean success = FALSE;
+	char *iter = (char *) string;
+
+	g_free (vector->values);
+	vector->n_values = 0;
+	vector->values = NULL;
+
+	while (*iter != '\0') {
+		if (*iter == ',' ||
+		    *iter == ' ') {
+			n_values++;
+			do {
+				iter++;
+			} while (*iter == ',' ||
+				 *iter == ' ');
+		} else
+			iter++;
+	}
+
+	vector->values = g_new (double, n_values);
+	vector->n_values = n_values;
+
+	iter = (char *)string;
+	n_values = lsm_str_parse_double_list (&iter, vector->n_values, vector->values);
+	success = n_values == vector->n_values;
+
+	if (!success) {
+		g_free (vector->values);
+		vector->values = NULL;
+		vector->n_values = 0;
+	}
+
+	return success;
+}
+
+static char *
+lsm_svg_vector_trait_to_string (LsmTrait *abstract_trait)
+{
+	g_assert_not_reached ();
+
+	return NULL;
+}
+
+static void
+lsm_svg_vector_trait_finalize (LsmTrait *abstract_trait)
+{
+	LsmSvgVector *svg_vector = (LsmSvgVector *) abstract_trait;
+
+	g_free (svg_vector->values);
+	svg_vector->n_values = 0;
+	svg_vector->values = NULL;
+}
+
+const LsmTraitClass lsm_svg_vector_trait_class = {
+	.size = sizeof (LsmSvgVector),
+	.from_string = lsm_svg_vector_trait_from_string,
+	.to_string = lsm_svg_vector_trait_to_string,
+	.finalize = lsm_svg_vector_trait_finalize
+};
+
 static gboolean
 lsm_svg_length_trait_from_string (LsmTrait *abstract_trait, char *string)
 {
@@ -935,6 +1000,30 @@ const LsmTraitClass lsm_svg_color_trait_class = {
 	.to_string = lsm_svg_color_trait_to_string
 };
 
+static gboolean
+lsm_svg_color_filter_type_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgColorFilterType *trait = (LsmSvgColorFilterType *) abstract_trait;
+
+	*trait = lsm_svg_color_filter_type_from_string (string);
+
+	return *trait >= 0;
+}
+
+static char *
+lsm_svg_color_filter_type_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmSvgColorFilterType *trait = (LsmSvgColorFilterType *) abstract_trait;
+
+	return g_strdup (lsm_svg_color_filter_type_to_string (*trait));
+}
+
+const LsmTraitClass lsm_svg_color_filter_type_trait_class = {
+	.size = sizeof (LsmSvgColorFilterType),
+	.from_string = lsm_svg_color_filter_type_trait_from_string,
+	.to_string = lsm_svg_color_filter_type_trait_to_string
+};
+
 static gboolean
 lsm_svg_marker_units_trait_from_string (LsmTrait *abstract_trait, char *string)
 {
@@ -1182,6 +1271,47 @@ const LsmTraitClass lsm_svg_one_or_two_double_trait_class = {
 	.to_string = lsm_svg_one_or_two_double_trait_to_string
 };
 
+static gboolean
+lsm_svg_one_or_two_integer_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgOneOrTwoInteger *trait = (LsmSvgOneOrTwoInteger *) abstract_trait;
+	char *end_ptr;
+
+	trait->a = g_ascii_strtoll (string, &end_ptr, 10);
+	if (end_ptr == string) {
+		trait->a = 0;
+		trait->b = 0;
+		return FALSE;
+	}
+
+	string = end_ptr;
+
+	lsm_str_skip_spaces (&string);
+
+	if (string[0] == '\0') {
+		trait->b = trait->a;
+		return TRUE;
+	}
+
+	trait->b = g_ascii_strtoll (string, &end_ptr, 10);
+
+	return TRUE;
+}
+
+static char *
+lsm_svg_one_or_two_integer_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmSvgOneOrTwoInteger *trait = (LsmSvgOneOrTwoInteger *) abstract_trait;
+
+	return g_strdup_printf ("%d %d", trait->a, trait->b);
+}
+
+const LsmTraitClass lsm_svg_one_or_two_integer_trait_class = {
+	.size = sizeof (double),
+	.from_string = lsm_svg_one_or_two_integer_trait_from_string,
+	.to_string = lsm_svg_one_or_two_integer_trait_to_string
+};
+
 static gboolean
 lsm_svg_overflow_trait_from_string (LsmTrait *abstract_trait, char *string)
 {
@@ -1230,3 +1360,122 @@ const LsmTraitClass lsm_svg_writing_mode_trait_class = {
 	.to_string = lsm_svg_writing_mode_trait_to_string
 };
 
+static gboolean
+lsm_svg_morphology_operator_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgMorphologyOperator *trait = (LsmSvgMorphologyOperator *) abstract_trait;
+
+	*trait = lsm_svg_morphology_operator_from_string (string);
+
+	return *trait >= 0;
+}
+
+static char *
+lsm_svg_morphology_operator_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmSvgMorphologyOperator *trait = (LsmSvgMorphologyOperator *) abstract_trait;
+
+	return g_strdup (lsm_svg_morphology_operator_to_string (*trait));
+}
+
+const LsmTraitClass lsm_svg_morphology_operator_trait_class = {
+	.size = sizeof (LsmSvgMorphologyOperator),
+	.from_string = lsm_svg_morphology_operator_trait_from_string,
+	.to_string = lsm_svg_morphology_operator_trait_to_string
+};
+
+static gboolean
+lsm_svg_edge_mode_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgEdgeMode *trait = (LsmSvgEdgeMode *) abstract_trait;
+
+	*trait = lsm_svg_edge_mode_from_string (string);
+
+	return *trait >= 0;
+}
+
+static char *
+lsm_svg_edge_mode_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmSvgEdgeMode *trait = (LsmSvgEdgeMode *) abstract_trait;
+
+	return g_strdup (lsm_svg_edge_mode_to_string (*trait));
+}
+
+const LsmTraitClass lsm_svg_edge_mode_trait_class = {
+	.size = sizeof (LsmSvgEdgeMode),
+	.from_string = lsm_svg_edge_mode_trait_from_string,
+	.to_string = lsm_svg_edge_mode_trait_to_string
+};
+
+static gboolean
+lsm_svg_stitch_tiles_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgStitchTiles *trait = (LsmSvgStitchTiles *) abstract_trait;
+
+	*trait = lsm_svg_stitch_tiles_from_string (string);
+
+	return *trait >= 0;
+}
+
+static char *
+lsm_svg_stitch_tiles_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmSvgStitchTiles *trait = (LsmSvgStitchTiles *) abstract_trait;
+
+	return g_strdup (lsm_svg_stitch_tiles_to_string (*trait));
+}
+
+const LsmTraitClass lsm_svg_stitch_tiles_trait_class = {
+	.size = sizeof (LsmSvgStitchTiles),
+	.from_string = lsm_svg_stitch_tiles_trait_from_string,
+	.to_string = lsm_svg_stitch_tiles_trait_to_string
+};
+
+static gboolean
+lsm_svg_turbulence_type_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgTurbulenceType *trait = (LsmSvgTurbulenceType *) abstract_trait;
+
+	*trait = lsm_svg_turbulence_type_from_string (string);
+
+	return *trait >= 0;
+}
+
+static char *
+lsm_svg_turbulence_type_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmSvgTurbulenceType *trait = (LsmSvgTurbulenceType *) abstract_trait;
+
+	return g_strdup (lsm_svg_turbulence_type_to_string (*trait));
+}
+
+const LsmTraitClass lsm_svg_turbulence_type_trait_class = {
+	.size = sizeof (LsmSvgTurbulenceType),
+	.from_string = lsm_svg_turbulence_type_trait_from_string,
+	.to_string = lsm_svg_turbulence_type_trait_to_string
+};
+
+static gboolean
+lsm_svg_channel_selector_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmSvgChannelSelector *trait = (LsmSvgChannelSelector *) abstract_trait;
+
+	*trait = lsm_svg_channel_selector_from_string (string);
+
+	return *trait >= 0;
+}
+
+static char *
+lsm_svg_channel_selector_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmSvgChannelSelector *trait = (LsmSvgChannelSelector *) abstract_trait;
+
+	return g_strdup (lsm_svg_channel_selector_to_string (*trait));
+}
+
+const LsmTraitClass lsm_svg_channel_selector_trait_class = {
+	.size = sizeof (LsmSvgChannelSelector),
+	.from_string = lsm_svg_channel_selector_trait_from_string,
+	.to_string = lsm_svg_channel_selector_trait_to_string
+};

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

@@ -30,6 +30,11 @@
 
 G_BEGIN_DECLS
 
+typedef struct {
+	unsigned int n_values;
+	double *values;
+} LsmSvgVector;
+
 typedef struct {
 	LsmSvgAngleType type;
 	double angle;
@@ -72,30 +77,43 @@ typedef struct {
 	double b;
 } LsmSvgOneOrTwoDouble;
 
+typedef struct {
+	int a;
+	int b;
+} LsmSvgOneOrTwoInteger;
+
 extern const LsmTraitClass lsm_svg_angle_trait_class;
 extern const LsmTraitClass lsm_svg_blending_mode_trait_class;
 extern const LsmTraitClass lsm_svg_enable_background_trait_class;
+extern const LsmTraitClass lsm_svg_channel_selector_trait_class;
 extern const LsmTraitClass lsm_svg_color_trait_class;
+extern const LsmTraitClass lsm_svg_color_filter_type_trait_class;
 extern const LsmTraitClass lsm_svg_comp_op_trait_class;
 extern const LsmTraitClass lsm_svg_dash_array_trait_class;
 extern const LsmTraitClass lsm_svg_display_trait_class;
+extern const LsmTraitClass lsm_svg_edge_mode_trait_class;
 extern const LsmTraitClass lsm_svg_fill_rule_trait_class;
 extern const LsmTraitClass lsm_svg_font_stretch_trait_class;
 extern const LsmTraitClass lsm_svg_font_style_trait_class;
 extern const LsmTraitClass lsm_svg_font_weight_trait_class;
+extern const LsmTraitClass lsm_svg_one_or_two_integer_trait_class;
 extern const LsmTraitClass lsm_svg_length_trait_class;
 extern const LsmTraitClass lsm_svg_length_list_trait_class;
 extern const LsmTraitClass lsm_svg_line_join_trait_class;
 extern const LsmTraitClass lsm_svg_line_cap_trait_class;
 extern const LsmTraitClass lsm_svg_marker_units_trait_class;
 extern const LsmTraitClass lsm_svg_matrix_trait_class;
+extern const LsmTraitClass lsm_svg_morphology_operator_trait_class;
 extern const LsmTraitClass lsm_svg_one_or_two_double_trait_class;
 extern const LsmTraitClass lsm_svg_overflow_trait_class;
 extern const LsmTraitClass lsm_svg_paint_trait_class;
 extern const LsmTraitClass lsm_svg_pattern_units_trait_class;
 extern const LsmTraitClass lsm_svg_preserve_aspect_ratio_trait_class;
 extern const LsmTraitClass lsm_svg_spread_method_trait_class;
+extern const LsmTraitClass lsm_svg_stitch_tiles_trait_class;
 extern const LsmTraitClass lsm_svg_text_anchor_trait_class;
+extern const LsmTraitClass lsm_svg_turbulence_type_trait_class;
+extern const LsmTraitClass lsm_svg_vector_trait_class;
 extern const LsmTraitClass lsm_svg_visibility_trait_class;
 extern const LsmTraitClass lsm_svg_writing_mode_trait_class;
 

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

@@ -47,13 +47,19 @@ typedef struct _LsmSvgEllipseElement LsmSvgEllipseElement;
 typedef struct _LsmSvgFilterElement LsmSvgFilterElement;
 typedef struct _LsmSvgFilterPrimitive LsmSvgFilterPrimitive;
 typedef struct _LsmSvgFilterBlend LsmSvgFilterBlend;
+typedef struct _LsmSvgFilterColorMatrix LsmSvgFilterColorMatrix;
 typedef struct _LsmSvgFilterComposite LsmSvgFilterComposite;
+typedef struct _LsmSvgFilterConvolveMatrix LsmSvgFilterConvolveMatrix;
+typedef struct _LsmSvgFilterDisplacementMap LsmSvgFilterDisplacementMap;
 typedef struct _LsmSvgFilterFlood LsmSvgFilterFlood;
 typedef struct _LsmSvgFilterGaussianBlur LsmSvgFilterGaussianBlur;
+typedef struct _LsmSvgFilterImage LsmSvgFilterImage;
 typedef struct _LsmSvgFilterMerge LsmSvgFilterMerge;
 typedef struct _LsmSvgFilterMergeNode LsmSvgFilterMergeNode;
+typedef struct _LsmSvgFilterMorphology LsmSvgFilterMorphology;
 typedef struct _LsmSvgFilterOffset LsmSvgFilterOffset;
 typedef struct _LsmSvgFilterSpecularLighting LsmSvgFilterSpecularLighting;
+typedef struct _LsmSvgFilterTurbulence LsmSvgFilterTurbulence;
 typedef struct _LsmSvgFilterTile LsmSvgFilterTile;
 typedef struct _LsmSvgLineElement LsmSvgLineElement;
 typedef struct _LsmSvgPolylineElement LsmSvgPolylineElement;