petrack.cpp

    {
        if( mControlWidget->getCalibCoordDimension() == 0 )
        {

            //debout << "getHeadSize: " << pers << " " << frame << endl;
            //debout << mTracker->at(pers).trackPointAt(frame) << endl;

//            debout << "mTracker->at(pers).height(): " << mTracker->at(pers).height() << endl;
//            debout << "mControlWidget->mapDefaultHeight->value(): " << mControlWidget->mapDefaultHeight->value() << endl;
//            debout << "mControlWidget->mapHeight->value(): " << mControlWidget->mapHeight->value() << endl;
            int diff;
            cv::Point3f p3d = getExtrCalibration()->get3DPoint(cv::Point2f(mTracker->at(pers).trackPointAt(frame).x(),
                                                            mTracker->at(pers).trackPointAt(frame).y()),
                                                           mControlWidget->mapDefaultHeight->value());
                                                           //mTracker->at(pers).height()); // mStatusPosRealHeight->value());

//            debout << "Track position: (" << mTracker->at(pers).trackPointAt(frame).x() << ", " << mTracker->at(pers).trackPointAt(frame).y() << ")" << endl;
//            debout << "P3D: (" << p3d.x << ", " << p3d.y << ", " << p3d.z << ")" << endl;

            //debout << "3D Punkt: x: " << p3d.x << ", y: " << p3d.y << ", z: " << p3d.z << endl;

            cv::Point2f p3d_x1 = getExtrCalibration()->getImagePoint( cv::Point3f(p3d.x+HEAD_SIZE*0.5, p3d.y, p3d.z) );
            cv::Point2f p3d_x2 = getExtrCalibration()->getImagePoint( cv::Point3f(p3d.x-HEAD_SIZE*0.5, p3d.y, p3d.z) );
            cv::Point2f p3d_y1 = getExtrCalibration()->getImagePoint( cv::Point3f(p3d.x, p3d.y+HEAD_SIZE*0.5, p3d.z) );
            cv::Point2f p3d_y2 = getExtrCalibration()->getImagePoint( cv::Point3f(p3d.x, p3d.y-HEAD_SIZE*0.5, p3d.z) );

            diff = (int) std::max(sqrt(pow(p3d_x2.x-p3d_x1.x,2)+pow(p3d_x2.y-p3d_x1.y,2)),
                           sqrt(pow(p3d_y2.x-p3d_y1.x,2)+pow(p3d_y2.y-p3d_y1.y,2)));
//                    max(abs(getExtrCalibration()->getImagePoint(Point3f(p3d.x+HEAD_SIZE*0.5, p3d.y,               p3d.z)).x-
//                                 getExtrCalibration()->getImagePoint(Point3f(p3d.x-HEAD_SIZE*0.5, p3d.y,               p3d.z)).x)
//                                ,abs(getExtrCalibration()->getImagePoint(Point3f(p3d.x,           p3d.y+HEAD_SIZE*0.5, p3d.z)).y-
//                                 getExtrCalibration()->getImagePoint(Point3f(p3d.x,               p3d.y-HEAD_SIZE*0.5, p3d.z)).y));
//            debout << "HeadSize: " << diff << endl;
            return diff;// < 8 ? 8 : diff;
        }else
        {
            z = mTracker->at(pers).trackPointAt(frame).sp().z();
            h = mTracker->at(pers).height();
            if (z > 0)
                return (HEAD_SIZE*mControlWidget->coordAltitude->value() / z) / getImageItem()->getCmPerPixel();
            else if (h > MIN_HEIGHT)
                return (HEAD_SIZE*mControlWidget->coordAltitude->value() / (mControlWidget->coordAltitude->value()-h)) / getImageItem()->getCmPerPixel();
            else
                return mHeadSize;
        }
    }

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

}

/**
 * @brief Petrack::getOnlyVisible Returns trajectories which should be evaluated
 *
 * If "only for visible people" is checked, then only people visible via
 * "show only people" (single person) or "show only people list"(multiple persons)
 * are going to be evaluated. If "only for visible people" is not checked,
 * everyone gets evaluated, not only the ones selected for visibility.
 *
 * @return all trajectories which should be evaluated; empty when all should be evaluated
 */
QSet<int> Petrack::getOnlyVisible()
{
    if  ((mControlWidget->trackOnlyVisible->checkState() == Qt::Checked) && (mControlWidget->trackShowOnly->checkState() == Qt::Checked || mControlWidget->trackShowOnlyList->checkState() == Qt::Checked))
    {
//        int maxPed = mTracker->size();
        if( mControlWidget->trackShowOnlyList->checkState() == Qt::Checked)
        {
            QStringList list = mControlWidget->trackShowOnlyNrList->text().split(",", Qt::SkipEmptyParts);
            QSet<int> onlyVisible;
            foreach(QString s, list)
            {
                bool ok = false;
                int nr = s.toInt(&ok);
                if(ok/* && nr <= maxPed && nr > 0*/) // einzelne ID
                    onlyVisible.insert(nr-1);
                else // error or IDs range (e.g. 1-3, 6-10, etc.)
                {
                    QStringList range = s.split("-", Qt::SkipEmptyParts);
                    int last,first = range[0].toInt(&ok);

                    if(ok/* && first <= maxPed && nr > 0*/)
                    {
                        last = range[1].toInt(&ok);
                        if(ok/* && last <= maxPed && nr > 0*/)
                        {
                            if(first>last)
                                std::swap(first,last);

                            for(int i=first;i<=last;i++)
                                onlyVisible.insert(i-1);
                        }
                    }

                }
                if(!ok)
                    debout << "Warning: error while reading showOnlyVisible list from input line!" << std::endl;
            }
            return onlyVisible; //in anzeige wird ab 1 gezaehlt, in datenstruktur ab 0

        }else // if(ControlWidget->trackShowOnly->checkState() == Qt::Checked) //
        {
            QSet<int> onlyVisible;
            onlyVisible.insert(mControlWidget->trackShowOnlyNr->value()-1);
            return onlyVisible;
        }
    }else
        return QSet<int>();
}

void Petrack::addManualTrackPointOnlyVisible(const QPointF& pos)
{
    int pers = addOrMoveManualTrackPoint(pos)+1;
    if (pers == 0)
        pers = mTracker->size()+1;
    pers = mControlWidget->trackShowOnlyNr->maximum();
    mControlWidget->trackShowOnlyNr->setValue(pers);
//    mControlWidget->trackShowOnlyNr->setText(QString::number(pers));
    mControlWidget->trackShowOnly->setChecked(true);
}

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

//void Petrack::showContextMenu(QPointF pos)
//{
//    QMenu menu(this);
//    menu.addAction(mDelPastAct);
//    menu.addAction(mDelFutureAct);
//    menu.addAction(mDelAllRoiAct);
//    menu.exec(pos.toPoint());
//}

void Petrack::splitTrackPerson(QPointF pos)
{
    mTracker->splitPersonAt((Vec2F) pos, mAnimation->getCurrentFrameNum(), getOnlyVisible());
    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)
    mTracker->addPoint(tP, mAnimation->getCurrentFrameNum(), getOnlyVisible(), &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
{
    mTracker->delPoint((Vec2F) pos, direction, mAnimation->getCurrentFrameNum(), getOnlyVisible());
    updateControlWidget();
}
void Petrack::editTrackPersonComment(QPointF pos)
{

    mTracker->editTrackPersonComment((Vec2F) pos, mAnimation->getCurrentFrameNum(), getOnlyVisible());
    updateControlWidget();
}
void Petrack::setTrackPersonHeight(QPointF pos)
{
    mTracker->setTrackPersonHeight((Vec2F) pos, mAnimation->getCurrentFrameNum(), getOnlyVisible());
    updateControlWidget();
}
void Petrack::resetTrackPersonHeight(QPointF pos)
{
    mTracker->resetTrackPersonHeight((Vec2F) pos, mAnimation->getCurrentFrameNum(), getOnlyVisible());
    updateControlWidget();
}

// direction zeigt an, ob bis zum aktuellen (-1), ab dem aktuellen (1) oder ganzer trackpath (0)
// loeschen von Trackpoints aller Trajektorien
void Petrack::deleteTrackPointAll(int direction) //const QPoint &pos
{
    mTracker->delPointAll(direction, mAnimation->getCurrentFrameNum());
    updateControlWidget();
}

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

void Petrack::deleteTrackPointInsideROI()
{
    mTracker->delPointInsideROI();
    updateControlWidget();
    mScene->update();
}
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::setPeTrackVersion(const std::string& petrackVersion)
{
    mPetrackVersion = QString::fromStdString(petrackVersion);
}

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"