QTouchEvent: add uniqueId and rotation; TUIO: support fiducial tokens

TUIO supports tracking tagged physical objects on touchscreens by
various means (QR codes, RFIDs etc.)  It can detect both position
and rotation.  Likewise, it may be possible for some touchscreens or
drivers to detect orientation of the fingers.  So, just as QTabletEvent
has rotation, each touchpoint needs to include the rotation value.

When using tokens, each object has a permanent unique ID, whereas
QTouchEvent::TouchPoint::id() is a transient ID which usually auto-
increments each time a finger is pressed to the device.  So we need to
make that available too, to identify each token.  Different platforms
may use different kinds of IDs (int, UUID, QR code etc.); however for
TUIO 1.x, the unique IDs are just 32-bit integers.  QPointerUniqueId
is added, storing only a qint64 for now (like QTabletEvent::uniqueId())
but able to be expanded as necessary later on.

Task-number: QTBUG-51844
Change-Id: I04182042f47fa2954728079139a4664a31184b54
Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>

1 files changed, 228 insertions, 29 deletions

diff --git a/src/plugins/generic/tuiotouch/qtuiohandler.cpp b/src/plugins/generic/tuiotouch/qtuiohandler.cpp
index 6026e06b55..86decd312b 100644
--- a/src/plugins/generic/tuiotouch/qtuiohandler.cpp
+++ b/src/plugins/generic/tuiotouch/qtuiohandler.cpp
@@ -43,10 +43,12 @@
 #include <QWindow>
 #include <QGuiApplication>
 #include <QTouchDevice>
+#include <qmath.h>
 
 #include <qpa/qwindowsysteminterface.h>
 
 #include "qtuiocursor_p.h"
+#include "qtuiotoken_p.h"
 #include "qtuiohandler_p.h"
 #include "qoscbundle_p.h"
 
@@ -55,6 +57,12 @@ QT_BEGIN_NAMESPACE
 Q_LOGGING_CATEGORY(lcTuioSource, "qt.qpa.tuio.source")
 Q_LOGGING_CATEGORY(lcTuioSet, "qt.qpa.tuio.set")
 
+// With TUIO the first application takes exclusive ownership of the "device"
+// we cannot attach more than one application to the same port anyway.
+// Forcing delivery makes it easy to use simulators in the same machine
+// and forget about headaches about unfocused TUIO windows.
+static bool forceDelivery = qEnvironmentVariableIsSet("QT_TUIOTOUCH_DELIVER_WITHOUT_FOCUS");
+
 QTuioHandler::QTuioHandler(const QString &specification)
     : m_device(new QTouchDevice) // not leaked, QTouchDevice cleans up registered devices itself
 {
@@ -157,29 +165,49 @@ void QTuioHandler::processPackets()
             messages.push_back(msg);
         }
 
-        foreach (const QOscMessage &message, messages) {
-            if (message.addressPattern() != "/tuio/2Dcur") {
-                qWarning() << "Ignoring unknown address pattern " << message.addressPattern();
-                continue;
-            }
-
-            QList<QVariant> arguments = message.arguments();
-            if (arguments.count() == 0) {
-                qWarning("Ignoring TUIO message with no arguments");
-                continue;
-            }
-
-            QByteArray messageType = arguments.at(0).toByteArray();
-            if (messageType == "source") {
-                process2DCurSource(message);
-            } else if (messageType == "alive") {
-                process2DCurAlive(message);
-            } else if (messageType == "set") {
-                process2DCurSet(message);
-            } else if (messageType == "fseq") {
-                process2DCurFseq(message);
+        for (const QOscMessage &message : messages) {
+            if (message.addressPattern() == "/tuio/2Dcur") {
+                QList<QVariant> arguments = message.arguments();
+                if (arguments.count() == 0) {
+                    qWarning("Ignoring TUIO message with no arguments");
+                    continue;
+                }
+
+                QByteArray messageType = arguments.at(0).toByteArray();
+                if (messageType == "source") {
+                    process2DCurSource(message);
+                } else if (messageType == "alive") {
+                    process2DCurAlive(message);
+                } else if (messageType == "set") {
+                    process2DCurSet(message);
+                } else if (messageType == "fseq") {
+                    process2DCurFseq(message);
+                } else {
+                    qWarning() << "Ignoring unknown TUIO message type: " << messageType;
+                    continue;
+                }
+            } else if (message.addressPattern() == "/tuio/2Dobj") {
+                QList<QVariant> arguments = message.arguments();
+                if (arguments.count() == 0) {
+                    qWarning("Ignoring TUIO message with no arguments");
+                    continue;
+                }
+
+                QByteArray messageType = arguments.at(0).toByteArray();
+                if (messageType == "source") {
+                    process2DObjSource(message);
+                } else if (messageType == "alive") {
+                    process2DObjAlive(message);
+                } else if (messageType == "set") {
+                    process2DObjSet(message);
+                } else if (messageType == "fseq") {
+                    process2DObjFseq(message);
+                } else {
+                    qWarning() << "Ignoring unknown TUIO message type: " << messageType;
+                    continue;
+                }
             } else {
-                qWarning() << "Ignoring unknown TUIO message type: " << messageType;
+                qWarning() << "Ignoring unknown address pattern " << message.addressPattern();
                 continue;
             }
         }
@@ -328,11 +356,6 @@ void QTuioHandler::process2DCurFseq(const QOscMessage &message)
     Q_UNUSED(message); // TODO: do we need to do anything with the frame id?
 
     QWindow *win = QGuiApplication::focusWindow();
-    // With TUIO the first application takes exclusive ownership of the "device"
-    // we cannot attach more than one application to the same port anyway.
-    // Forcing delivery makes it easy to use simulators in the same machine
-    // and forget about headaches about unfocused TUIO windows.
-    static bool forceDelivery = qEnvironmentVariableIsSet("QT_TUIOTOUCH_DELIVER_WITHOUT_FOCUS");
     if (!win && QGuiApplication::topLevelWindows().length() > 0 && forceDelivery)
           win = QGuiApplication::topLevelWindows().at(0);
 
@@ -342,12 +365,12 @@ void QTuioHandler::process2DCurFseq(const QOscMessage &message)
     QList<QWindowSystemInterface::TouchPoint> tpl;
     tpl.reserve(m_activeCursors.size() + m_deadCursors.size());
 
-    foreach (const QTuioCursor &tc, m_activeCursors) {
+    for (const QTuioCursor &tc : m_activeCursors) {
         QWindowSystemInterface::TouchPoint tp = cursorToTouchPoint(tc, win);
         tpl.append(tp);
     }
 
-    foreach (const QTuioCursor &tc, m_deadCursors) {
+    for (const QTuioCursor &tc : m_deadCursors) {
         QWindowSystemInterface::TouchPoint tp = cursorToTouchPoint(tc, win);
         tp.state = Qt::TouchPointReleased;
         tpl.append(tp);
@@ -357,5 +380,181 @@ void QTuioHandler::process2DCurFseq(const QOscMessage &message)
     m_deadCursors.clear();
 }
 
+void QTuioHandler::process2DObjSource(const QOscMessage &message)
+{
+    QList<QVariant> arguments = message.arguments();
+    if (arguments.count() != 2) {
+        qWarning() << "Ignoring malformed TUIO source message: " << arguments.count();
+        return;
+    }
+
+    if (QMetaType::Type(arguments.at(1).type()) != QMetaType::QByteArray) {
+        qWarning("Ignoring malformed TUIO source message (bad argument type)");
+        return;
+    }
+
+    qCDebug(lcTuioSource) << "Got TUIO source message from: " << arguments.at(1).toByteArray();
+}
+
+void QTuioHandler::process2DObjAlive(const QOscMessage &message)
+{
+    QList<QVariant> arguments = message.arguments();
+
+    // delta the notified tokens that are active, against the ones we already
+    // know of.
+    //
+    // TBD: right now we're assuming one 2DObj alive message corresponds to a
+    // new data source from the input. is this correct, or do we need to store
+    // changes and only process the deltas on fseq?
+    QMap<int, QTuioToken> oldActiveTokens = m_activeTokens;
+    QMap<int, QTuioToken> newActiveTokens;
+
+    for (int i = 1; i < arguments.count(); ++i) {
+        if (QMetaType::Type(arguments.at(i).type()) != QMetaType::Int) {
+            qWarning() << "Ignoring malformed TUIO alive message (bad argument on position" << i << arguments << ')';
+            return;
+        }
+
+        int sessionId = arguments.at(i).toInt();
+        if (!oldActiveTokens.contains(sessionId)) {
+            // newly active
+            QTuioToken token(sessionId);
+            token.setState(Qt::TouchPointPressed);
+            newActiveTokens.insert(sessionId, token);
+        } else {
+            // we already know about it, remove it so it isn't marked as released
+            QTuioToken token = oldActiveTokens.value(sessionId);
+            token.setState(Qt::TouchPointStationary); // position change in SET will update if needed
+            newActiveTokens.insert(sessionId, token);
+            oldActiveTokens.remove(sessionId);
+        }
+    }
+
+    // anything left is dead now
+    QMap<int, QTuioToken>::ConstIterator it = oldActiveTokens.constBegin();
+
+    // deadTokens should be cleared from the last FSEQ now
+    m_deadTokens.reserve(oldActiveTokens.size());
+
+    // TODO: there could be an issue of resource exhaustion here if FSEQ isn't
+    // sent in a timely fashion. we should probably track message counts and
+    // force-flush if we get too many built up.
+    while (it != oldActiveTokens.constEnd()) {
+        m_deadTokens.append(it.value());
+        ++it;
+    }
+
+    m_activeTokens = newActiveTokens;
+}
+
+void QTuioHandler::process2DObjSet(const QOscMessage &message)
+{
+    QList<QVariant> arguments = message.arguments();
+    if (arguments.count() < 7) {
+        qWarning() << "Ignoring malformed TUIO set message with too few arguments: " << arguments.count();
+        return;
+    }
+
+    if (QMetaType::Type(arguments.at(1).type()) != QMetaType::Int ||
+            QMetaType::Type(arguments.at(2).type()) != QMetaType::Int ||
+            QMetaType::Type(arguments.at(3).type()) != QMetaType::Float ||
+            QMetaType::Type(arguments.at(4).type()) != QMetaType::Float ||
+            QMetaType::Type(arguments.at(5).type()) != QMetaType::Float ||
+            QMetaType::Type(arguments.at(6).type()) != QMetaType::Float ||
+            QMetaType::Type(arguments.at(7).type()) != QMetaType::Float ||
+            QMetaType::Type(arguments.at(8).type()) != QMetaType::Float ||
+            QMetaType::Type(arguments.at(9).type()) != QMetaType::Float ||
+            QMetaType::Type(arguments.at(10).type()) != QMetaType::Float) {
+        qWarning() << "Ignoring malformed TUIO set message with bad types: " << arguments;
+        return;
+    }
+
+    int id = arguments.at(1).toInt();
+    int classId = arguments.at(2).toInt();
+    float x = arguments.at(3).toFloat();
+    float y = arguments.at(4).toFloat();
+    float angle = arguments.at(5).toFloat();
+    float vx = arguments.at(6).toFloat();
+    float vy = arguments.at(7).toFloat();
+    float angularVelocity = arguments.at(8).toFloat();
+    float acceleration = arguments.at(9).toFloat();
+    float angularAcceleration = arguments.at(10).toFloat();
+
+    QMap<int, QTuioToken>::Iterator it = m_activeTokens.find(id);
+    if (it == m_activeTokens.end()) {
+        qWarning() << "Ignoring malformed TUIO set for nonexistent token " << classId;
+        return;
+    }
+
+    qCDebug(lcTuioSet) << "Processing SET for token " << classId << id << " @ " << x << y << "∡" << angle <<
+                          "vel" << vx << vy << angularVelocity << "acc" << acceleration << angularAcceleration;
+    QTuioToken &tok = *it;
+    tok.setClassId(classId);
+    tok.setX(x);
+    tok.setY(y);
+    tok.setVX(vx);
+    tok.setVY(vy);
+    tok.setAcceleration(acceleration);
+    tok.setAngle(angle);
+    tok.setAngularVelocity(angularAcceleration);
+    tok.setAngularAcceleration(angularAcceleration);
+}
+
+QWindowSystemInterface::TouchPoint QTuioHandler::tokenToTouchPoint(const QTuioToken &tc, QWindow *win)
+{
+    QWindowSystemInterface::TouchPoint tp;
+    tp.id = tc.id();
+    tp.uniqueId = tc.classId(); // TODO TUIO 2.0: populate a QVariant, and register the mapping from int to arbitrary UID data
+    tp.flags = QTouchEvent::TouchPoint::Token;
+    tp.pressure = 1.0f;
+
+    tp.normalPosition = QPointF(tc.x(), tc.y());
+
+    if (!m_transform.isIdentity())
+        tp.normalPosition = m_transform.map(tp.normalPosition);
+
+    tp.state = tc.state();
+    tp.area = QRectF(0, 0, 1, 1);
+
+    // We map the token position to the size of the window.
+    QPointF relPos = QPointF(win->size().width() * tp.normalPosition.x(), win->size().height() * tp.normalPosition.y());
+    QPointF delta = relPos - relPos.toPoint();
+    tp.area.moveCenter(win->mapToGlobal(relPos.toPoint()) + delta);
+    tp.velocity = QVector2D(win->size().width() * tc.vx(), win->size().height() * tc.vy());
+    tp.rotation = tc.angle() * 180.0 / M_PI; // convert radians to degrees
+    return tp;
+}
+
+
+void QTuioHandler::process2DObjFseq(const QOscMessage &message)
+{
+    Q_UNUSED(message); // TODO: do we need to do anything with the frame id?
+
+    QWindow *win = QGuiApplication::focusWindow();
+    if (!win && QGuiApplication::topLevelWindows().length() > 0 && forceDelivery)
+          win = QGuiApplication::topLevelWindows().at(0);
+
+    if (!win)
+        return;
+
+    QList<QWindowSystemInterface::TouchPoint> tpl;
+    tpl.reserve(m_activeTokens.size() + m_deadTokens.size());
+
+    for (const QTuioToken & t : m_activeTokens) {
+        QWindowSystemInterface::TouchPoint tp = tokenToTouchPoint(t, win);
+        tpl.append(tp);
+    }
+
+    for (const QTuioToken & t : m_deadTokens) {
+        QWindowSystemInterface::TouchPoint tp = tokenToTouchPoint(t, win);
+        tp.state = Qt::TouchPointReleased;
+        tp.velocity = QVector2D();
+        tpl.append(tp);
+    }
+    QWindowSystemInterface::handleTouchEvent(win, m_device, tpl);
+
+    m_deadTokens.clear();
+}
+
 QT_END_NAMESPACE