[gegl/npd-squashed] libs, operations: Add n-point deformation
- From: Michael Henning <mhenning src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gegl/npd-squashed] libs, operations: Add n-point deformation
- Date: Sun, 17 Nov 2013 20:43:55 +0000 (UTC)
commit 7bd297888509d38889424393caaf0a31e2e2ca15
Author: Marek Dvoroznak <dvoromar gmail com>
Date: Wed Jun 26 23:32:22 2013 +0200
libs, operations: Add n-point deformation
.gitignore | 1 +
Makefile.am | 1 +
configure.ac | 9 +
gegl.pc.in | 2 +-
libs/npd/.gitignore | 6 +
libs/npd/Makefile.am | 40 +++
libs/npd/deformation.c | 207 +++++++++++++
libs/npd/deformation.h | 48 +++
libs/npd/graphics.c | 556 +++++++++++++++++++++++++++++++++++
libs/npd/graphics.h | 128 ++++++++
libs/npd/lattice_cut.c | 278 ++++++++++++++++++
libs/npd/lattice_cut.h | 40 +++
libs/npd/npd.h | 32 ++
libs/npd/npd_common.c | 619 +++++++++++++++++++++++++++++++++++++++
libs/npd/npd_common.h | 157 ++++++++++
libs/npd/npd_gegl.c | 68 +++++
libs/npd/npd_gegl.h | 33 ++
libs/npd/npd_math.c | 47 +++
libs/npd/npd_math.h | 58 ++++
operations/external/Makefile.am | 8 +
operations/external/npd.c | 329 +++++++++++++++++++++
po/POTFILES.in | 1 +
22 files changed, 2667 insertions(+), 1 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index 69c9757..d411137 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,3 +47,4 @@
cscope.files
cscope.out
/*.project
+/nbproject
diff --git a/Makefile.am b/Makefile.am
index 31f43be..588a324 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -7,6 +7,7 @@ SUBDIRS=\
libs \
opencl \
gegl \
+ libs/npd \
seamless-clone \
operations \
bin \
diff --git a/configure.ac b/configure.ac
index f567090..a6f780b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1074,6 +1074,14 @@ if test "x$have_p2tc" != "xyes"; then
AC_SUBST(P2TC_LIBS, "-L\$(top_builddir)/libs/poly2tri-c/poly2tri-c -lpoly2tri-c")
fi
+##################
+# Check for libnpd
+##################
+have_libnpd="yes (internal)"
+
+AC_SUBST(NPD_CFLAGS, "-I\$(top_srcdir)/libs")
+AC_SUBST(NPD_LIBS, "-L\$(top_builddir)/libs/npd -lgegl-npd-\$(GEGL_API_VERSION)")
+
#######################
# Check for other items
#######################
@@ -1139,6 +1147,7 @@ gegl/property-types/Makefile
gegl/opencl/Makefile
libs/Makefile
libs/rgbe/Makefile
+libs/npd/Makefile
libs/poly2tri-c/Makefile
libs/poly2tri-c/poly2tri-c/Makefile
libs/poly2tri-c/poly2tri-c/render/Makefile
diff --git a/gegl.pc.in b/gegl.pc.in
index 614bb78..f4b70fc 100644
--- a/gegl.pc.in
+++ b/gegl.pc.in
@@ -8,5 +8,5 @@ Name: GEGL
Description: Generic Graphics Library
Version: @GEGL_REAL_VERSION@
Requires: @GLIB_PACKAGES@ babl
-Libs: -L${libdir} -l PACKAGE_NAME@- GEGL_API_VERSION@
+Libs: -L${libdir} -l PACKAGE_NAME@- GEGL_API_VERSION@ -l PACKAGE_NAME@-npd- GEGL_API_VERSION@
Cflags: -I${includedir}/@PACKAGE_NAME -@GEGL_API_VERSION@
diff --git a/libs/npd/.gitignore b/libs/npd/.gitignore
new file mode 100644
index 0000000..4e0b01c
--- /dev/null
+++ b/libs/npd/.gitignore
@@ -0,0 +1,6 @@
+/Makefile
+/Makefile.in
+/.deps/
+/.libs/
+/*.lo
+/*.la
\ No newline at end of file
diff --git a/libs/npd/Makefile.am b/libs/npd/Makefile.am
new file mode 100644
index 0000000..080bb9d
--- /dev/null
+++ b/libs/npd/Makefile.am
@@ -0,0 +1,40 @@
+include $(top_srcdir)/operations/Makefile-common.am
+
+######################################################
+# A shared library for n-point image deformation API #
+######################################################
+
+GEGL_NPD_publicdir = $(includedir)/gegl-$(GEGL_API_VERSION)/npd
+
+GEGL_NPD_public_HEADERS = \
+ npd_common.h \
+ deformation.h \
+ npd_math.h \
+ graphics.h \
+ lattice_cut.h \
+ npd_gegl.h \
+ npd.h
+
+GEGL_NPD_SOURCES = \
+ $(GEGL_NPD_public_HEADERS) \
+ npd_common.c \
+ deformation.c \
+ npd_math.c \
+ graphics.c \
+ lattice_cut.c \
+ npd_gegl.c
+
+libgegl_npd_ GEGL_API_VERSION@_la_SOURCES = \
+ $(GEGL_NPD_public_HEADERS) \
+ $(GEGL_NPD_SOURCES)
+
+libgegl_npd_ GEGL_API_VERSION@_la_LDFLAGS = \
+ -avoid-version -export-dynamic $(no_undefined)
+
+libgegl_npd_ GEGL_API_VERSION@_la_CFLAGS = \
+ $(AM_CFLAGS)
+
+lib_LTLIBRARIES = libgegl-npd- GEGL_API_VERSION@.la
+
+libgegl_npd_ GEGL_API_VERSION@_la_LIBADD = \
+ $(libgegl)
diff --git a/libs/npd/deformation.c b/libs/npd/deformation.c
new file mode 100644
index 0000000..87f4362
--- /dev/null
+++ b/libs/npd/deformation.c
@@ -0,0 +1,207 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#include "deformation.h"
+#include <math.h>
+
+#define NPD_COMPUTE_CENTROID(suffix, arg1, arg2, WEIGHTS, accessor) \
+void \
+npd_compute_centroid_##suffix (gint num_of_points, \
+ arg1, \
+ arg2, \
+ NPDPoint *centroid) \
+{ \
+ gfloat x_sum = 0, y_sum = 0, weights_sum = 0; \
+ gint i; \
+ \
+ /* first compute sum of all values for each coordinate */ \
+ for (i = 0; i < num_of_points; ++i) \
+ { \
+ x_sum += (WEIGHTS) * points[i] accessor x; \
+ y_sum += (WEIGHTS) * points[i] accessor y; \
+ weights_sum += (WEIGHTS); \
+ } \
+ \
+ /* then compute mean */ \
+ centroid->x = x_sum / weights_sum; \
+ centroid->y = y_sum / weights_sum; \
+}
+
+NPD_COMPUTE_CENTROID (of_overlapping_points,
+ NPDPoint *points[],
+ gfloat weights[],
+ 1,
+ ->)
+NPD_COMPUTE_CENTROID (from_weighted_points,
+ NPDPoint points[],
+ gfloat weights[],
+ weights[i],
+ .)
+#undef NPD_COMPUTE_CENTROID
+
+void
+npd_compute_ARSAP_transformation (gint num_of_points,
+ NPDPoint reference_points[],
+ NPDPoint current_points[],
+ gfloat weights[],
+ gboolean ASAP)
+{
+ NPDPoint pc = {0, 0}, qc = {0, 0};
+ gfloat a = 0, b = 0, mu_part = 0, mu, r1, r2, x0, y0;
+ gint i;
+
+ /* p - points of reference pose */
+ npd_compute_centroid_from_weighted_points (num_of_points,
+ reference_points,
+ weights,
+ &pc);
+ /* q - points of current pose */
+ npd_compute_centroid_from_weighted_points (num_of_points,
+ current_points,
+ weights,
+ &qc);
+
+ /* get rotation */
+ for (i = 0; i < num_of_points; ++i)
+ {
+ gfloat px_minus_pcx = reference_points[i].x - pc.x;
+ gfloat py_minus_pcy = reference_points[i].y - pc.y;
+ gfloat qx_minus_qcx = current_points[i].x - qc.x;
+ gfloat qy_minus_qcy = current_points[i].y - qc.y;
+
+ a += weights[i]
+ * ((px_minus_pcx)
+ * (qx_minus_qcx)
+ + (py_minus_pcy)
+ * (qy_minus_qcy));
+ b += weights[i]
+ * ((px_minus_pcx)
+ * (qy_minus_qcy)
+ - (py_minus_pcy)
+ * (qx_minus_qcx));
+
+ mu_part += weights[i]
+ * ((px_minus_pcx)
+ * (px_minus_pcx)
+ + (py_minus_pcy)
+ * (py_minus_pcy));
+ }
+
+ mu = 1;
+ if (ASAP) mu = mu_part;
+ else mu = sqrt(a * a + b * b);
+
+ r1 = a / mu;
+ r2 = -b / mu;
+
+ /* get translation */
+ x0 = qc.x - ( r1 * pc.x + r2 * pc.y);
+ y0 = qc.y - (-r2 * pc.x + r1 * pc.y);
+
+ /* transform points */
+ for (i = 0; i < num_of_points; ++i)
+ {
+ if (!current_points[i].fixed)
+ {
+ current_points[i].x = r1 * reference_points[i].x
+ + r2 * reference_points[i].y + x0;
+ current_points[i].y = -r2 * reference_points[i].x
+ + r1 * reference_points[i].y + y0;
+ }
+ }
+}
+
+void
+npd_compute_ARSAP_transformations (NPDHiddenModel *hidden_model)
+{
+ gint i;
+
+ for (i = 0; i < hidden_model->num_of_bones; ++i)
+ {
+ NPDBone *reference_bones = &hidden_model->reference_bones[i];
+ NPDBone *current_bones = &hidden_model->current_bones[i];
+ npd_compute_ARSAP_transformation (reference_bones->num_of_points,
+ reference_bones->points,
+ current_bones->points,
+ current_bones->weights,
+ hidden_model->ASAP);
+ }
+}
+
+void
+npd_deform_model (NPDModel *model,
+ gint rigidity)
+{
+ gint i;
+ for (i = 0; i < rigidity; ++i)
+ {
+ npd_deform_model_once (model);
+ }
+}
+
+void
+npd_deform_model_once (NPDModel *model)
+{
+ gint i, j;
+
+ /* updates associated overlapping points according to this control point */
+ for (i = 0; i < model->control_points->len; ++i)
+ {
+ NPDControlPoint *cp = &g_array_index (model->control_points,
+ NPDControlPoint,
+ i);
+
+ for (j = 0; j < cp->overlapping_points->num_of_points; ++j)
+ {
+ npd_set_point_coordinates (cp->overlapping_points->points[j],
+ &cp->point);
+ }
+ }
+
+ npd_deform_hidden_model_once (model->hidden_model);
+}
+
+void
+npd_deform_hidden_model_once (NPDHiddenModel *hidden_model)
+{
+ gint i, j;
+ npd_compute_ARSAP_transformations (hidden_model);
+
+ /* overlapping points are not overlapping after the deformation,
+ so we have to move them to their centroid */
+ for (i = 0; i < hidden_model->num_of_overlapping_points; ++i)
+ {
+ NPDOverlappingPoints *list_of_ops
+ = &hidden_model->list_of_overlapping_points[i];
+ NPDPoint centroid;
+
+ npd_compute_centroid_of_overlapping_points (list_of_ops->num_of_points,
+ list_of_ops->points,
+ NULL,
+ ¢roid);
+
+ for (j = 0; j < list_of_ops->num_of_points; ++j)
+ {
+ list_of_ops->points[j]->x = centroid.x;
+ list_of_ops->points[j]->y = centroid.y;
+ }
+ }
+}
diff --git a/libs/npd/deformation.h b/libs/npd/deformation.h
new file mode 100644
index 0000000..c363e1d
--- /dev/null
+++ b/libs/npd/deformation.h
@@ -0,0 +1,48 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#ifndef __NPD_DEFORMATION_H__
+#define __NPD_DEFORMATION_H__
+
+#include "npd_common.h"
+
+void npd_compute_centroid_from_weighted_points
+ (gint num_of_points,
+ NPDPoint points[],
+ gfloat weights[],
+ NPDPoint *centroid);
+void npd_compute_centroid_of_overlapping_points
+ (gint num_of_points,
+ NPDPoint *points[],
+ gfloat weights[],
+ NPDPoint *centroid);
+void npd_compute_ARSAP_transformation (gint num_of_points,
+ NPDPoint reference_shape[],
+ NPDPoint current_shape[],
+ gfloat weights[],
+ gboolean ASAP);
+void npd_compute_ARSAP_transformations (NPDHiddenModel *model);
+void npd_deform_model (NPDModel *model,
+ gint rigidity);
+void npd_deform_model_once (NPDModel *model);
+void npd_deform_hidden_model_once (NPDHiddenModel *hidden_model);
+
+#endif /* __NPD_DEFORMATION_H__ */
diff --git a/libs/npd/graphics.c b/libs/npd/graphics.c
new file mode 100644
index 0000000..e5c5e5f
--- /dev/null
+++ b/libs/npd/graphics.c
@@ -0,0 +1,556 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#include "graphics.h"
+#include "glib.h"
+#include <math.h>
+#include "npd_math.h"
+#include "lattice_cut.h"
+#include <stdio.h>
+#include <string.h>
+
+void
+npd_create_mesh_from_image (NPDModel *model,
+ gint width,
+ gint height,
+ gint position_x,
+ gint position_y)
+{
+ gint square_size = model->mesh_square_size;
+ NPDImage *image = model->reference_image;
+ gint i, cy, cx, y, x, r, c, ow, oh;
+ NPDColor pixel_color = { 0, 0, 0, 0 };
+ GArray *squares;
+ gint *sq2id;
+ gboolean *empty_squares;
+ GList *tmp_ops = NULL;
+ GArray *ops = g_array_new (FALSE, FALSE, sizeof (NPDOverlappingPoints));
+ GList **edges;
+ NPDHiddenModel *hm = model->hidden_model;
+
+ /* create squares above the image */
+ width = ceil ((gfloat) width / square_size);
+ height = ceil ((gfloat) height / square_size);
+
+ squares = g_array_new (FALSE, FALSE, sizeof (NPDBone));
+ empty_squares = g_new0 (gboolean, width * height);
+ sq2id = g_new0 (gint, width * height);
+
+ i = 0;
+ for (cy = 0; cy < height; cy++)
+ for (cx = 0; cx < width; cx++)
+ {
+ gboolean is_empty = TRUE;
+
+ for (y = cy * square_size; y < (cy + 1) * square_size; y++)
+ for (x = cx * square_size; x < (cx + 1) * square_size; x++)
+ {
+ /* test of emptiness */
+ npd_get_pixel_color (image, x, y, &pixel_color);
+ if (!npd_is_color_transparent (&pixel_color))
+ {
+ is_empty = FALSE;
+ goto not_empty;
+ }
+ }
+
+#define NPD_SQ_ID cy * width + cx
+
+ not_empty:
+ if (!is_empty)
+ {
+ /* create a square */
+ NPDBone square;
+ npd_create_square (&square,
+ position_x + cx * square_size,
+ position_y + cy * square_size,
+ square_size, square_size);
+ g_array_append_val (squares, square);
+ sq2id[NPD_SQ_ID] = i;
+ i++;
+ }
+ else
+ empty_squares[NPD_SQ_ID] = TRUE;
+ }
+
+ /* find empty edges */
+ edges = npd_find_edges (model->reference_image, width, height, square_size);
+
+ /* create provisional overlapping points */
+#define NPD_ADD_P(op,r,c,point) \
+ if ((r) > -1 && (r) < (oh - 1) && (c) > -1 && (c) < (ow - 1) && \
+ edges[op] == NULL && !empty_squares[(r) * width + (c)]) \
+ { \
+ tmp_ops = g_list_append (tmp_ops, GINT_TO_POINTER ((r) * width + (c)));\
+ tmp_ops = g_list_append (tmp_ops, GINT_TO_POINTER (point)); \
+ num++; \
+ }
+
+ ow = width + 1; oh = height + 1;
+
+ for (r = 0; r < oh; r++)
+ for (c = 0; c < ow; c++)
+ {
+ gint index = r * ow + c, num = 0;
+ NPD_ADD_P (index, r - 1, c - 1, 2);
+ NPD_ADD_P (index, r - 1, c, 3);
+ NPD_ADD_P (index, r, c, 0);
+ NPD_ADD_P (index, r, c - 1, 1);
+ if (num > 0)
+ tmp_ops = g_list_insert_before (tmp_ops,
+ g_list_nth_prev (g_list_last (tmp_ops), 2 * num - 1),
+ GINT_TO_POINTER (num));
+ }
+#undef NPD_ADD_P
+
+ /* cut lattice's edges and continue with creating of provisional overlapping points */
+ tmp_ops = g_list_concat (tmp_ops, npd_cut_edges (edges, ow, oh));
+ for (i = 0; i < ow * oh; i++) g_list_free (edges[i]);
+ g_free (edges);
+
+ /* create model's bones */
+ hm->num_of_bones = squares->len;
+ hm->current_bones = (NPDBone*) (gpointer) squares->data;
+ g_array_free (squares, FALSE);
+
+ /* create model's overlapping points */
+ while (g_list_next (tmp_ops))
+ {
+ GPtrArray *ppts = g_ptr_array_new ();
+ gint count = GPOINTER_TO_INT (tmp_ops->data);
+ gint j = 0;
+
+ for (i = 0; i < count; i++)
+ {
+ gint sq, p;
+ tmp_ops = g_list_next (tmp_ops);
+ sq = GPOINTER_TO_INT (tmp_ops->data);
+ tmp_ops = g_list_next (tmp_ops);
+ p = GPOINTER_TO_INT (tmp_ops->data);
+
+ if (!empty_squares[sq])
+ {
+ g_ptr_array_add (ppts, &hm->current_bones[sq2id[sq]].points[p]);
+ j++;
+ }
+ }
+
+ if (j > 0)
+ {
+ NPDOverlappingPoints op;
+ op.num_of_points = j;
+ op.points = (NPDPoint**) ppts->pdata;
+ g_ptr_array_free (ppts, FALSE);
+ op.representative = op.points[0];
+ g_array_append_val (ops, op);
+ }
+ tmp_ops = g_list_next (tmp_ops);
+ }
+
+ g_list_free (tmp_ops);
+ g_free (empty_squares);
+ g_free (sq2id);
+
+ hm->num_of_overlapping_points = ops->len;
+ hm->list_of_overlapping_points = (NPDOverlappingPoints*) (gpointer) ops->data;
+ g_array_free (ops, FALSE);
+
+ /* create reference bones according to current bones */
+ hm->reference_bones = g_new (NPDBone, hm->num_of_bones);
+ for (i = 0; i < hm->num_of_bones; i++)
+ {
+ NPDBone *current_bone = &hm->current_bones[i];
+ NPDBone *reference_bone = &hm->reference_bones[i];
+ NPDPoint *current_points, *ref_points;
+ gint j, n = current_bone->num_of_points;
+
+ reference_bone->num_of_points = n;
+ reference_bone->points = g_new (NPDPoint, n);
+ memcpy (reference_bone->points, current_bone->points, n * sizeof (NPDPoint));
+ reference_bone->weights = current_bone->weights;
+
+ current_points = current_bone->points;
+ ref_points = reference_bone->points;
+
+ for (j = 0; j < n; j++)
+ {
+ current_points[j].current_bone = current_bone;
+ current_points[j].reference_bone = reference_bone;
+ ref_points[j].current_bone = current_bone;
+ ref_points[j].reference_bone = reference_bone;
+ ref_points[j].x = current_points[j].x - position_x;
+ ref_points[j].y = current_points[j].y - position_y;
+ current_points[j].counterpart = &ref_points[j];
+ ref_points[j].counterpart = ¤t_points[j];
+ }
+ }
+
+/*
+// could be useful later
+ gint j;
+ for (i = 0; i < hm->num_of_overlapping_points; i++)
+ for (j = 0; j < hm->list_of_overlapping_points[i].num_of_points; j++)
+ {
+ NPDPoint *p = hm->list_of_overlapping_points[i].points[j];
+ p->overlapping_points = &hm->list_of_overlapping_points[i];
+ p->counterpart->overlapping_points = &hm->list_of_overlapping_points[i];
+ }
+*/
+}
+
+void
+npd_draw_mesh (NPDModel *model,
+ NPDDisplay *display)
+{
+ NPDHiddenModel *hm = model->hidden_model;
+ gint i, j;
+
+ for (i = 0; i < hm->num_of_bones; i++)
+ {
+ NPDBone *bone = &hm->current_bones[i];
+ NPDPoint *first = &bone->points[0];
+ NPDPoint *p0, *p1 = NULL;
+
+ for (j = 1; j < bone->num_of_points; j++)
+ {
+ p0 = &bone->points[j - 1];
+ p1 = &bone->points[j];
+ npd_draw_line (display, p0->x, p0->y, p1->x, p1->y);
+ }
+ npd_draw_line (display, p1->x, p1->y, first->x, first->y);
+ }
+}
+
+gfloat
+npd_bilinear_interpolation (gfloat I0,
+ gfloat I1,
+ gfloat I2,
+ gfloat I3,
+ gfloat dx,
+ gfloat dy)
+{
+ return (I0 * (1 - dx) + I1 * dx) * (1 - dy) +
+ (I2 * (1 - dx) + I3 * dx) * dy;
+}
+
+void
+npd_bilinear_color_interpolation (NPDColor *I0,
+ NPDColor *I1,
+ NPDColor *I2,
+ NPDColor *I3,
+ gfloat dx,
+ gfloat dy,
+ NPDColor *out)
+{
+ out->r = npd_bilinear_interpolation (I0->r, I1->r, I2->r, I3->r, dx, dy);
+ out->g = npd_bilinear_interpolation (I0->g, I1->g, I2->g, I3->g, dx, dy);
+ out->b = npd_bilinear_interpolation (I0->b, I1->b, I2->b, I3->b, dx, dy);
+ out->a = npd_bilinear_interpolation (I0->a, I1->a, I2->a, I3->a, dx, dy);
+}
+
+gfloat
+npd_blend_band (gfloat src,
+ gfloat dst,
+ gfloat src_alpha,
+ gfloat dst_alpha,
+ gfloat out_alpha_recip)
+{
+ return (src * src_alpha +
+ dst * dst_alpha * (1 - src_alpha)) * out_alpha_recip;
+}
+
+void
+npd_blend_colors (NPDColor *src,
+ NPDColor *dst,
+ NPDColor *out_color)
+{
+#ifdef NPD_RGBA_FLOAT
+ gfloat src_A = src->a,
+ dst_A = dst->a;
+#else
+ gfloat src_A = src->a / 255.0,
+ dst_A = dst->a / 255.0;
+#endif
+ gfloat out_alpha = src_A + dst_A * (1 - src_A);
+ gfloat out_alpha_recip = 1 / out_alpha;
+
+ out_color->r = npd_blend_band (src->r, dst->r, src_A, dst_A, out_alpha_recip);
+ out_color->g = npd_blend_band (src->g, dst->g, src_A, dst_A, out_alpha_recip);
+ out_color->b = npd_blend_band (src->b, dst->b, src_A, dst_A, out_alpha_recip);
+#ifdef NPD_RGBA_FLOAT
+ out_color->a = out_alpha;
+#else
+ out_color->a = out_alpha * 255;
+#endif
+}
+
+void
+npd_texture_fill_triangle (gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ gint x3,
+ gint y3,
+ NPDMatrix *A,
+ NPDImage *input_image,
+ NPDImage *output_image,
+ NPDSettings settings)
+{
+ gint yA, yB, yC, xA, xB, xC;
+ gint tmp, y;
+ gint deltaXAB, deltaYAB;
+ gint deltaXBC, deltaYBC;
+ gint deltaXAC, deltaYAC;
+
+ gfloat slopeAB;
+ gfloat slopeBC;
+ gfloat slopeAC;
+
+ gfloat k, l;
+ gfloat slope1, slope2, slope3, slope4;
+
+ if (y1 == y2 && x1 > x2)
+ {
+ tmp = y1; y1 = y2; y2 = tmp;
+ tmp = x1; x1 = x2; x2 = tmp;
+ }
+ if (y1 == y3 && x1 > x3)
+ {
+ tmp = y1; y1 = y3; y3 = tmp;
+ tmp = x1; x1 = x3; x3 = tmp;
+ }
+ if (y2 == y3 && x2 > x3)
+ {
+ tmp = y2; y2 = y3; y3 = tmp;
+ tmp = x2; x2 = x3; x3 = tmp;
+ }
+
+ if (y1 <= y2)
+ {
+ if (y2 <= y3)
+ {
+ /* y1 <= y2 <= y3 */
+ yA = y1; yB = y2; yC = y3;
+ xA = x1; xB = x2; xC = x3;
+ }
+ else if (y1 <= y3)
+ {
+ /* y1 <= y3 < y2 */
+ yA = y1; yB = y3; yC = y2;
+ xA = x1; xB = x3; xC = x2;
+ }
+ else
+ {
+ /* y3 < y1 < y2 */
+ yA = y3; yB = y1; yC = y2;
+ xA = x3; xB = x1; xC = x2;
+ }
+ }
+ else
+ {
+ if (y1 <= y3)
+ {
+ /* y2 < y1 <= y3 */
+ yA = y2; yB = y1; yC = y3;
+ xA = x2; xB = x1; xC = x3;
+ }
+ else if (y2 <= y3)
+ {
+ /* y2 <= y3 < y1 */
+ yA = y2; yB = y3; yC = y1;
+ xA = x2; xB = x3; xC = x1;
+ }
+ else
+ {
+ /* y3 < y2 < y1 */
+ yA = y3; yB = y2; yC = y1;
+ xA = x3; xB = x2; xC = x1;
+ }
+ }
+
+ deltaXAB = xB - xA, deltaYAB = yB - yA;
+ deltaXBC = xC - xB, deltaYBC = yC - yB;
+ deltaXAC = xC - xA, deltaYAC = yC - yA;
+
+ slopeBC = (deltaYBC == 0 ? 0 : (gfloat) deltaXBC / deltaYBC);
+ slopeAC = (deltaYAC == 0 ? 0 : (gfloat) deltaXAC / deltaYAC);
+
+ if (deltaYAB == 0)
+ {
+ slopeAB = 0;
+ k = xA;
+ l = xB;
+
+ slope1 = slopeAB;
+ slope2 = slopeAC;
+ slope3 = slopeAC;
+ slope4 = slopeBC;
+ }
+ else
+ {
+ slopeAB = (gfloat) deltaXAB / deltaYAB;
+ k = xA;
+ l = xA;
+
+ if (slopeAB > slopeAC)
+ {
+ slope1 = slopeAC;
+ slope2 = slopeAB;
+ slope3 = slopeAC;
+ slope4 = slopeBC;
+ }
+ else
+ {
+ slope1 = slopeAB;
+ slope2 = slopeAC;
+ slope3 = slopeBC;
+ slope4 = slopeAC;
+ }
+ }
+
+ for (y = yA; y < yB; y++)
+ {
+ npd_draw_texture_line ((gint) round (k), (gint) round (l),
+ y, A,
+ input_image, output_image,
+ settings);
+ k += slope1;
+ l += slope2;
+ }
+
+ for (y = yB; y <= yC; y++)
+ {
+ npd_draw_texture_line ((gint) round (k), (gint) round (l),
+ y, A,
+ input_image, output_image,
+ settings);
+ k += slope3;
+ l += slope4;
+ }
+}
+
+void
+npd_texture_quadrilateral (NPDBone *reference_bone,
+ NPDBone *current_bone,
+ NPDImage *input_image,
+ NPDImage *output_image,
+ NPDSettings settings)
+{
+ /* p1 are points of domain, p2 are points of codomain */
+ NPDPoint *p1 = current_bone->points;
+ NPDPoint *p2 = reference_bone->points;
+
+ NPDMatrix *A = NULL;
+ npd_new_matrix (&A);
+
+ npd_compute_affinity (&p1[0], &p1[1], &p1[2],
+ &p2[0], &p2[1], &p2[2], A);
+ npd_texture_fill_triangle ((gint) p1[0].x, (gint) p1[0].y,
+ (gint) p1[1].x, (gint) p1[1].y,
+ (gint) p1[2].x, (gint) p1[2].y,
+ A, input_image, output_image,
+ settings);
+
+ npd_compute_affinity (&p1[0], &p1[2], &p1[3],
+ &p2[0], &p2[2], &p2[3], A);
+ npd_texture_fill_triangle ((gint) p1[0].x, (gint) p1[0].y,
+ (gint) p1[2].x, (gint) p1[2].y,
+ (gint) p1[3].x, (gint) p1[3].y,
+ A, input_image, output_image,
+ settings);
+
+ npd_destroy_matrix (&A);
+}
+
+void
+npd_draw_texture_line (gint x1,
+ gint x2,
+ gint y,
+ NPDMatrix *A,
+ NPDImage *input_image,
+ NPDImage *output_image,
+ NPDSettings settings)
+{
+ gint x, fx, fy;
+ gfloat dx, dy;
+
+ for (x = x1; x <= x2; x++)
+ {
+ NPDPoint p, q;
+ NPDColor I0, interpolated, *final;
+
+ q.x = x; q.y = y;
+ npd_apply_transformation (A, &q, &p);
+
+ fx = floor (p.x);
+ fy = floor (p.y);
+
+ npd_get_pixel_color (input_image, fx, fy, &I0);
+ final = &I0;
+
+ /* bilinear interpolation */
+ if (settings & NPD_BILINEAR_INTERPOLATION)
+ {
+ NPDColor I1, I2, I3;
+
+ dx = p.x - fx;
+ dy = p.y - fy;
+
+ npd_get_pixel_color (input_image, fx + 1, fy, &I1);
+ npd_get_pixel_color (input_image, fx, fy + 1, &I2);
+ npd_get_pixel_color (input_image, fx + 1, fy + 1, &I3);
+ npd_bilinear_color_interpolation (&I0, &I1, &I2, &I3, dx, dy, &interpolated);
+ final = &interpolated;
+ }
+
+ /* alpha blending */
+ if (settings & NPD_ALPHA_BLENDING)
+ {
+ NPDColor dest;
+ npd_get_pixel_color (output_image, x, y, &dest);
+ npd_blend_colors (final, &dest, final);
+ }
+
+ npd_set_pixel_color (output_image, x, y, final);
+ }
+}
+
+gboolean
+npd_compare_colors (NPDColor *c1,
+ NPDColor *c2)
+{
+ if (npd_equal_floats (c1->r, c2->r) &&
+ npd_equal_floats (c1->g, c2->g) &&
+ npd_equal_floats (c1->b, c2->b) &&
+ npd_equal_floats (c1->a, c2->a))
+ return TRUE;
+
+ return FALSE;
+}
+
+gboolean
+npd_is_color_transparent (NPDColor *color)
+{
+ if (npd_equal_floats (color->a, 0.0))
+ return TRUE;
+
+ return FALSE;
+}
diff --git a/libs/npd/graphics.h b/libs/npd/graphics.h
new file mode 100644
index 0000000..db174fc
--- /dev/null
+++ b/libs/npd/graphics.h
@@ -0,0 +1,128 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#ifndef __NPD_GRAPHICS_H__
+#define __NPD_GRAPHICS_H__
+
+#include "npd_common.h"
+
+//#define NPD_RGBA_FLOAT
+
+struct _NPDColor {
+#ifdef NPD_RGBA_FLOAT
+ gfloat r;
+ gfloat g;
+ gfloat b;
+ gfloat a;
+#else
+ guint8 r;
+ guint8 g;
+ guint8 b;
+ guint8 a;
+#endif
+};
+
+typedef enum
+{
+ NPD_BILINEAR_INTERPOLATION = 1,
+ NPD_ALPHA_BLENDING = 1 << 1
+} NPDSettings;
+
+void npd_create_model_from_image (NPDModel *model,
+ NPDImage *image,
+ gint square_size);
+void npd_create_mesh_from_image (NPDModel *model,
+ gint width,
+ gint height,
+ gint position_x,
+ gint position_y);
+void npd_draw_model (NPDModel *model,
+ NPDDisplay *display);
+void npd_draw_mesh (NPDModel *model,
+ NPDDisplay *display);
+
+gboolean npd_load_image (NPDImage *image,
+ const char *path);
+void npd_destroy_image (NPDImage *image);
+//void npd_draw_image (NPDImage *image);
+void npd_texture_fill_triangle (gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ gint x3,
+ gint y3,
+ NPDMatrix *A,
+ NPDImage *input_image,
+ NPDImage *output_image,
+ NPDSettings settings);
+void npd_texture_quadrilateral (NPDBone *reference_bone,
+ NPDBone *current_bone,
+ NPDImage *input_image,
+ NPDImage *output_image,
+ NPDSettings settings);
+void npd_draw_texture_line (gint x1,
+ gint x2,
+ gint y,
+ NPDMatrix *A,
+ NPDImage *input_image,
+ NPDImage *output_image,
+ NPDSettings settings);
+void (*npd_draw_line) (NPDDisplay *display,
+ gfloat x0,
+ gfloat y0,
+ gfloat x1,
+ gfloat y1);
+gfloat npd_bilinear_interpolation (gfloat I0,
+ gfloat I1,
+ gfloat I2,
+ gfloat I3,
+ gfloat dx,
+ gfloat dy);
+void npd_bilinear_color_interpolation (NPDColor *I0,
+ NPDColor *I1,
+ NPDColor *I2,
+ NPDColor *I3,
+ gfloat dx,
+ gfloat dy,
+ NPDColor *out);
+gfloat npd_blend_band (gfloat src,
+ gfloat dst,
+ gfloat src_alpha,
+ gfloat dest_alpha,
+ gfloat out_alpha);
+void npd_blend_colors (NPDColor *src,
+ NPDColor *dst,
+ NPDColor *out_color);
+void (*npd_get_pixel_color) (NPDImage *image,
+ gint x,
+ gint y,
+ NPDColor *color);
+void (*npd_set_pixel_color) (NPDImage *image,
+ gint x,
+ gint y,
+ NPDColor *color);
+gboolean npd_compare_colors (NPDColor *c1,
+ NPDColor *c2);
+gboolean npd_is_color_transparent (NPDColor *color);
+gboolean npd_init_display (NPDDisplay *display);
+void npd_destroy_display (NPDDisplay *display);
+
+#endif /*__NPD_GRAPHICS_H__ */
diff --git a/libs/npd/lattice_cut.c b/libs/npd/lattice_cut.c
new file mode 100644
index 0000000..d8e7f72
--- /dev/null
+++ b/libs/npd/lattice_cut.c
@@ -0,0 +1,278 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#include "lattice_cut.h"
+#include "npd_common.h"
+#include "graphics.h"
+#include <glib.h>
+#include "npd_math.h"
+
+#define NPD_SWAP_INTS(i,j) { gint tmp = i; i = j; j = tmp; }
+
+/* only works for straight lines */
+gboolean
+npd_is_edge_empty (NPDImage *image,
+ gint X1,
+ gint Y1,
+ gint X2,
+ gint Y2)
+{
+ gint x, y;
+ NPDColor color;
+
+ if (Y1 > Y2) NPD_SWAP_INTS (Y1, Y2);
+ if (X1 > X2) NPD_SWAP_INTS (X1, X2);
+
+ for (y = Y1; y <= Y2; y++)
+ for (x = X1; x <= X2; x++)
+ {
+ npd_get_pixel_color (image, x, y, &color);
+ if (!npd_is_color_transparent (&color))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+GList**
+npd_find_edges (NPDImage *image,
+ gint count_x,
+ gint count_y,
+ gint square_size)
+{
+ gint i, j;
+ gint ow = count_x + 1,
+ oh = count_y + 1;
+ GList **empty_edges = g_new0 (GList*, ow * oh);
+
+ for (j = 1; j <= count_y; j++)
+ for (i = 1; i <= count_x; i++)
+ {
+#define NPD_TEST_EMPTY(from_op_x,from_op_y,to_op_x,to_op_y) \
+ if (npd_is_edge_empty (image, \
+ (from_op_x) * square_size, (from_op_y) * square_size, \
+ (to_op_x) * square_size, (to_op_y) * square_size)) \
+ { \
+ gint from_op_id = (from_op_y) * ow + (from_op_x), \
+ to_op_id = (to_op_y) * ow + (to_op_x); \
+ empty_edges[from_op_id] = g_list_append (empty_edges[from_op_id], \
+ GINT_TO_POINTER (to_op_id)); \
+ empty_edges[to_op_id] = g_list_append (empty_edges[to_op_id], \
+ GINT_TO_POINTER (from_op_id)); \
+ }
+
+ if (j != count_y) NPD_TEST_EMPTY (i, j, i - 1, j);
+ if (i != count_x) NPD_TEST_EMPTY (i, j, i, j - 1);
+#undef NPD_TEST_EMPTY
+ }
+
+ return empty_edges;
+}
+
+GList*
+npd_cut_edges (GList **edges,
+ gint ow,
+ gint oh)
+{
+ gint i, r, col, width = ow - 1;
+ GList *ops = NULL;
+ gint neighbors[4];
+
+ for (r = 0; r < oh; r++)
+ for (col = 0; col < ow; col++)
+ {
+ gint index = r * ow + col;
+ GList *op = edges[index];
+ gint num_of_neighbors = g_list_length (op);
+
+ if (num_of_neighbors == 0) continue;
+
+#define NPD_ADD_COUNT(count) ops = g_list_append (ops, GINT_TO_POINTER (count))
+#define NPD_ADD_P(r,col,point) \
+ if ((r) > -1 && (r) < (oh - 1) && (col) > -1 && (col) < (ow - 1)) \
+ { \
+ ops = g_list_append (ops, GINT_TO_POINTER ((r) * width + (col))); \
+ ops = g_list_append (ops, GINT_TO_POINTER (point)); \
+ }
+
+ for (i = 0; i < num_of_neighbors; i++)
+ neighbors[i] = GPOINTER_TO_INT (g_list_nth_data (op, i));
+
+ if (num_of_neighbors == 1)
+ {
+ gboolean border = FALSE;
+ if (r == 0 || col == 0 || r == (oh - 1) || col == (ow - 1))
+ border = TRUE;
+
+ if (border) NPD_ADD_COUNT (1);
+ else NPD_ADD_COUNT (4);
+ NPD_ADD_P (r - 1, col - 1, 2);
+ NPD_ADD_P (r - 1, col, 3);
+ NPD_ADD_P (r, col, 0);
+ NPD_ADD_P (r, col - 1, 1);
+ if (border)
+ ops = g_list_insert_before (ops,
+ g_list_nth_prev (g_list_last (ops), 1),
+ GINT_TO_POINTER (1));
+#undef NPD_ADD_P
+ }
+ else
+ if (num_of_neighbors == 2)
+ {
+ gboolean x_differs = FALSE, y_differs = FALSE;
+ gint a, b, c, d;
+
+#define NPD_OP_X(op) ((op) % ow)
+#define NPD_OP_Y(op) ((op) / ow)
+
+ if (NPD_OP_X (neighbors[0]) != NPD_OP_X (neighbors[1])) x_differs = TRUE;
+ if (NPD_OP_Y (neighbors[0]) != NPD_OP_Y (neighbors[1])) y_differs = TRUE;
+
+ if (x_differs && y_differs)
+ {
+ /* corner */
+ gint B = neighbors[0], C = neighbors[1];
+
+ if (NPD_OP_X (index) == NPD_OP_X (neighbors[0]))
+ { B = neighbors[1]; C = neighbors[0]; }
+
+ if (NPD_OP_Y (index) < NPD_OP_Y (C))
+ {
+ if (NPD_OP_X (index) < NPD_OP_X (B))
+ { /* IV. quadrant */ a = 2; b = 3; c = 1; d = 0; }
+ else
+ { /* III. quadrant */ a = 2; b = 3; c = 0; d = 1; }
+ }
+ else
+ {
+ if (NPD_OP_X (index) < NPD_OP_X (B))
+ { /* I. quadrant */ a = 2; b = 0; c = 1; d = 3; }
+ else
+ { /* II. quadrant */ a = 0; b = 3; c = 1; d = 2; }
+ }
+
+#define NPD_OP2SQ(op) (op == 0 ? ( r * width + col) : \
+ (op == 1 ? ( r * width + col - 1) : \
+ (op == 2 ? ((r - 1) * width + col - 1) : \
+ ((r - 1) * width + col))))
+#define NPD_ADD_P(square,point) \
+ ops = g_list_append (ops, GINT_TO_POINTER (square)); \
+ ops = g_list_append (ops, GINT_TO_POINTER (point));
+
+ NPD_ADD_COUNT (3);
+ NPD_ADD_P (NPD_OP2SQ (a), a);
+ NPD_ADD_P (NPD_OP2SQ (b), b);
+ NPD_ADD_P (NPD_OP2SQ (c), c);
+ NPD_ADD_COUNT (1);
+ NPD_ADD_P (NPD_OP2SQ (d), d);
+ }
+ else
+ {
+ /* segment */
+ a = 0; b = 1; c = 2; d = 3;
+ if (y_differs) { a = 1; b = 2; c = 0; d = 3; }
+
+ NPD_ADD_COUNT (2);
+ NPD_ADD_P (NPD_OP2SQ (a), a);
+ NPD_ADD_P (NPD_OP2SQ (b), b);
+ NPD_ADD_COUNT (2);
+ NPD_ADD_P (NPD_OP2SQ (c), c);
+ NPD_ADD_P (NPD_OP2SQ (d), d);
+ }
+ }
+ else
+ if (num_of_neighbors == 3)
+ {
+ gint B = neighbors[0], C = neighbors[1], D = neighbors[2];
+ gint a = 2, b = 1, c = 3, d = 0;
+
+ if ((NPD_OP_X (B) != NPD_OP_X (C)) && (NPD_OP_Y (B) != NPD_OP_Y (C)))
+ {
+ /* B and C form corner */
+ B = neighbors[2]; D = neighbors[0]; /* swap B and D */
+
+ if ((NPD_OP_X (B) != NPD_OP_X (C)) && (NPD_OP_Y (B) != NPD_OP_Y (C)))
+ {
+ /* (new) B and C form corner */
+ C = neighbors[0]; D = neighbors[1]; /* swap C and D */
+ }
+ }
+
+ /* B and C form segment */
+ if (NPD_OP_X (B) == NPD_OP_X (C))
+ {
+ if (NPD_OP_X (B) < NPD_OP_X (D))
+ {
+ /* |_
+ | */
+ a = 2; b = 1; c = 3; d = 0;
+ }
+ else
+ {
+ /* _|
+ | */
+ a = 3; b = 0; c = 2; d = 1;
+ }
+ }
+ else if (NPD_OP_Y (B) == NPD_OP_Y (C))
+ {
+ if (NPD_OP_Y (B) < NPD_OP_Y (D))
+ {
+ /* _ _
+ | */
+ a = 2; b = 3; c = 1; d = 0;
+ }
+ else
+ {
+ /* _|_ */
+ a = 1; b = 0; c = 2; d = 3;
+ }
+ }
+
+ NPD_ADD_COUNT (2);
+ NPD_ADD_P (NPD_OP2SQ (a), a);
+ NPD_ADD_P (NPD_OP2SQ (b), b);
+ NPD_ADD_COUNT (1);
+ NPD_ADD_P (NPD_OP2SQ (c), c);
+ NPD_ADD_COUNT (1);
+ NPD_ADD_P (NPD_OP2SQ (d), d);
+ }
+ else
+ if (num_of_neighbors == 4)
+ {
+ NPD_ADD_COUNT (1);
+ NPD_ADD_P (NPD_OP2SQ (0), 0);
+ NPD_ADD_COUNT (1);
+ NPD_ADD_P (NPD_OP2SQ (1), 1);
+ NPD_ADD_COUNT (1);
+ NPD_ADD_P (NPD_OP2SQ (2), 2);
+ NPD_ADD_COUNT (1);
+ NPD_ADD_P (NPD_OP2SQ (3), 3);
+ }
+ }
+#undef NPD_ADD_P
+#undef NPD_OP2SQ
+#undef NPD_OP_X
+#undef NPD_OP_Y
+#undef NPD_ADD_COUNT
+
+ return ops;
+}
diff --git a/libs/npd/lattice_cut.h b/libs/npd/lattice_cut.h
new file mode 100644
index 0000000..b331ba3
--- /dev/null
+++ b/libs/npd/lattice_cut.h
@@ -0,0 +1,40 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#ifndef __REFINE_H__
+#define __REFINE_H__
+
+#include "npd_common.h"
+
+gboolean npd_is_edge_empty (NPDImage *image,
+ gint X1,
+ gint Y1,
+ gint X2,
+ gint Y2);
+GList** npd_find_edges (NPDImage *image,
+ gint count_x,
+ gint count_y,
+ gint square_size);
+GList* npd_cut_edges (GList **edges,
+ gint ow,
+ gint oh);
+
+#endif /* __REFINE_H__ */
diff --git a/libs/npd/npd.h b/libs/npd/npd.h
new file mode 100644
index 0000000..654c1ce
--- /dev/null
+++ b/libs/npd/npd.h
@@ -0,0 +1,32 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#ifndef __NPD_H__
+#define __NPD_H__
+
+#include "npd_common.h"
+#include "graphics.h"
+#include "deformation.h"
+#include "npd_math.h"
+#include "lattice_cut.h"
+
+#endif /* __NPD_H__ */
+
diff --git a/libs/npd/npd_common.c b/libs/npd/npd_common.c
new file mode 100644
index 0000000..1b427b9
--- /dev/null
+++ b/libs/npd/npd_common.c
@@ -0,0 +1,619 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#include "npd_common.h"
+#include "npd_math.h"
+#include <math.h>
+#include <glib.h>
+#include <glib/gprintf.h>
+
+gint npd_int_sort_function_descending (gconstpointer a,
+ gconstpointer b);
+
+void
+npd_init_model (NPDModel *model)
+{
+ NPDHiddenModel *hidden_model;
+ GArray *control_points;
+
+ /* init hidden model */
+ hidden_model = g_new (NPDHiddenModel, 1);
+ model->hidden_model = hidden_model;
+ hidden_model->ASAP = FALSE;
+ hidden_model->MLS_weights = FALSE;
+ hidden_model->MLS_weights_alpha = 1;
+ hidden_model->num_of_bones = 0;
+ hidden_model->num_of_overlapping_points = 0;
+
+ /* init control points */
+ control_points = g_array_new (FALSE, FALSE, sizeof (NPDControlPoint));
+ model->control_points = control_points;
+ model->control_point_radius = 6;
+ model->control_points_visible = TRUE;
+
+ /* init other */
+ model->mesh_visible = TRUE;
+ model->texture_visible = TRUE;
+}
+
+void
+npd_destroy_hidden_model (NPDHiddenModel *hm)
+{
+ gint i;
+ for (i = 0; i < hm->num_of_overlapping_points; i++)
+ {
+ g_free (hm->list_of_overlapping_points[i].points);
+ }
+
+ g_free (hm->list_of_overlapping_points);
+
+ for (i = 0; i < hm->num_of_bones; i++)
+ {
+ g_free (hm->current_bones[i].weights);
+ g_free (hm->current_bones[i].points);
+ g_free (hm->reference_bones[i].points);
+ }
+
+ g_free (hm->current_bones);
+ g_free (hm->reference_bones);
+}
+
+void
+npd_destroy_model (NPDModel *model)
+{
+ /* destroy control points */
+ g_array_free (model->control_points, TRUE);
+
+ /* destroy hidden model */
+ npd_destroy_hidden_model (model->hidden_model);
+ g_free (model->hidden_model);
+}
+
+/**
+ * Finds nearest (to specified position) overlapping points, creates a new
+ * control point at the position of overlapping points and assigns them to the
+ * control point.
+ *
+ * @param model
+ * @param coord specified position
+ * @return pointer to a newly created control point or NULL when there already
+ * is a control point at the position of nearest overlapping points
+ */
+NPDControlPoint*
+npd_add_control_point (NPDModel *model,
+ NPDPoint *coord)
+{
+ gint num_of_ops, i, closest;
+ gfloat min, current;
+ NPDOverlappingPoints *list_of_ops;
+ NPDControlPoint cp;
+ NPDPoint *closest_point;
+
+ list_of_ops = model->hidden_model->list_of_overlapping_points;
+ num_of_ops = model->hidden_model->num_of_overlapping_points;
+
+ /* find closest overlapping points */
+ closest = 0;
+ min = npd_SED (coord, list_of_ops[0].representative);
+
+ for (i = 1; i < num_of_ops; i++)
+ {
+ NPDPoint *op = list_of_ops[i].representative;
+ current = npd_SED(coord, op);
+
+ if (min > current)
+ {
+ closest = i;
+ min = current;
+ }
+ }
+
+ closest_point = list_of_ops[closest].representative;
+
+ /* we want to create a new control point only when there isn't any
+ * control point associated to the closest overlapping points - i.e. we
+ * don't want to have two (or more) different control points manipulating
+ * one overlapping points */
+ if (!npd_get_control_point_at (model, closest_point))
+ {
+ cp.point.weight = closest_point->weight;
+ cp.overlapping_points = &list_of_ops[closest];
+
+ npd_set_point_coordinates (&cp.point, closest_point);
+ g_array_append_val (model->control_points, cp);
+
+ if (model->hidden_model->MLS_weights)
+ npd_compute_MLS_weights (model);
+
+ return &g_array_index (model->control_points,
+ NPDControlPoint,
+ model->control_points->len - 1);
+ }
+ else
+ return NULL;
+}
+
+/**
+ * Beware, when you use this function on previously stored pointers to control
+ * points it needn't to work properly, because g_array_remove_index can
+ * preserve pointers but change (move) data.
+ * In this situation use npd_remove_control_points instead.
+ */
+void
+npd_remove_control_point (NPDModel *model,
+ NPDControlPoint *control_point)
+{
+ gint i;
+ NPDControlPoint *cp;
+
+ for (i = 0; i < model->control_points->len; i++)
+ {
+ cp = &g_array_index (model->control_points, NPDControlPoint, i);
+
+ if (cp == control_point)
+ {
+ npd_set_control_point_weight (cp, 1.0);
+ g_array_remove_index (model->control_points, i);
+
+ if (model->hidden_model->MLS_weights)
+ npd_compute_MLS_weights (model);
+
+ return;
+ }
+ }
+}
+
+gint
+npd_int_sort_function_descending (gconstpointer a,
+ gconstpointer b)
+{
+ return GPOINTER_TO_INT (b) - GPOINTER_TO_INT (a);
+}
+
+void
+npd_remove_control_points (NPDModel *model,
+ GList *control_points)
+{
+ gint i;
+ NPDControlPoint *cp;
+ GList *indices = NULL;
+
+ /* first we find indices of control points we want to remove */
+ while (control_points != NULL)
+ {
+ for (i = 0; i < model->control_points->len; i++)
+ {
+ cp = &g_array_index (model->control_points, NPDControlPoint, i);
+ if (cp == control_points->data)
+ {
+ npd_set_control_point_weight (cp, 1.0);
+ indices = g_list_insert_sorted (indices,
+ GINT_TO_POINTER (i),
+ npd_int_sort_function_descending);
+ }
+ }
+
+ control_points = g_list_next (control_points);
+ }
+
+ /* indices are sorted in descending order, so we can simply iterate over them
+ * and remove corresponding control points one by one */
+ while (indices != NULL)
+ {
+ g_array_remove_index (model->control_points, GPOINTER_TO_INT (indices->data));
+ indices = g_list_next (indices);
+ }
+
+ if (model->hidden_model->MLS_weights)
+ npd_compute_MLS_weights (model);
+
+ g_list_free (indices);
+}
+
+void
+npd_remove_all_control_points (NPDModel *model)
+{
+ g_array_remove_range (model->control_points,
+ 0,
+ model->control_points->len);
+}
+
+void
+npd_set_control_point_weight (NPDControlPoint *cp,
+ gfloat weight)
+{
+ npd_set_overlapping_points_weight(cp->overlapping_points, weight);
+}
+
+gboolean
+npd_equal_coordinates (NPDPoint *p1,
+ NPDPoint *p2)
+{
+ return npd_equal_coordinates_epsilon(p1, p2, NPD_EPSILON);
+}
+
+gboolean
+npd_equal_coordinates_epsilon (NPDPoint *p1,
+ NPDPoint *p2,
+ gfloat epsilon)
+{
+ if (npd_equal_floats_epsilon (p1->x, p2->x, epsilon) &&
+ npd_equal_floats_epsilon (p1->y, p2->y, epsilon))
+ {
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+NPDControlPoint*
+npd_get_control_point_with_radius_at (NPDModel *model,
+ NPDPoint *coord,
+ gfloat radius)
+{
+ gint i;
+ for (i = 0; i < model->control_points->len; i++)
+ {
+ NPDControlPoint *cp = &g_array_index (model->control_points,
+ NPDControlPoint,
+ i);
+ if (npd_equal_coordinates_epsilon (&cp->point,
+ coord,
+ radius))
+ {
+ return cp;
+ }
+ }
+
+ return NULL;
+}
+
+NPDControlPoint*
+npd_get_control_point_at (NPDModel *model,
+ NPDPoint *coord)
+{
+ return npd_get_control_point_with_radius_at (model,
+ coord,
+ model->control_point_radius);
+}
+
+void
+npd_create_square (NPDBone *square,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ gint i;
+ square->num_of_points = 4;
+ square->points = g_new (NPDPoint, 4);
+ square->weights = g_new (gfloat, 4);
+
+ square->points[0].x = x; square->points[0].y = y;
+ square->points[1].x = x + width; square->points[1].y = y;
+ square->points[2].x = x + width; square->points[2].y = y + height;
+ square->points[3].x = x; square->points[3].y = y + height;
+
+ for (i = 0; i < 4; i++)
+ {
+ square->weights[i] = 1.0;
+ square->points[i].weight = &square->weights[i];
+ square->points[i].fixed = FALSE;
+ square->points[i].index = i;
+ }
+}
+
+void
+npd_create_list_of_overlapping_points (NPDHiddenModel *hm)
+{
+ gint i, j, num_of_bones;
+ NPDBone *bone;
+ NPDPoint *point;
+ GPtrArray *list_of_ops;
+ GHashTable *coords_to_cluster;
+
+ list_of_ops = g_ptr_array_new ();
+ num_of_bones = hm->num_of_bones;
+ coords_to_cluster = g_hash_table_new_full
+ (g_str_hash, g_str_equal,
+ g_free, (GDestroyNotify) g_hash_table_destroy);
+
+ for (i = 0; i < num_of_bones; i++)
+ {
+ bone = &hm->current_bones[i];
+
+ for (j = 0; j < bone->num_of_points; j++)
+ {
+ point = &bone->points[j];
+ add_point_to_suitable_cluster (coords_to_cluster,
+ point,
+ list_of_ops);
+ }
+ }
+
+ hm->list_of_overlapping_points = g_new (NPDOverlappingPoints,
+ list_of_ops->len);
+ hm->num_of_overlapping_points = list_of_ops->len;
+
+ for (i = 0; i < list_of_ops->len; i++)
+ {
+ GPtrArray *op = g_ptr_array_index (list_of_ops, i);
+ hm->list_of_overlapping_points[i].points = (NPDPoint**) op->pdata;
+ hm->list_of_overlapping_points[i].num_of_points = op->len;
+ hm->list_of_overlapping_points[i].representative =
+ hm->list_of_overlapping_points[i].points[0];
+
+ for (j = 0; j < op->len; j++)
+ {
+ NPDPoint *p = hm->list_of_overlapping_points[i].points[j];
+ p->overlapping_points = &hm->list_of_overlapping_points[i];
+ p->counterpart->overlapping_points = &hm->list_of_overlapping_points[i];
+ }
+
+ g_ptr_array_free (op, FALSE); /* we want to preserve the underlying
+ array */
+ }
+
+ /* free allocated memory */
+ g_hash_table_destroy (coords_to_cluster);
+ g_ptr_array_free (list_of_ops, TRUE);
+}
+
+#define NPD_FLOAT_TO_STRING(name_of_string, value) \
+/* must be freed */ \
+name_of_string = g_new (gchar, 10); \
+g_ascii_dtostr (name_of_string, 10, value);
+
+void
+add_point_to_suitable_cluster (GHashTable *coords_to_cluster,
+ NPDPoint *point,
+ GPtrArray *list_of_overlapping_points)
+{
+ gchar *str_coord_x, *str_coord_y;
+ GHashTable *coord_y;
+ GPtrArray *op;
+
+ NPD_FLOAT_TO_STRING (str_coord_x, point->x);
+ NPD_FLOAT_TO_STRING (str_coord_y, point->y);
+
+ coord_y = g_hash_table_lookup (coords_to_cluster, str_coord_x);
+
+ if (coord_y == NULL)
+ {
+ /* coordinate doesn't exist */
+ coord_y = g_hash_table_new_full (g_str_hash, /* is freed during */
+ g_str_equal, /* destroying */
+ g_free, /* coords_to_cluster */
+ NULL); /* hash table */
+ g_hash_table_insert (coords_to_cluster, str_coord_x, coord_y);
+ }
+
+ op = g_hash_table_lookup (coord_y, str_coord_y);
+ if (op == NULL)
+ {
+ op = g_ptr_array_new ();
+ g_hash_table_insert (coord_y, str_coord_y, op);
+ g_ptr_array_add (list_of_overlapping_points, op);
+ }
+
+ g_ptr_array_add (op, point);
+}
+
+void
+npd_set_overlapping_points_weight (NPDOverlappingPoints *op,
+ gfloat weight)
+{
+ gint i;
+ for (i = 0; i < op->num_of_points; i++)
+ {
+ (*op->points[i]->weight) = weight;
+ }
+}
+
+void
+npd_set_point_coordinates (NPDPoint *target,
+ NPDPoint *source)
+{
+ target->x = source->x;
+ target->y = source->y;
+}
+
+/**
+ * Sets type of deformation. The function doesn't perform anything if supplied
+ * deformation type doesn't differ from currently set one.
+ *
+ * @param model
+ * @param ASAP TRUE = ASAP deformation, FALSE = ARAP deformation
+ * @param MLS_weights use weights from Moving Least Squares deformation method
+ */
+void
+npd_set_deformation_type (NPDModel *model,
+ gboolean ASAP,
+ gboolean MLS_weights)
+{
+ NPDHiddenModel *hm = model->hidden_model;
+
+ if (hm->ASAP == ASAP && hm->MLS_weights == MLS_weights) return;
+
+ if (MLS_weights)
+ npd_compute_MLS_weights (model);
+ else if (hm->MLS_weights)
+ npd_reset_weights (hm);
+
+ hm->ASAP = ASAP;
+ hm->MLS_weights = MLS_weights;
+}
+
+void
+npd_compute_MLS_weights (NPDModel *model)
+{
+ NPDHiddenModel *hm = model->hidden_model;
+ NPDControlPoint *cp;
+ NPDOverlappingPoints *op;
+ NPDPoint *cp_reference, *op_reference;
+ gfloat min, SED, MLS_weight;
+ gint i, j;
+
+ if (model->control_points->len == 0)
+ {
+ npd_reset_weights (hm);
+ return;
+ }
+
+ for (i = 0; i < hm->num_of_overlapping_points; i++)
+ {
+ op = &hm->list_of_overlapping_points[i];
+ op_reference = op->representative->counterpart;
+ min = INFINITY;
+
+ for (j = 0; j < model->control_points->len; j++)
+ {
+ cp = &g_array_index (model->control_points,
+ NPDControlPoint,
+ j);
+ cp_reference = cp->overlapping_points->representative->counterpart;
+
+ /* TODO - use geodetic distance */
+ SED = npd_SED (cp_reference,
+ op_reference);
+ if (SED < min) min = SED;
+ }
+
+ if (npd_equal_floats (min, 0.0)) min = 0.0000001;
+ MLS_weight = 1 / pow (min, hm->MLS_weights_alpha);
+ npd_set_overlapping_points_weight (op, MLS_weight);
+ }
+}
+
+void
+npd_reset_weights (NPDHiddenModel *hm)
+{
+ NPDOverlappingPoints *op;
+ gint i;
+
+ for (i = 0; i < hm->num_of_overlapping_points; i++)
+ {
+ op = &hm->list_of_overlapping_points[i];
+ npd_set_overlapping_points_weight (op, 1.0);
+ }
+}
+
+void
+npd_print_model (NPDModel *model,
+ gboolean print_control_points)
+{
+ gint i;
+ g_printf ("NPDModel:\n");
+ g_printf ("control point radius: %f\n", model->control_point_radius);
+ g_printf ("control points visible: %d\n", model->control_points_visible);
+ g_printf ("mesh visible: %d\n", model->mesh_visible);
+ g_printf ("texture visible: %d\n", model->texture_visible);
+ g_printf ("mesh square size: %d\n", model->mesh_square_size);
+
+ npd_print_hidden_model (model->hidden_model, FALSE, FALSE);
+
+ if (print_control_points)
+ {
+ g_printf ("%d control points:\n", model->control_points->len);
+ for (i = 0; i < model->control_points->len; i++)
+ {
+ NPDControlPoint *cp = &g_array_index (model->control_points,
+ NPDControlPoint,
+ i);
+ npd_print_point (&cp->point, TRUE);
+ }
+ }
+}
+
+void
+npd_print_hidden_model (NPDHiddenModel *hm,
+ gboolean print_bones,
+ gboolean print_overlapping_points)
+{
+ gint i;
+ g_printf ("NPDHiddenModel:\n");
+ g_printf ("number of bones: %d\n", hm->num_of_bones);
+ g_printf ("ASAP: %d\n", hm->ASAP);
+ g_printf ("MLS weights: %d\n", hm->MLS_weights);
+ g_printf ("number of overlapping points: %d\n", hm->num_of_overlapping_points);
+
+ if (print_bones)
+ {
+ g_printf ("bones:\n");
+ for (i = 0; i < hm->num_of_bones; i++)
+ {
+ npd_print_bone (&hm->current_bones[i]);
+ }
+ }
+
+ if (print_overlapping_points)
+ {
+ g_printf ("overlapping points:\n");
+ for (i = 0; i < hm->num_of_overlapping_points; i++)
+ {
+ npd_print_overlapping_points (&hm->list_of_overlapping_points[i]);
+ }
+ }
+}
+
+void
+npd_print_bone (NPDBone *bone)
+{
+ gint i;
+ g_printf ("NPDBone:\n");
+ g_printf ("number of points: %d\n", bone->num_of_points);
+ g_printf ("points:\n");
+ for (i = 0; i < bone->num_of_points; i++)
+ {
+ npd_print_point (&bone->points[i], TRUE);
+ }
+}
+
+void
+npd_print_point (NPDPoint *point,
+ gboolean print_details)
+{
+ if (print_details)
+ {
+ g_printf ("(NPDPoint: x: %f, y: %f, weight: %f, fixed: %d)\n",
+ point->x, point->y, *point->weight, point->fixed);
+ }
+ else
+ {
+ g_printf ("(NPDPoint: x: %f, y: %f)\n",
+ point->x, point->y);
+ }
+}
+
+void
+npd_print_overlapping_points (NPDOverlappingPoints *op)
+{
+ gint i;
+ g_printf ("NPDOverlappingPoints:\n");
+ g_printf ("number of points: %d\n", op->num_of_points);
+ g_printf ("representative: ");
+ npd_print_point (op->representative, TRUE);
+ g_printf ("points:\n");
+ for (i = 0; i < op->num_of_points; i++)
+ {
+ npd_print_point (op->points[i], TRUE);
+ }
+}
diff --git a/libs/npd/npd_common.h b/libs/npd/npd_common.h
new file mode 100644
index 0000000..b3be82e
--- /dev/null
+++ b/libs/npd/npd_common.h
@@ -0,0 +1,157 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#ifndef __NPD_COMMON_H__
+#define __NPD_COMMON_H__
+
+#include <glib.h>
+
+/* opaque types for independency on used display library */
+typedef struct _NPDImage NPDImage;
+typedef struct _NPDColor NPDColor;
+typedef struct _NPDDisplay NPDDisplay;
+typedef struct _NPDMatrix NPDMatrix;
+
+typedef struct _NPDPoint NPDPoint;
+typedef struct _NPDBone NPDBone;
+typedef struct _NPDOverlappingPoints NPDOverlappingPoints;
+
+struct _NPDPoint
+{
+ gfloat x;
+ gfloat y;
+ gboolean fixed;
+ gfloat *weight; /* pointer to weight in array of weights */
+ gint index;
+ NPDBone *current_bone;
+ NPDBone *reference_bone;
+ NPDPoint *counterpart;
+ NPDOverlappingPoints *overlapping_points;
+};
+
+struct _NPDBone
+{
+ gint num_of_points;
+ NPDPoint *points; /* array of points */
+ gfloat *weights; /* array of weights */
+};
+
+struct _NPDOverlappingPoints
+{
+ gint num_of_points;
+ NPDPoint *representative; /* pointer to representative of cluster */
+ NPDPoint **points; /* array of pointers to points */
+};
+
+typedef struct
+{
+ gint num_of_bones;
+ gint num_of_overlapping_points;
+ gboolean ASAP; /* don't change directly!
+ * use npd_set_deformation_type function */
+ gboolean MLS_weights; /* don't change directly!
+ * use npd_set_deformation_type function */
+ gfloat MLS_weights_alpha;
+ NPDBone *current_bones; /* array of current bones */
+ NPDBone *reference_bones; /* array of reference bones */
+ NPDOverlappingPoints *list_of_overlapping_points; /* array of overlapping points */
+} NPDHiddenModel;
+
+typedef struct
+{
+ NPDPoint point;
+ NPDOverlappingPoints *overlapping_points; /* pointer to overlapping points */
+} NPDControlPoint;
+
+typedef struct
+{
+ gfloat control_point_radius;
+ gboolean control_points_visible;
+ gboolean mesh_visible;
+ gboolean texture_visible;
+ gint mesh_square_size;
+ GArray *control_points; /* GArray of control points */
+ NPDHiddenModel *hidden_model;
+ NPDImage *reference_image;
+ NPDDisplay *display;
+} NPDModel;
+
+#define npd_init(set_pixel, get_pixel, \
+ draw_line) \
+npd_set_pixel_color = set_pixel; \
+npd_get_pixel_color = get_pixel; \
+npd_draw_line = draw_line;
+
+void npd_init_model (NPDModel *model);
+void npd_destroy_hidden_model (NPDHiddenModel *model);
+void npd_destroy_model (NPDModel *model);
+
+NPDControlPoint *npd_add_control_point (NPDModel *model,
+ NPDPoint *coord);
+void npd_remove_control_point (NPDModel *model,
+ NPDControlPoint *control_point);
+void npd_remove_control_points (NPDModel *model,
+ GList *control_points);
+void npd_remove_all_control_points (NPDModel *model);
+void npd_set_control_point_weight (NPDControlPoint *cp,
+ gfloat weight);
+gboolean npd_equal_coordinates (NPDPoint *p1,
+ NPDPoint *p2);
+gboolean npd_equal_coordinates_epsilon (NPDPoint *p1,
+ NPDPoint *p2,
+ gfloat epsilon);
+NPDControlPoint *npd_get_control_point_with_radius_at
+ (NPDModel *model,
+ NPDPoint *coord,
+ gfloat control_point_radius);
+NPDControlPoint *npd_get_control_point_at (NPDModel *model,
+ NPDPoint *coord);
+void npd_create_square (NPDBone *square,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+void npd_create_list_of_overlapping_points
+ (NPDHiddenModel *model);
+void add_point_to_suitable_cluster (GHashTable *coords_to_cluster,
+ NPDPoint *point,
+ GPtrArray *list_of_overlapping_points);
+void npd_set_overlapping_points_weight
+ (NPDOverlappingPoints *op,
+ gfloat weight);
+void npd_set_point_coordinates (NPDPoint *target,
+ NPDPoint *source);
+void npd_set_deformation_type (NPDModel *model,
+ gboolean ASAP,
+ gboolean MLS_weights);
+void npd_compute_MLS_weights (NPDModel *model);
+void npd_reset_weights (NPDHiddenModel *hidden_model);
+
+void npd_print_model (NPDModel *model,
+ gboolean print_control_points);
+void npd_print_hidden_model (NPDHiddenModel *hm,
+ gboolean print_bones,
+ gboolean print_overlapping_points);
+void npd_print_bone (NPDBone *bone);
+void npd_print_point (NPDPoint *point,
+ gboolean print_details);
+void npd_print_overlapping_points (NPDOverlappingPoints *op);
+#endif /* __NPD_COMMON_H__ */
diff --git a/libs/npd/npd_gegl.c b/libs/npd/npd_gegl.c
new file mode 100644
index 0000000..1a8abaf
--- /dev/null
+++ b/libs/npd/npd_gegl.c
@@ -0,0 +1,68 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#include "npd_gegl.h"
+#include <glib.h>
+
+void
+npd_new_matrix (NPDMatrix **matrix)
+{
+ *matrix = g_new (NPDMatrix, 1);
+}
+
+void
+npd_destroy_matrix (NPDMatrix **matrix)
+{
+ g_free (*matrix);
+}
+
+void
+npd_compute_affinity (NPDPoint *p11,
+ NPDPoint *p21,
+ NPDPoint *p31,
+ NPDPoint *p12,
+ NPDPoint *p22,
+ NPDPoint *p32,
+ NPDMatrix *T)
+{
+ GeglMatrix3 Y, X;
+
+ Y.coeff[0][0] = p12->x; Y.coeff[1][0] = p12->y; Y.coeff[2][0] = 1;
+ Y.coeff[0][1] = p22->x; Y.coeff[1][1] = p22->y; Y.coeff[2][1] = 1;
+ Y.coeff[0][2] = p32->x; Y.coeff[1][2] = p32->y; Y.coeff[2][2] = 1;
+
+ X.coeff[0][0] = p11->x; X.coeff[1][0] = p11->y; X.coeff[2][0] = 1;
+ X.coeff[0][1] = p21->x; X.coeff[1][1] = p21->y; X.coeff[2][1] = 1;
+ X.coeff[0][2] = p31->x; X.coeff[1][2] = p31->y; X.coeff[2][2] = 1;
+
+ gegl_matrix3_invert (&X);
+ gegl_matrix3_multiply (&Y, &X, &T->matrix);
+}
+
+void
+npd_apply_transformation (NPDMatrix *T,
+ NPDPoint *src,
+ NPDPoint *dest)
+{
+ gdouble x = src->x, y = src->y;
+ gegl_matrix3_transform_point (&T->matrix, &x, &y);
+ dest->x = x; dest->y = y;
+}
diff --git a/libs/npd/npd_gegl.h b/libs/npd/npd_gegl.h
new file mode 100644
index 0000000..7ce4790
--- /dev/null
+++ b/libs/npd/npd_gegl.h
@@ -0,0 +1,33 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#ifndef __NPD_GEGL_H__
+#define __NPD_GEGL_H__
+
+#include "npd_math.h"
+#include <gegl-matrix.h>
+
+struct _NPDMatrix
+{
+ GeglMatrix3 matrix;
+};
+
+#endif /* __NPD_GEGL_H__ */
diff --git a/libs/npd/npd_math.c b/libs/npd/npd_math.c
new file mode 100644
index 0000000..b14f73f
--- /dev/null
+++ b/libs/npd/npd_math.c
@@ -0,0 +1,47 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#include "npd_math.h"
+#include <math.h>
+
+gboolean
+npd_equal_floats (gfloat a,
+ gfloat b)
+{
+ return npd_equal_floats_epsilon (a, b, NPD_EPSILON);
+}
+
+gboolean
+npd_equal_floats_epsilon (gfloat a,
+ gfloat b,
+ gfloat epsilon)
+{
+ return fabs (a - b) < epsilon;
+}
+
+gfloat
+npd_SED (NPDPoint *p1,
+ NPDPoint *p2)
+{
+ gint dx = p1->x - p2->x;
+ gint dy = p1->y - p2->y;
+ return dx * dx + dy * dy;
+}
diff --git a/libs/npd/npd_math.h b/libs/npd/npd_math.h
new file mode 100644
index 0000000..411f4e9
--- /dev/null
+++ b/libs/npd/npd_math.h
@@ -0,0 +1,58 @@
+/*
+ * This file is part of N-point image deformation library.
+ *
+ * N-point image deformation 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 3 of the License,
+ * or (at your option) any later version.
+ *
+ * N-point image deformation 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 N-point image deformation library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#ifndef __NPD_MATH_H__
+#define __NPD_MATH_H__
+
+#include "npd_common.h"
+
+#define NPD_EPSILON 0.00001
+
+void npd_compute_homography (NPDPoint *p11,
+ NPDPoint *p21,
+ NPDPoint *p31,
+ NPDPoint *p41,
+ NPDPoint *p12,
+ NPDPoint *p22,
+ NPDPoint *p32,
+ NPDPoint *p42,
+ NPDMatrix *T);
+void npd_compute_affinity (NPDPoint *p11,
+ NPDPoint *p21,
+ NPDPoint *p31,
+ NPDPoint *p12,
+ NPDPoint *p22,
+ NPDPoint *p32,
+ NPDMatrix *T);
+void npd_apply_transformation (NPDMatrix *T,
+ NPDPoint *src,
+ NPDPoint *dest);
+gboolean npd_equal_floats_epsilon (gfloat a,
+ gfloat b,
+ gfloat epsilon);
+gboolean npd_equal_floats (gfloat a,
+ gfloat b);
+gfloat npd_SED (NPDPoint *p1,
+ NPDPoint *p2);
+void npd_new_matrix (NPDMatrix **matrix);
+void npd_destroy_matrix (NPDMatrix **matrix);
+
+#endif /* __NPD_MATH_H__ */
diff --git a/operations/external/Makefile.am b/operations/external/Makefile.am
index b929744..6b2dc4f 100644
--- a/operations/external/Makefile.am
+++ b/operations/external/Makefile.am
@@ -158,5 +158,13 @@ rgbe_save_la_SOURCES = rgbe-save.c
rgbe_save_la_CFLAGS = $(AM_CFLAGS) -I $(top_srcdir)/libs
rgbe_save_la_LIBADD = $(op_libs) $(top_builddir)/libs/rgbe/librgbe.la
+# Dependencies are in our source tree
+if HAVE_CAIRO
+ops += npd.la
+npd_la_SOURCES = npd.c
+npd_la_CFLAGS = $(AM_CFLAGS) $(NPD_CFLAGS) $(CAIRO_CFLAGS)
+npd_la_LIBADD = $(op_libs) $(NPD_LIBS) $(CAIRO_LIBS)
+endif
+
opdir = $(libdir)/gegl- GEGL_API_VERSION@
op_LTLIBRARIES = $(ops)
diff --git a/operations/external/npd.c b/operations/external/npd.c
new file mode 100644
index 0000000..63bfc37
--- /dev/null
+++ b/operations/external/npd.c
@@ -0,0 +1,329 @@
+/* This file is an image processing operation for GEGL
+ *
+ * GEGL 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 3 of the License, or (at your option) any later version.
+ *
+ * GEGL 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 GEGL; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2013 Marek Dvoroznak <dvoromar gmail com>
+ */
+
+#include "config.h"
+#include <glib/gi18n-lib.h>
+
+#ifdef GEGL_CHANT_PROPERTIES
+gegl_chant_pointer (model, _("model"),
+ _("Model - basic element we operate on"))
+
+gegl_chant_int (square_size, _("square size"),
+ 5, 1000, 20,
+ _("Size of an edge of square the mesh consists of"))
+
+gegl_chant_int (rigidity, _("rigidity"),
+ 0, 10000, 100,
+ _("The number of deformation iterations"))
+
+gegl_chant_boolean (ASAP_deformation, _("ASAP deformation"),
+ FALSE,
+ _("ASAP deformation is performed when TRUE, ARAP deformation otherwise"))
+
+gegl_chant_boolean (MLS_weights, _("MLS weights"),
+ FALSE,
+ _("Use MLS weights"))
+
+gegl_chant_double (MLS_weights_alpha, _("MLS weights alpha"),
+ 0.1, 2.0, 1.0,
+ _("Alpha parameter of MLS weights"))
+
+gegl_chant_boolean (mesh_visible, _("mesh visible"),
+ TRUE,
+ _("Should the mesh be visible?"))
+#else
+
+#define GEGL_CHANT_TYPE_FILTER
+#define GEGL_CHANT_C_FILE "npd.c"
+
+#include "gegl-chant.h"
+#include <stdio.h>
+#include <math.h>
+#include <npd/npd.h>
+#include <npd/npd_gegl.h>
+#include <cairo.h>
+
+struct _NPDImage
+{
+ gint width;
+ gint height;
+ NPDPoint position;
+ guchar *buffer;
+};
+
+struct _NPDDisplay
+{
+ NPDImage image;
+ cairo_t *cr;
+};
+
+typedef struct
+{
+ gboolean first_run;
+ NPDModel model;
+} NPDProperties;
+
+void npd_create_image (NPDImage *image,
+ GeglBuffer *gegl_buffer,
+ const Babl *format);
+
+void npd_set_pixel_color_impl (NPDImage *image,
+ gint x,
+ gint y,
+ NPDColor *color);
+
+void npd_get_pixel_color_impl (NPDImage *image,
+ gint x,
+ gint y,
+ NPDColor *color);
+
+void npd_draw_line_impl (NPDDisplay *display,
+ gfloat x0,
+ gfloat y0,
+ gfloat x1,
+ gfloat y1);
+
+void npd_set_pixel_color_impl (NPDImage *image,
+ gint x,
+ gint y,
+ NPDColor *color)
+{
+ if (x > -1 && x < image->width &&
+ y > -1 && y < image->height)
+ {
+ gint position = 4 * (y * image->width + x);
+
+ image->buffer[position + 0] = color->r;
+ image->buffer[position + 1] = color->g;
+ image->buffer[position + 2] = color->b;
+ image->buffer[position + 3] = color->a;
+ }
+}
+
+void
+npd_get_pixel_color_impl (NPDImage *image,
+ gint x,
+ gint y,
+ NPDColor *color)
+{
+ if (x > -1 && x < image->width &&
+ y > -1 && y < image->height)
+ {
+ gint position = 4 * (y * image->width + x);
+
+ color->r = image->buffer[position + 0];
+ color->g = image->buffer[position + 1];
+ color->b = image->buffer[position + 2];
+ color->a = image->buffer[position + 3];
+ }
+ else
+ {
+ color->r = color->g = color->b = color->a = 0;
+ }
+}
+
+void npd_draw_line_impl (NPDDisplay *display,
+ gfloat x0,
+ gfloat y0,
+ gfloat x1,
+ gfloat y1)
+{
+ cairo_move_to (display->cr, x0, y0);
+ cairo_line_to (display->cr, x1, y1);
+}
+
+void
+npd_draw_model (NPDModel *model,
+ NPDDisplay *display)
+{
+ NPDHiddenModel *hm = model->hidden_model;
+ NPDImage *image = model->reference_image;
+ gint i;
+
+ /* draw texture */
+ if (model->texture_visible)
+ {
+ for (i = 0; i < hm->num_of_bones; i++)
+ {
+ npd_texture_quadrilateral(&hm->reference_bones[i],
+ &hm->current_bones[i],
+ image,
+ &display->image,
+ NPD_BILINEAR_INTERPOLATION | NPD_ALPHA_BLENDING);
+ }
+ }
+
+ /* draw mesh */
+ if (model->mesh_visible)
+ {
+ cairo_surface_t *surface;
+
+ surface = cairo_image_surface_create_for_data (display->image.buffer,
+ CAIRO_FORMAT_ARGB32,
+ display->image.width,
+ display->image.height,
+ display->image.width * 4);
+ display->cr = cairo_create (surface);
+ cairo_set_line_width (display->cr, 1);
+ cairo_set_source_rgba (display->cr, 0, 0, 0, 1);
+ npd_draw_mesh (model, display);
+ cairo_stroke (display->cr);
+ }
+}
+
+void
+npd_create_model_from_image (NPDModel *model,
+ NPDImage *image,
+ gint square_size)
+{
+ npd_init_model(model);
+ model->reference_image = image;
+ model->mesh_square_size = square_size;
+
+ npd_create_mesh_from_image (model, image->width, image->height, 0, 0);
+}
+
+void
+npd_create_image (NPDImage *image,
+ GeglBuffer *gegl_buffer,
+ const Babl *format)
+{
+ guchar *buffer;
+ buffer = g_new0 (guchar, gegl_buffer_get_pixel_count (gegl_buffer) * 4);
+ gegl_buffer_get (gegl_buffer, NULL, 1.0, format,
+ buffer, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+ image->buffer = buffer;
+ image->width = gegl_buffer_get_width (gegl_buffer);
+ image->height = gegl_buffer_get_height (gegl_buffer);
+}
+
+void
+npd_destroy_image (NPDImage *image)
+{
+ g_free(image->buffer);
+}
+
+static void
+prepare (GeglOperation *operation)
+{
+ GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
+ NPDProperties *props;
+
+ if (o->chant_data == NULL)
+ {
+ props = g_new (NPDProperties, 1);
+ props->first_run = TRUE;
+ o->chant_data = props;
+ }
+
+ gegl_operation_set_format (operation, "input",
+ babl_format ("RGBA float"));
+ gegl_operation_set_format (operation, "output",
+ babl_format ("RGBA float"));
+}
+
+static gboolean
+process (GeglOperation *operation,
+ GeglBuffer *input,
+ GeglBuffer *output,
+ const GeglRectangle *result,
+ gint level)
+{
+ GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
+ const Babl *format = babl_format ("RGBA u8");
+ NPDProperties *props = o->chant_data;
+ NPDModel *model = &props->model;
+ NPDHiddenModel *hm;
+ guchar *output_buffer;
+ gint length = gegl_buffer_get_pixel_count (input) * 4;
+
+ if (props->first_run)
+ {
+ gint width, height;
+ NPDImage *input_image = g_new (NPDImage, 1);
+ NPDDisplay *display = g_new (NPDDisplay, 1);
+
+ npd_init (npd_set_pixel_color_impl,
+ npd_get_pixel_color_impl,
+ npd_draw_line_impl);
+
+ npd_create_image (input_image, input, format);
+ width = input_image->width;
+ height = input_image->height;
+
+ output_buffer = g_new0 (guchar, length);
+ display->image.width = width;
+ display->image.height = height;
+ display->image.buffer = output_buffer;
+ model->display = display;
+
+ npd_create_model_from_image (model, input_image, o->square_size);
+ hm = model->hidden_model;
+/* npd_create_list_of_overlapping_points (hm);*/
+
+ o->model = model;
+
+ memcpy (output_buffer, input_image->buffer, length);
+
+ props->first_run = FALSE;
+ }
+ else
+ {
+ npd_set_deformation_type (model, o->ASAP_deformation, o->MLS_weights);
+
+ if (o->MLS_weights &&
+ model->hidden_model->MLS_weights_alpha != o->MLS_weights_alpha)
+ {
+ model->hidden_model->MLS_weights_alpha = o->MLS_weights_alpha;
+ npd_compute_MLS_weights (model);
+ }
+
+ model->mesh_visible = o->mesh_visible;
+
+ output_buffer = model->display->image.buffer;
+ memset (output_buffer, 0, length);
+ npd_deform_model (model, o->rigidity);
+ npd_draw_model (model, model->display);
+ }
+
+ gegl_buffer_set (output, NULL, 0, format, output_buffer, GEGL_AUTO_ROWSTRIDE);
+
+ return TRUE;
+}
+
+static void
+gegl_chant_class_init (GeglChantClass *klass)
+{
+ GeglOperationClass *operation_class;
+ GeglOperationFilterClass *filter_class;
+
+ operation_class = GEGL_OPERATION_CLASS (klass);
+ filter_class = GEGL_OPERATION_FILTER_CLASS (klass);
+
+ filter_class->process = process;
+ operation_class->prepare = prepare;
+
+ gegl_operation_class_set_keys (operation_class,
+ "categories" , "transform",
+ "name" , "gegl:npd",
+ "description" , _("Performs n-point image deformation"),
+ NULL);
+}
+
+#endif
\ No newline at end of file
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 91377d0..8b672fa 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -117,6 +117,7 @@ operations/external/jpg-load.c
operations/external/jpg-save.c
operations/external/lcms-from-profile.c
operations/external/matting-levin.c
+operations/external/npd.c
operations/external/npy-save.c
operations/external/path.c
operations/external/pixbuf.c
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
