BioTrackerApp.cpp

#include "BioTrackerApp.h"
#include <limits>
#include <thread>

#include <boost/algorithm/string.hpp>

#include "Exceptions.h"

namespace BioTracker {
namespace Core {

/**
 * The consturctor instantiates m_settings.
 * m_settings BioTrackerApp::m_settings is the BioTracker setting class BioTracker::Core::Settings.
 * The default constructor of BioTracker::Core::Settings is used to instantiate m_settings.
 *
 * A registry Registry::getInstance() for loading and registering new tracker
 * from a shared library is called by the constructor. In the whole BioTracker only one registry is
 * allowed. Therefore the registry was designt as a singleton BioTracker::Util::Singleton.
 *
 * BioTrackerApp constructor also calles for a Registry. The Registry is a singleton and
 * used for loading and registering new tracker from shared libraries.
 * In the constructor
 */
BioTrackerApp::BioTrackerApp()
    : m_settings()
    , m_registry(Registry::getInstance())
    , m_trackingThread(m_settings) {
    initConnects();
    loadModulesInPath(ConfigParam::MODULE_PATH);

    m_trackingThread.start();
}

BioTrackerApp::~BioTrackerApp() {
    m_trackingThread.terminate();
    m_trackingThread.wait();
}

/**
 * So far there are six connections between the BioTrackerApp and the TrackingThread and one connection to the
 * Registry.
 *
 *
 */
void BioTrackerApp::initConnects() {

    /** @code{.cpp} */
    QObject::connect(&m_trackingThread, &Core::TrackingThread::frameCalculated,
                     this, &BioTrackerApp::frameCalculatedFromTrackingThread);

    QObject::connect(&m_trackingThread, &Core::TrackingThread::notifyGUI,
                     this, &BioTrackerApp::notifyFromTrackingThread);

    QObject::connect(&m_trackingThread, &Core::TrackingThread::fileOpened,
                     this, &BioTrackerApp::fileOpenedFromTrackingThread);

    QObject::connect(&m_trackingThread, &Core::TrackingThread::trackerSelected,
                     this, &BioTrackerApp::trackerSelectedFromTrackingThread);

    QObject::connect(&m_trackingThread, &Core::TrackingThread::registerViews,
                     this, &BioTrackerApp::registerViewsFromTrackingThread);

    QObject::connect(&m_trackingThread, &Core::TrackingThread::requestPaint,
                     this, &BioTrackerApp::requestPaintFromTrackingThread);

    QObject::connect(&m_registry, &Core::Registry::trackerIsAlreadyLoaded,
                     this, &BioTrackerApp::trackerIsAlreadyLoadedFromRegistry);
    /**  @endcode */
}

/**
 * BioTrackerApp calls the loadVideo function of TrackingThread::loadVideo().
 * TrackingThread will stored the file path as a parameter of Settings.
 * Only video formats supported by OpenCV can be used with the BioTracker
 */
void BioTrackerApp::openVideo(const boost::filesystem::path &path) {
    m_trackingThread.loadVideo(path);
}

void BioTrackerApp::openImages(std::vector<boost::filesystem::path> paths) {
    m_trackingThread.loadPictures(std::move(paths));
}

void BioTrackerApp::openCamera(int device) {
    m_trackingThread.loadCamera(device);
}

void BioTrackerApp::play() {
    m_trackingThread.setPlay();
}

void BioTrackerApp::pause() {
    m_trackingThread.setPause();
}

void BioTrackerApp::paint(const size_t w, const size_t h, QPainter &painter, PanZoomState zoom,
                          const TrackingAlgorithm::View &v) {
    m_trackingThread.paint(w, h, painter, zoom, v);
}

bool BioTrackerApp::isRendering() {
    return m_trackingThread.isRendering();
}

bool BioTrackerApp::isRunning() {
    return !m_trackingThread.isPaused();
}

void BioTrackerApp::setFrame(const size_t frameNumber) {
    m_trackingThread.setFrameNumber(frameNumber);
}

void BioTrackerApp::setTargetFps(const double fps) {
    m_trackingThread.setFps(fps);
}

void BioTrackerApp::setMaxSpeed(bool enabled) {
    m_trackingThread.setMaxSpeed(enabled);
}

double BioTrackerApp::getTargetFps() const {
    return std::numeric_limits<double>::infinity();
}

size_t BioTrackerApp::getNumFrames() const {
    return m_trackingThread.getVideoLength();
}

size_t BioTrackerApp::getCurrentFrameNumber() const {
    return m_trackingThread.getFrameNumber();
}

void BioTrackerApp::setTrackingAlgorithm(std::shared_ptr<TrackingAlgorithm>
        trackingAlgorithm) {

    m_trackingThread.setTrackingAlgorithm(std::move(trackingAlgorithm));
}

void BioTrackerApp::setTrackingAlgorithm(const std::string &trackerName) {
    const auto trackerType = m_registry.getTypeByString().at(trackerName);
    if (trackerType != NoTracking) {
        setTrackingAlgorithm(m_registry.makeNewTracker(trackerType, m_settings));
    }
}

void BioTrackerApp::mouseEvent(QMouseEvent *event) {
    m_trackingThread.mouseEvent(event);
}

void BioTracker::Core::BioTrackerApp::mouseWheelEvent(QWheelEvent *event) {
    m_trackingThread.mouseWheelEvent(event);
}

void BioTrackerApp::keyboardEvent(QKeyEvent *event) {
    m_trackingThread.keyboardEvent(event);
}

// all slots will only pass the signals through

void BioTrackerApp::notifyFromTrackingThread(const std::string &message,
        const MessageType type) {
    Q_EMIT notify(message, type);
}


void BioTrackerApp::frameCalculatedFromTrackingThread(const size_t frameNumber,
        const std::string filename, const double currentFps) {
    Q_EMIT frameCalculated(frameNumber, filename, currentFps);
}


void BioTrackerApp::loadModulesInPath(const boost::filesystem::path &path) {
    if (!boost::filesystem::is_directory(path)) {
        throw directory_not_found("Invalid path");
    }

    for (auto &p : boost::make_iterator_range(boost::filesystem::directory_iterator(path), {})) {
        std::vector<std::string> parts;
        boost::split(parts, p.path().string(), boost::is_any_of("."));
        /** @note expect filename to be of form: name.tracker.ext */
        if (parts.size() >= 3) {
            getRegistry().loadTrackerLibrary(p);
        }
    }
}

void BioTrackerApp::fileOpenedFromTrackingThread(const std::string fileName,
        const size_t numFrame, const double tfps) {
    Q_EMIT fileOpened(fileName, numFrame, tfps);
}

void BioTracker::Core::BioTrackerApp::trackerSelectedFromTrackingThread(
    std::shared_ptr<TrackingAlgorithm> a) {
    Q_EMIT trackerSelected(a);
}

void BioTracker::Core::BioTrackerApp::registerViewsFromTrackingThread(const std::vector<TrackingAlgorithm::View>
        views) {
    Q_EMIT registerViews(views);
}

void BioTracker::Core::BioTrackerApp::requestPaintFromTrackingThread() {
    Q_EMIT requestPaint();
}

void BioTracker::Core::BioTrackerApp::trackerIsAlreadyLoadedFromRegistry(const std::string name) {
    std::stringstream ss;
    ss << "Tracker " << name << " is already loaded!";
    Q_EMIT notify(ss.str(), MessageType::FAIL);
}

void BioTracker::Core::BioTrackerApp::enableTracking() {
    m_trackingThread.enableTracking();
}

void BioTracker::Core::BioTrackerApp::disableTracking() {
    m_trackingThread.disableTracking();
}

} // Core
} // BioTracker