Introduce gesture frames

This patch extends the API with parallel new/delete functions,
aiming to eventually replace the open/close function. The new
functions give access to the grail gesture frames, containing
gestural transform information. This information is useful in its
own right, and will eventually replace the internal recognizer.

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

1 files changed, 399 insertions, 0 deletions

diff --git a/src/grail-frame.c b/src/grail-frame.c
new file mode 100644
index 0000000..cf38452
--- /dev/null
+++ b/src/grail-frame.c
@@ -0,0 +1,399 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010 Canonical Ltd.
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@bitmath.org>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#include "grail-impl.h"
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+static void set_center_velocity_and_radius(struct grail_impl *impl,
+                                           struct grail_element *slot)
+{
+        const struct utouch_contact **tc = slot->touches;
+        double x, y, vx, vy, r2, dx, dy;
+        int i;
+
+        switch (slot->num_touches) {
+        case 1:
+                x = tc[0]->x;
+                y = tc[0]->y;
+                vx = tc[0]->vx;
+                vy = tc[0]->vy;
+                r2 = 0;
+                break;
+        case 2:
+                dx = 0.5 * (tc[1]->x - tc[0]->x);
+                dy = 0.5 * (tc[1]->y - tc[0]->y);
+                x = tc[0]->x + dx;
+                y = tc[0]->y + dy;
+                vx = 0.5 * (tc[0]->vx + tc[1]->vx);
+                vy = 0.5 * (tc[0]->vy + tc[1]->vy);
+                r2 = dx * dx + dy * dy;
+                break;
+        default:
+                x = y = vx = vy = r2 = 0;
+                for (i = 0; i < slot->num_touches; i++) {
+                        x += tc[i]->x;
+                        y += tc[i]->y;
+                        vx += tc[i]->vx;
+                        vy += tc[i]->vy;
+                }
+                x /= slot->num_touches;
+                y /= slot->num_touches;
+                vx /= slot->num_touches;
+                vy /= slot->num_touches;
+                for (i = 0; i < slot->num_touches; i++) {
+                        dx = tc[i]->x - x;
+                        dy = tc[i]->y - y;
+                        r2 += dx * dx + dy * dy;
+                }
+                r2 /= slot->num_touches;
+                break;
+        }
+
+        slot->center.x = x;
+        slot->center.y = y;
+        slot->velocity.x = 1000 * vx;
+        slot->velocity.y = 1000 * vy;
+        slot->radius2 = r2;
+}
+
+static void set_moveness_pivot_and_drag(struct grail_impl *impl,
+                                        struct grail_element *slot,
+                                        double ds, double dc)
+{
+        const struct grail_control *ctl = impl->ctl;
+        const struct grail_element *pslot = slot->prev;
+        double mx = slot->center.x - pslot->center.x;
+        double my = slot->center.y - pslot->center.y;
+        float *T = slot->transform;
+
+        slot->moveness = 1;
+        slot->pivot = pslot->center;
+
+        if (slot->num_touches > 1) {
+                double wx = (1 - dc) * mx + ds * my;
+                double wy = (1 - dc) * my - ds * mx;
+                double w2 = wx * wx + wy * wy;
+                if (w2 > 0) {
+                        double q = (mx * mx + my * my) / w2;
+                        double s = ctl->pivot_unbound ?
+                                q : sqrt(pslot->radius2 / w2);
+                        if (s < q) {
+                                slot->moveness = 1 - s / q;
+                                slot->pivot.x += s * wx;
+                                slot->pivot.y += s * wy;
+                        } else {
+                                slot->moveness = 0;
+                                slot->pivot.x += q * wx;
+                                slot->pivot.y += q * wy;
+                        }
+                }
+        }
+
+        mx *= slot->moveness;
+        my *= slot->moveness;
+
+        T[0] = dc;
+        T[1] = ds;
+        T[2] = (1 - dc) * slot->pivot.x - ds * slot->pivot.y + mx;
+        T[3] = -ds;
+        T[4] = dc;
+        T[5] = (1 - dc) * slot->pivot.y + ds * slot->pivot.x + my;
+
+        slot->drag.x = pslot->drag.x + mx;
+        slot->drag.y = pslot->drag.y + my;
+}
+
+static void start_slot(struct grail_impl *impl,
+                       struct grail_element *slot,
+                       const struct utouch_frame *touch)
+{
+        float *T = slot->transform;
+
+        slot->id = impl->seqid++ & GRAIL_ID_MAX;
+        slot->expect_mask = GRAIL_EXPECT_MASK;
+        slot->active_mask = 0;
+        slot->start_time = touch->time;
+        set_center_velocity_and_radius(impl, slot);
+        slot->start_center = slot->center;
+        T[0] = T[4] = 1;
+        T[1] = T[2] = T[3] = T[5] = 0;
+        slot->pivot = slot->center;
+        slot->drag.x = 0;
+        slot->drag.y = 0;
+        slot->scale2 = 1;
+        slot->angle = 0;
+}
+
+static void update_slot(struct grail_impl *impl,
+                        struct grail_element *slot,
+                        double ds, double dc)
+{
+        const struct grail_element *pslot = slot->prev;
+
+        slot->id = pslot->id;
+        slot->start_time = pslot->start_time;
+        slot->start_center = pslot->start_center;
+        slot->expect_mask = pslot->expect_mask;
+        slot->active_mask = pslot->active_mask;
+
+        set_center_velocity_and_radius(impl, slot);
+        set_moveness_pivot_and_drag(impl, slot, ds, dc);
+
+        slot->scale2 = pslot->scale2 * (ds * ds + dc * dc);
+        slot->angle = pslot->angle + ds / dc; /* atan2(ds, dc) */
+}
+
+static void stop_slot(struct grail_impl *impl,
+                      struct grail_element *slot)
+{
+        const struct grail_element *pslot = slot->prev;
+        float *T = slot->transform;
+
+        slot->id = -1;
+        slot->num_touches = 0;
+        slot->start_time = pslot->start_time;
+        slot->start_center = pslot->start_center;
+        slot->expect_mask = 0;
+        slot->active_mask = pslot->active_mask;
+        slot->center = pslot->center;
+        slot->velocity = pslot->velocity;
+        slot->radius2 = pslot->radius2;
+        T[0] = T[4] = 1;
+        T[1] = T[2] = T[3] = T[5] = 0;
+        slot->moveness = 1;
+        slot->pivot = pslot->pivot;
+        slot->drag = pslot->drag;
+        slot->scale2 = pslot->scale2;
+        slot->angle = pslot->angle;
+}
+
+static void set_slot_one(struct grail_impl *impl,
+                         struct grail_element *slot,
+                         const struct utouch_frame *touch,
+                         const struct utouch_contact *t1)
+{
+        const struct grail_element *pslot = slot->prev;
+        const struct utouch_contact *p1 = pslot->touches[0];
+
+        if (!t1->active) {
+                stop_slot(impl, slot);
+                return;
+        }
+
+        slot->touches[0] = t1;
+        slot->num_touches = 1;
+
+        if (pslot->num_touches != slot->num_touches || t1->id != p1->id) {
+                start_slot(impl, slot, touch);
+                return;
+        }
+
+        update_slot(impl, slot, 0, 1);
+}
+
+static void set_slot_two(struct grail_impl *impl,
+                         struct grail_element *slot,
+                         const struct utouch_frame *touch,
+                         const struct utouch_contact *t1,
+                         const struct utouch_contact *t2)
+{
+        const struct grail_element *pslot = slot->prev;
+        const struct utouch_contact *p1 = pslot->touches[0];
+        const struct utouch_contact *p2 = pslot->touches[1];
+        double tx, ty, px, py, d2;
+
+        if (!t1->active || !t2->active) {
+                stop_slot(impl, slot);
+                return;
+        }
+
+        slot->touches[0] = t1;
+        slot->touches[1] = t2;
+        slot->num_touches = 2;
+
+        if (pslot->num_touches != slot->num_touches ||
+            t1->id != p1->id || t2->id != p2->id) {
+                start_slot(impl, slot, touch);
+                return;
+        }
+
+        tx = t2->x - t1->x;
+        ty = t2->y - t1->y;
+        px = p2->x - p1->x;
+        py = p2->y - p1->y;
+
+        d2 = px * px + py * py;
+        if (d2 > 0) {
+                px /= d2;
+                py /= d2;
+        }
+
+        update_slot(impl, slot, tx * py - ty * px, tx * px + ty * py);
+}
+
+static void set_slot_multi(struct grail_impl *impl,
+                           struct grail_element *slot,
+                           struct grail_frame *frame,
+                           const struct utouch_frame *touch)
+{
+        const struct grail_element *pslot = slot->prev;
+        struct grail_element **slots = frame->slots;
+        int i, j, n = impl->num_touches;
+        struct grail_element *best = 0;
+
+        if (touch->num_active < 3) {
+                stop_slot(impl, slot);
+                return;
+        }
+
+        memcpy(slot->touches, touch->active,
+               touch->num_active * sizeof(slot->touches[0]));
+        slot->num_touches = touch->num_active;
+
+        if (pslot->num_touches != slot->num_touches) {
+                start_slot(impl, slot, touch);
+                return;
+        }
+
+        for (i = 0; i < slot->num_touches; i++) {
+                if (slot->touches[i]->id != pslot->touches[i]->id) {
+                        start_slot(impl, slot, touch);
+                        return;
+                }
+        }
+
+        for (i = 0; i < impl->num_touches; i++) {
+                for (j = i + 1; j < impl->num_touches; j++) {
+                        struct grail_element *s = slots[n++];
+                        if (!s->num_touches)
+                                continue;
+                        if (!best || s->radius2 > best->radius2)
+                                best = s;
+                }
+        }
+
+        update_slot(impl, slot, best->transform[1], best->transform[0]);
+}
+
+static void set_slots(struct grail_impl *impl,
+                      struct grail_frame *frame,
+                      const struct utouch_frame *touch)
+{
+        struct grail_element **slots = frame->slots;
+        struct utouch_contact *const *tc = touch->slots;
+        int i, j, n = 0;
+
+        for (i = 0; i < impl->num_touches; i++)
+                set_slot_one(impl, slots[n++], touch, tc[i]);
+
+        for (i = 0; i < impl->num_touches; i++)
+                for (j = i + 1; j < impl->num_touches; j++)
+                        set_slot_two(impl, slots[n++], touch, tc[i], tc[j]);
+
+        set_slot_multi(impl, slots[n++], frame, touch);
+}
+
+static void collect_transforms(struct grail_impl *impl,
+                               struct grail_frame *frame,
+                               const struct utouch_frame *touch)
+{
+        const struct utouch_surface *s = utouch_frame_get_surface(impl->fh);
+        const struct grail_control *ctl = impl->ctl;
+        float c_x = ctl->bar_center_x * (s->mapped_max_x - s->mapped_min_x);
+        float c_y = ctl->bar_center_y * (s->mapped_max_y - s->mapped_min_y);
+        float d_x = ctl->bar_drag_x * (s->mapped_max_x - s->mapped_min_x);
+        float d_y = ctl->bar_drag_y * (s->mapped_max_y - s->mapped_min_y);
+        float ds2 = ctl->bar_scale * ctl->bar_scale;
+        float dt;
+        int i;
+
+        for (i = 0; i < impl->num_slots; i++) {
+                struct grail_element *s = frame->slots[i];
+
+                if (!s->num_touches)
+                        continue;
+
+                dt = touch->time - s->start_time;
+                if (dt > ctl->glue_ms) {
+                        unsigned int mask = s->active_mask;
+
+                        if (fabs(s->center.x - s->start_center.x) > c_x)
+                                mask |= GRAIL_EXPECT_CENTER_X;
+                        if (fabs(s->center.y - s->start_center.y) > c_y)
+                                mask |= GRAIL_EXPECT_CENTER_Y;
+                        if (fabs(s->drag.x) > d_x)
+                                mask |= GRAIL_EXPECT_DRAG_X;
+                        if (fabs(s->drag.y) > d_y)
+                                mask |= GRAIL_EXPECT_DRAG_Y;
+                        if (fabs(s->scale2 - 1) > ds2)
+                                mask |= GRAIL_EXPECT_SCALE;
+                        if (fabs(s->angle) > ctl->bar_angle)
+                                mask |= GRAIL_EXPECT_ANGLE;
+
+                        s->active_mask = mask;
+
+                        if (dt < ctl->drop_x_ms)
+                                mask |= GRAIL_EXPECT_CENTER_X;
+                        if (dt < ctl->drop_y_ms)
+                                mask |= GRAIL_EXPECT_CENTER_Y;
+                        if (dt < ctl->drop_x_ms)
+                                mask |= GRAIL_EXPECT_DRAG_X;
+                        if (dt < ctl->drop_y_ms)
+                                mask |= GRAIL_EXPECT_DRAG_Y;
+                        if (dt < ctl->drop_scale_ms)
+                                mask |= GRAIL_EXPECT_SCALE;
+                        if (dt < ctl->drop_angle_ms)
+                                mask |= GRAIL_EXPECT_ANGLE;
+
+                        s->expect_mask &= mask;
+                }
+
+                frame->ongoing[frame->num_ongoing++] = s;
+        }
+}
+
+const struct grail_frame GRAIL_PUBLIC *
+grail_pump_frame(grail_handle ge, const struct utouch_frame *touch)
+{
+        struct grail_impl *impl = ge->impl;
+        struct grail_frame *frame = impl->frames[impl->nextframe];
+        const struct grail_frame *prev = frame->prev;
+        int i;
+
+        if (touch->slot_revision == touch->prev->slot_revision &&
+            !prev->num_ongoing)
+                return 0;
+
+        frame->touch = touch;
+        frame->num_ongoing = 0;
+        for (i = 0; i < impl->num_slots; i++)
+                frame->slots[i]->prev = prev->slots[i];
+
+        set_slots(impl, frame, touch);
+        collect_transforms(impl, frame, touch);
+
+        impl->nextframe = (impl->nextframe + 1) % impl->num_frames;
+
+        return frame;
+}