annotate common/Matcher.cpp @ 53:bcea875d8d2f tip

More build fixes

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

#include "Matcher.h"
#include "Objects.h"
#include "EditDistance.h"

#include <QMultiMap>

#include <iostream>

using namespace Dataquay;

namespace ClassicalData {

ComposerTypingQuickMatcher::ComposerTypingQuickMatcher(QList<Composer *> cl) :
    m_composers(cl)
{
}

GuessList
ComposerTypingQuickMatcher::match(QString text, int maxResults,
                                  float threshold) const
{
    GuessList results;
    GuessSet matches;

    foreach (Composer *c, m_composers) {
        float value = c->matchTypingQuick(text);
        if (value < threshold) continue;
        matches.insert(Guess(value, c));
    }
    
    int n = 0;
    for (GuessSet::const_iterator i = matches.begin();
         i != matches.end(); ++i) {
        results.push_back(*i);
        if (maxResults > 0 && ++n > maxResults) break;
    }

    return results;
}

ComposerTypingThoroughMatcher::ComposerTypingThoroughMatcher(QList<Composer *> cl) :
    m_composers(cl)
{
}

GuessList
ComposerTypingThoroughMatcher::match(QString text, int maxResults,
                                     float threshold) const
{
    GuessList results;

    GuessSet matches;
    foreach (Composer *c, m_composers) {
        float value = c->matchTyping(text);
        if (value < threshold) continue;
        matches.insert(Guess(value, c));
    }
    
    int n = 0;
    for (GuessSet::const_iterator i = matches.begin();
         i != matches.end(); ++i) {
        results.push_back(*i);
        if (maxResults > 0 && ++n > maxResults) break;
    }

    return results;
}

ComposerFullTextMatcher::ComposerFullTextMatcher(QList<Composer *> cl) :
    m_composers(cl)
{
}

GuessList
ComposerFullTextMatcher::match(QString text, int maxResults,
                               float threshold) const
{
    GuessList results;

    GuessSet matches;
    foreach (Composer *c, m_composers) {
        float value = c->matchFuzzyName(text);
        if (value < threshold) continue;
//        std::cerr << "Liking: " << c->name().toStdString() << " (" << value << ")" << std::endl;
        matches.insert(Guess(value, c));
    }
    
    int n = 0;
    for (GuessSet::iterator i = matches.begin();
         i != matches.end(); ++i) {
        Guess g = *i;
        results.push_back(g);
//        std::cerr << "Pushing: " << g.entity()->name().toStdString() << std::endl;
        if (maxResults > 0 && ++n > maxResults) break;
    }

    return results;
}

WorkCatalogueMatcher::WorkCatalogueMatcher(QList<Work *> wl) :
    m_works(wl)
{
}

GuessList
WorkCatalogueMatcher::match(QString text, int maxResults,
                            float threshold) const
{
    GuessList results;
    GuessSet matches;
    QStringList cats = Work::extractCatalogueNumberTexts(text);
    if (cats.empty()) return results;
    foreach (QString cat, cats) {
        std::cerr << "testing cat \"" << cat.toStdString() << "\" against "
                  << m_works.size() << " works" << std::endl;
        foreach (Work *w, m_works) {
            if (maxResults > 0 && matches.size() >= maxResults) {
                break;
            }
            QString catalogue = w->catalogue();
            if (catalogue != "") {
                if (!Work::compareCatalogueNumberTexts(catalogue, cat)) {
                    std::cerr << "We like: " << w->name().toStdString() << " ("
                              << catalogue.toStdString() << ")" << std::endl;
                    // all catalogue matches score equal here
                    matches.insert(Guess(1.f, w));
                    continue;
                }
            }
            QString opus = w->opus();
            QString number = w->number();
            QString optext;
            if (opus != "") {
                if (number != "") {
                    optext = QString("Op %1 no %2").arg(opus).arg(number);
                    if (!Work::compareCatalogueNumberTexts(optext, cat)) {
                        std::cerr << "We like: " << w->name().toStdString() << " ("
                                  << optext.toStdString() << ")" << std::endl;
                        matches.insert(Guess(1.f, w));
                        continue;
                    }
                } else {
                    optext = QString("Op %1").arg(opus);
                    if (!Work::compareCatalogueNumberTexts(optext, cat)) {
                        std::cerr << "We like: " << w->name().toStdString() << " ("
                                  << optext.toStdString() << ")" << std::endl;
                        matches.insert(Guess(1.f, w));
                        continue;
                    }
                }
            }
        }
    }

    if (maxResults == 0 || matches.size() < maxResults) {

        // Now, for slightly lower marks, test for strings like
        // "Symphony no 8" at the start of the title, or after a
        // colon, slash or dash (e.g. "Brahms: Symphony no 4")

        QRegExp numberRe1("^([^\\d]+)\\s+[Nn][a-z]*\\.?\\s*(\\d+)");
        QRegExp numberRe2("[/:-]\\s*(\\w[^\\d]+)\\s+[Nn][a-z]*\\.?\\s*(\\d+)");
        QString tag, number;

        if (numberRe1.indexIn(text) >= 0) {
            tag = numberRe1.cap(1);
            number = numberRe1.cap(2);
        } else if (numberRe2.indexIn(text) >= 0) {
            tag = numberRe2.cap(1);
            number = numberRe2.cap(2);
        }
        
        if (tag != "") {

            std::cerr << "tag = \"" << tag.toStdString() << "\", number = \""
                      << number.toStdString() << "\"" << std::endl;

            tag.replace(QRegExp("[^\\w\\s]+"), "");
            QString matcherReStr =
                QString("^%1\\s+[Nn][a-z]*\\.?\\s*%2\\b").arg(tag).arg(number);
            QRegExp matcherRe(matcherReStr, Qt::CaseInsensitive);
            std::cerr << "matcherRe: " << matcherReStr.toStdString() << std::endl;

            // initials only
/* nah, doesn't work well
            QString weakTag;
            QRegExp initialRe("\\b(\\w)\\w*\\b");
            int ix = 0;
            while ((ix = initialRe.indexIn(tag, ix)) >= 0) {
                if (ix > 0) weakTag += "\\s+";
                weakTag += initialRe.cap(1) + "\\w*";
                ++ix;
            }
            
            QString weakMatcherReStr =
                QString("^%1\\s+[Nn][a-z]*\\.?\\s*%2\\b").arg(weakTag).arg(number);
            QRegExp weakMatcherRe(weakMatcherReStr, Qt::CaseInsensitive);
            std::cerr << "weakMatcherRe: " << weakMatcherReStr.toStdString() << std::endl;
*/
            foreach (Work *w, m_works) {
                if (maxResults > 0 && matches.size() >= maxResults) {
                    break;
                }
                QString name = w->name();
                if (matcherRe.indexIn(name) >= 0) {
                    std::cerr << "We quite like: " << name.toStdString() << std::endl;
                    matches.insert(Guess(0.8f, w));
                }
/* else if (weakMatcherRe.indexIn(name) >= 0) {
                    std::cerr << "We sorta like: " << name.toStdString() << std::endl;
                    matches.insert(Guess(0.2f, w));
                }
*/
            }
        }
    }
    
    int n = 0;
    for (GuessSet::const_iterator i = matches.begin();
         i != matches.end(); ++i) {
        results.push_back(*i);
        if (maxResults > 0 && ++n > maxResults) break;
    }

    return results;
}

WorkTitleMatcher::WorkTitleMatcher(QList<Work *> wl) :
    m_works(wl)
{
}

GuessList
WorkTitleMatcher::match(QString text, int maxResults,
                        float threshold) const
{
    GuessList results;
    GuessSet matches;

    // Throw away any initial numbers (likely to be track index)
    text = text.replace(QRegExp("^[0-9]+"), "");

    QString quoted;
    QRegExp quoteRe("(^|\\s)[\"']([^\"]+)[\"']($|[^\\w])");
    int qthresh = 0;
    
    if (quoteRe.indexIn(text) >= 0) {
        quoted = quoteRe.cap(2);
        if (quoted.length() < 4) quoted = "";
        qthresh = quoted.length() / 4;
    }

    std::cerr << "text = " << text.toStdString() << ", quoted = "
              << quoted.toStdString() << std::endl;

    QStringList components =
        text.split(QRegExp("[^\\w]+"), QString::SkipEmptyParts);
    QStringList reduced;
    foreach (QString c, components) {
        QString r = Composer::reduceName(c.toLower());
        if (r != "") {
            if (r.length() > 3 || r[0].isDigit()) {
                reduced.push_back(r);
            }
        }
    }

    std::cerr << "reduced = " << reduced.join(" ").toStdString() << std::endl;

    EditDistance ed;

    foreach (Work *w, m_works) {
        if (maxResults > 0 && matches.size() >= maxResults) {
            break;
        }

        float highScore = 0.f;

        QSet<QString> names = w->aliases();
        names.insert(w->name());

        foreach (QString name, names) {

            float pro = 0.f;
            float con = 0.f;

            if (quoted != "") {
                if (quoteRe.indexIn(name) >= 0) {
                    QString q = quoteRe.cap(1);
                    int dist = ed.calculate(quoted, q, qthresh);
                    if (dist < qthresh) {
                        std::cerr << "quoted name match: " << q.toStdString() << std::endl;
                        pro += 0.7f - 0.1f * dist;
                        if (pro - con > highScore) {
                            highScore = pro - con;
                            continue;
                        }
                    }
                }
            }

            QStringList wcomp =
                name.split(QRegExp("[^\\w]+"), QString::SkipEmptyParts);
            QSet<QString> wr;
            foreach (QString wc, wcomp) {
                wr.insert(Composer::reduceName(wc.toLower()));
            }
            foreach (QString rc, reduced) {
                if (wr.contains(rc)) {
                    std::cerr << "component match: " << rc.toStdString() << std::endl;
                    pro += 0.1;
                } else {
                    con += 0.101;
                    if (con > 0.25) con = 0.25;
                }
            }

            if (pro - con > highScore) highScore = pro - con;
        }

        if (highScore > 0.f) {
            std::cerr << "for " << w->name().toStdString() << " highScore = " << highScore << std::endl;
            matches.insert(Guess(highScore, w));
        }
    }
    
    int n = 0;
    for (GuessSet::const_iterator i = matches.begin();
         i != matches.end(); ++i) {
        results.push_back(*i);
        if (maxResults > 0 && ++n > maxResults) break;
    }

    return results;
}

}