petrack.cpp

    if(pos != nullptr)
    {
        return mHeadSize; // muss noch aus density map gelesen werden!!!
    }
    else //(pos == NULL) && (pers == -1)
    {
        return mHeadSize;
    }
}

void Petrack::setProFileName(const QString &fileName)
{
    // don't change project Name to an autosave
    if(mAutosave.isAutosave(fileName) || fileName == mProFileName)
    {
        return;
    }

    // Change project => delete old autosave
    mAutosave.deleteAutosave();
    // NOTE: Use only the global variant in future?
    // global one in helper.h because it is needed to use getFileList and shouldn't depend on Petrack
    proFileName  = fileName;
    mProFileName = fileName;
    updateWindowTitle();
}

/**
 * @brief Return the user's selection of pedestrians/trajectories
 *
 * Only people selected via "show only people" (single person) or "show only
 * people list"(multiple persons) are going to be selected.
 *
 * @return All user selected pedestrian (empty for all pedestrians)
 */
QSet<size_t> Petrack::getPedestrianUserSelection()
{
    if(mControlWidget->trackShowOnly->checkState() == Qt::Checked)
    {
        QSet<size_t> onlyVisible;
        // subtraction needed as in UI ID start at 1 and internally at 0
        onlyVisible.insert(mControlWidget->trackShowOnlyNr->value() - 1);
        return onlyVisible;
    }
    if(mControlWidget->trackShowOnlyList->checkState() == Qt::Checked)
    {
        auto enteredIDs = util::splitStringToInt(mControlWidget->trackShowOnlyNrList->text());
        if(enteredIDs.has_value())
        {
            QSet<size_t> selectedIDs;
            for(auto id : enteredIDs.value())
            {
                // subtraction needed as in UI ID start at 1 and internally at 0
                selectedIDs.insert(id - 1);
            }
            mControlWidget->trackShowOnlyNrList->setStyleSheet("");
            return selectedIDs;
        }
        else
        {
            mControlWidget->trackShowOnlyNrList->setStyleSheet("border: 1px solid red");
        }
    }
    return QSet<size_t>();
}

/**
 * @brief Splits the given text to get a set of integers.
 *
 * The given text will be split on ',' and then each element will be checked if it is a range. Ranges are marked with
 * '-' as divider. Only positive integer values are allowed.
 *
 * Examples:
 * '1,5,6' -> (1, 5, 6)
 * '1-5' -> (1, 2, 3, 4, 5)
 *
 * @param input given text
 * @return Set of int in the given text
 */
std::optional<QSet<int>> util::splitStringToInt(const QString &input)
{
    QSet<int> ids;

    for(const auto &id : input.split(",", Qt::SkipEmptyParts))
    {
        bool ok        = false;
        int  enteredID = id.toInt(&ok);
        if(ok && enteredID >= 0) // parse single values
        {
            ids.insert(enteredID);
        }
        else // error or IDs range (e.g. 1-3, 6-10, etc.)
        {
            if(id.startsWith("-"))
            {
                ok = false;
            }
            auto range = id.split("-");
            int  first = range[0].toInt(&ok);
            ok         = ok && range.size() == 2 && !range[1].isEmpty();
            if(ok)
            {
                int last = range[1].toInt(&ok);
                if(ok)
                {
                    if(first > last)
                    {
                        std::swap(first, last);
                    }

                    for(int i = first; i <= last; i++)
                    {
                        ids.insert(i);
                    }
                }
            }
        }
        if(!ok)
        {
            return std::nullopt;
        }
    }
    return ids;
}

/**
 * @brief Checks which pedestrians/trajectories are selected for evaluation.
 *
 * If "only for selected" is checked, then only selected people (@see
 * Petrack::getPedestrianUserSelection()) are going to be tracked, all people
 * otherwise.
 *
 * @return all trajectories which should be evaluated; empty when all should be evaluated
 */
QSet<size_t> Petrack::getPedestriansToTrack()
{
    if(mControlWidget->trackOnlySelected->checkState() == Qt::Checked)
    {
        return getPedestrianUserSelection();
    }

    return QSet<size_t>();
}

void Petrack::addManualTrackPointOnlyVisible(const QPointF &pos)
{
    int pers = addOrMoveManualTrackPoint(pos) + 1;
    if(pers == 0)
    {
        pers = static_cast<int>(mPersonStorage.nbPersons()) + 1;
    }
    mControlWidget->trackShowOnlyNr->setValue(pers);
    mControlWidget->trackShowOnly->setChecked(true);
}

void Petrack::updateControlWidget()
{
    mControlWidget->trackNumberAll->setText(QString("%1").arg(mPersonStorage.nbPersons()));
    mControlWidget->trackShowOnlyNr->setMaximum(static_cast<int>(MAX(mPersonStorage.nbPersons(), 1)));
    mControlWidget->trackNumberVisible->setText(
        QString("%1").arg(mPersonStorage.visible(mAnimation->getCurrentFrameNum())));
}

void Petrack::splitTrackPerson(QPointF pos)
{
    mPersonStorage.splitPersonAt((Vec2F) pos, mAnimation->getCurrentFrameNum(), getPedestrianUserSelection());
    updateControlWidget();
}

/**
 * @brief Lets the user add or move a TrackPoint manually
 *
 * There is an check inside addPoint which inhibits adding a point,
 * if only selected trajectories are visualized, since one wouldn't
 * see the newly added TrackPoint.
 *
 * @param pos pixel position of mouse on image
 * @return index of person whose point was moved; -1 if failed or new trajectory is started
 */
int Petrack::addOrMoveManualTrackPoint(const QPointF &pos)
{
    int        pers = -1;
    TrackPoint tP(Vec2F{pos}, 110); // 110 is higher than 100 (max. quality) and gets clamped to 100 after insertion
    // allows replacemet of every point (check for better quality always passes)
    mPersonStorage.addPoint(
        tP, mAnimation->getCurrentFrameNum(), getPedestrianUserSelection(), mReco.getRecoMethod(), &pers);
    updateControlWidget();
    return pers;
}

// direction zeigt an, ob bis zum aktuellen (-1), ab dem aktuellen (1) oder ganzer trackpath (0)
// loeschen von Trackpoints einer Trajektorie
void Petrack::deleteTrackPoint(QPointF pos, int direction) // const QPoint &pos
{
    mPersonStorage.delPoint((Vec2F) pos, direction, mAnimation->getCurrentFrameNum(), getPedestrianUserSelection());
    updateControlWidget();
}
void Petrack::editTrackPersonComment(QPointF pos)
{
    mPersonStorage.editTrackPersonComment((Vec2F) pos, mAnimation->getCurrentFrameNum(), getPedestrianUserSelection());
    updateControlWidget();
}
void Petrack::setTrackPersonHeight(QPointF pos)
{
    mPersonStorage.setTrackPersonHeight((Vec2F) pos, mAnimation->getCurrentFrameNum(), getPedestrianUserSelection());
    updateControlWidget();
}
void Petrack::resetTrackPersonHeight(QPointF pos)
{
    mPersonStorage.resetTrackPersonHeight((Vec2F) pos, mAnimation->getCurrentFrameNum(), getPedestrianUserSelection());
    updateControlWidget();
}

/**
 * @brief Delete the following, previous or whole trajectory of **all** trajectories
 * @param direction previous, following or whole
 */
void Petrack::deleteTrackPointAll(PersonStorage::Direction direction) // const QPoint &pos
{
    mPersonStorage.delPointAll(direction, mAnimation->getCurrentFrameNum());
    updateControlWidget();
}

void Petrack::deleteTrackPointROI()
{
    mPersonStorage.delPointROI();
    updateControlWidget();
    mScene->update();
}

void Petrack::deleteTrackPointInsideROI()
{
    getPersonStorage().delPointInsideROI();
    updateControlWidget();
    mScene->update();
}

void Petrack::moveTrackPoint(QPointF pos)
{
    mManualTrackPointMover.moveTrackPoint(pos, mPersonStorage);
    mScene->update();
}

void Petrack::selectPersonForMoveTrackPoint(QPointF pos)
{
    FrameRange range;
    range.before  = mControlWidget->trackShowBefore->value();
    range.after   = mControlWidget->trackShowAfter->value();
    range.current = mPlayerWidget->getPos();
    auto successfullySelected =
        mManualTrackPointMover.selectTrackPoint(pos, mPersonStorage, getPedestrianUserSelection(), range);

    if(successfullySelected)
    {
        setCursor(QCursor{Qt::CursorShape::DragMoveCursor});
    }
}

void Petrack::releaseTrackPoint()
{
    mManualTrackPointMover.setTrackPoint();
    mAutosave.trackPersonModified();
    setCursor(QCursor{});
}

void Petrack::scrollShowOnly(int delta)
{
    if(delta < 0)
    {
        mControlWidget->trackShowOnlyNr->stepDown();
    }
    else
    {
        mControlWidget->trackShowOnlyNr->stepUp();
    }
}

void Petrack::updateSourceInOutFrames()
{
    mPlayerWidget->setFrameInNum(mAnimation->getSourceInFrameNum());
    mPlayerWidget->setFrameOutNum(mAnimation->getSourceOutFrameNum());
}

// delta gibt menge an Umdrehungen und richtung an
void Petrack::skipToFrameWheel(int delta)
{
    mPlayerWidget->skipToFrame(mPlayerWidget->getPos() + delta);
}

void Petrack::skipToFrameFromTrajectory(QPointF pos)
{
    auto       peds      = getPedestrianUserSelection();
    const auto before    = mControlWidget->trackShowBefore->value();
    const auto after     = mControlWidget->trackShowAfter->value();
    const auto currFrame = mPlayerWidget->getPos();
    FrameRange frameRange{before, after, currFrame};

    auto res = mPersonStorage.getProximalPersons(pos, peds, frameRange);

    if(res.size() == 1)
    {
        mPlayerWidget->skipToFrame(res.front().frame);
    }
    else if(res.size() > 1)
    {
        PWarning(
            this,
            tr("Too many trajectories"),
            tr("PeTrack can't determine which point you meant. Try selecting fewer trajectories first."));
    }
}

void Petrack::setPeTrackVersion(const std::string &petrackVersion)
{
    mPetrackVersion = QString::fromStdString(petrackVersion);
    updateWindowTitle();
}

void Petrack::setGitInformation(
    const std::string &gitCommitID,
    const std::string &gitCommitDate,
    const std::string &gitCommitBranch)
{
    mGitCommitID     = QString::fromStdString(gitCommitID);
    mGitCommitDate   = QString::fromStdString(gitCommitDate);
    mGitCommitBranch = QString::fromStdString(gitCommitBranch);
}

void Petrack::setCompileInformation(
    const std::string &compileTimeStamp,
    const std::string &compilerID,
    const std::string &compilerVersion)
{
    mCompileDate     = QString::fromStdString(compileTimeStamp);
    mCompilerID      = QString::fromStdString(compilerID);
    mCompilerVersion = QString::fromStdString(compilerVersion);
}

#include "moc_petrack.cpp"