mythgesture.cpp

Go to the documentation of this file.

/* -*- myth -*- */
// Qt
#include <QMetaEnum>
 
// MythTV
#include "mythgesture.h"
 
// Std
#include <array>
#include <cmath>
#include <algorithm>
#include <complex>
 
const QEvent::Type MythGestureEvent::kEventType = static_cast<QEvent::Type>(QEvent::registerEventType());
 
MythGestureEvent::MythGestureEvent(Gesture gesture, Qt::MouseButton Button)
  : QEvent(kEventType),
    m_gesture(gesture),
    m_button(Button)
{
}
 
const std::map<QString, MythGestureEvent::Gesture>MythGesture::kSequences =
{
    { "1",     MythGestureEvent::LongClick },
    { "5",     MythGestureEvent::Click },
    { "456",   MythGestureEvent::Right },
    { "654",   MythGestureEvent::Left  },
    { "258",   MythGestureEvent::Down  },
    { "852",   MythGestureEvent::Up    },
    { "951",   MythGestureEvent::UpLeft    },
    { "753",   MythGestureEvent::UpRight   },
    { "159",   MythGestureEvent::DownRight },
    { "357",   MythGestureEvent::DownLeft  },
    { "96321", MythGestureEvent::UpThenLeft    },
    { "74123", MythGestureEvent::UpThenRight   },
    { "36987", MythGestureEvent::DownThenLeft  },
    { "14789", MythGestureEvent::DownThenRight },
    { "32147", MythGestureEvent::LeftThenDown  },
    { "98741", MythGestureEvent::LeftThenUp    },
    { "12369", MythGestureEvent::RightThenDown },
    { "78963", MythGestureEvent::RightThenUp   },
    { "45654", MythGestureEvent::RightThenLeft },
    { "65456", MythGestureEvent::LeftThenRight },
    { "85258", MythGestureEvent::UpThenDown    },
    { "25852", MythGestureEvent::DownThenUp    }
};
 
QString MythGestureEvent::GetName() const
{
    return QMetaEnum::fromType<Gesture>().valueToKey(m_gesture);
}
 
QString MythGestureEvent::GetButtonName() const
{
    return QMetaEnum::fromType<Qt::MouseButtons>().valueToKey(static_cast<int>(m_button));
}
 
MythGesture::MythGesture(size_t MaxPoints, size_t MinPoints,
                         size_t MaxSequence, int ScaleRatio,
                         float BinPercent)
  : m_maxPoints(MaxPoints),
    m_minPoints(MinPoints),
    m_maxSequence(MaxSequence),
    m_scaleRatio(ScaleRatio),
    m_binPercent(BinPercent)
{
}
 
void MythGesture::AdjustExtremes(int X, int Y)
{
    m_minX = std::min(m_minX, X);
    m_maxX = std::max(m_maxX, X);
    m_minY = std::min(m_minY, Y);
    m_maxY = std::max(m_maxY, Y);
}
 
bool MythGesture::Recording(void)
{
    m_lock.lock();
    bool temp = m_recording;
    m_lock.unlock();
    return temp;
}
 
void MythGesture::Start(void)
{
    m_lock.lock();
    m_recording = true;
    m_lock.unlock();
}
 
 
void MythGesture::Stop(bool Timeout)
{
    m_lock.lock();
 
    if (m_recording)
    {
        m_recording = false;
 
        // translate before resetting maximums
        const QString gesture = Translate(Timeout);
        auto found = kSequences.find(gesture);
        if (found != kSequences.cend())
            m_lastGesture = found->second;
        else
            m_lastGesture = MythGestureEvent::Unknown;
 
        m_minX = m_minY = 10000;
        m_maxX = m_maxY = -1;
    }
 
    m_lock.unlock();
}
 
 
MythGestureEvent *MythGesture::GetGesture(void) const
{
    return new MythGestureEvent(m_lastGesture, m_lastButton);
}
 
/* comments in header */
static int determineBin (QPoint p, int x1, int x2, int y1, int y2)
{
    int bin_num = 1;
    if (p.x() > x1)
        bin_num += 1;
    if (p.x() > x2)
        bin_num += 1;
    if (p.y() > y1)
        bin_num += 3;
    if (p.y() > y2)
        bin_num += 3;
 
    return bin_num;
}
 
 
QString MythGesture::Translate(bool Timeout)
{
    auto total_points = static_cast<size_t>(m_points.count());
 
    if (total_points > m_maxPoints)
    {
        m_points.clear();
        return "0";
    }
 
    /* treat any stroke with less than the minimum number of points as
     * a click (not a drag), which is the center bin */
    if (total_points < m_minPoints)
    {
        m_points.clear();
        if (Timeout)
            return "1";
        return "5";
    }
 
    QString sequence;
 
    /* number of bins recorded in the stroke */
    size_t sequence_count = 0;
 
    /* points-->sequence translation scratch variables */
    int prev_bin = 0;
    int current_bin = 0;
    int bin_count = 0;
 
    /*flag indicating the start of a stroke - always count it in the sequence*/
    bool first_bin = true;
 
    /* determine size of grid */
    int delta_x = m_maxX - m_minX;
    int delta_y = m_maxY - m_minY;
 
    /* calculate bin boundary positions */
    int bound_x_1 = m_minX + (delta_x / 3);
    int bound_x_2 = m_minX + (2 * (delta_x / 3));
 
    int bound_y_1 = m_minY + (delta_y / 3);
    int bound_y_2 = m_minY + (2 * (delta_y / 3));
 
    if (delta_x > m_scaleRatio * delta_y)
    {
        bound_y_1 = ((m_maxY + m_minY - delta_x) / 2) + (delta_x / 3);
        bound_y_2 = ((m_maxY + m_minY - delta_x) / 2) + (2 * (delta_x / 3));
    }
    else if (delta_y > m_scaleRatio * delta_x)
    {
        bound_x_1 = ((m_maxX + m_minX - delta_y) / 2) + (delta_y / 3);
        bound_x_2 = ((m_maxX + m_minX - delta_y) / 2) + (2 * (delta_y / 3));
    }
 
    /* build string by placing points in bins, collapsing bins and
       discarding those with too few points... */
 
    while (!m_points.empty())
    {
        QPoint pt = m_points.front();
        m_points.pop_front();
 
        /* figure out which bin the point falls in */
        current_bin = determineBin(pt, bound_x_1, bound_x_2, bound_y_1,
                                   bound_y_2);
 
        /* if this is the first point, consider it the previous bin, too. */
        prev_bin = (prev_bin == 0) ? current_bin : prev_bin;
 
        if (prev_bin == current_bin)
            bin_count++;
        else
        {
 
            /* we are moving to a new bin -- consider adding to the
               sequence */
            if ((bin_count > (total_points * m_binPercent)) || first_bin)
            {
                first_bin = false;
                sequence += '0' + QChar(prev_bin);
                sequence_count ++;
            }
 
            /* restart counting points in the new bin */
            bin_count = 0;
            prev_bin = current_bin;
        }
    }
 
    /* add the last run of points to the sequence */
    sequence += '0' + QChar(current_bin);
    sequence_count++;
 
    /* bail out on error cases */
    if (sequence_count > m_maxSequence)
        sequence = '0';
 
    return sequence;
}
 
 
bool MythGesture::HasMinimumPoints() const
{
    return static_cast<size_t>(m_points.size()) >= m_minPoints;
}
 
bool MythGesture::Record(QPoint Point, Qt::MouseButton Button)
{
    /* only record if we haven't exceeded the maximum points */
    if ((static_cast<size_t>(m_points.size()) >= m_maxPoints) || !Recording())
        return false;
 
    m_lastButton = Button;
 
    if (m_points.empty())
    {
        m_points.push_back(Point);
        return true;
    }
 
    /* interpolate between last and current point */
    int delx = Point.x() - m_points.back().x();
    int dely = Point.y() - m_points.back().y();
 
    /* step by the greatest delta direction */
    if (abs(delx) > abs(dely))
    {
        float fy = m_points.back().y();
 
        /* go from the last point to the current, whatever direction
         * it may be */
        for (int ix = m_points.back().x();
             (delx > 0) ? (ix < Point.x()) : (ix > Point.x());
             ix += (delx > 0) ? 1 : -1)
        {
            /* step the other axis by the correct increment */
            fy += std::fabs(static_cast<float>(dely) / static_cast<float>(delx))
                * ((dely < 0) ? -1.0F : 1.0F);
            int iy = static_cast<int>(fy);
 
            /* add the interpolated point */
            m_points.push_back(QPoint(ix, iy));
            AdjustExtremes(ix, iy);
        }
    }
    else /* same thing, but for dely larger than delx case... */
    {
        float fx = m_points.back().x();
 
        /* go from the last point to the current, whatever direction
           it may be */
        for (int iy = m_points.back().y();
             (dely > 0) ? (iy < Point.y()) : (iy > Point.y());
             iy += (dely > 0) ? 1 : -1)
        {
            /* step the other axis by the correct increment */
            fx += std::fabs(static_cast<float>(delx) / static_cast<float>(dely))
                * ((delx < 0) ? -1.0F : 1.0F);
            int ix = static_cast<int>(fx);
 
            /* add the interpolated point */
            m_points.push_back(QPoint(ix, iy));
            AdjustExtremes(ix, iy);
        }
    }
 
    m_points.push_back(Point);
 
    return true;
}