analysiscontroller.h

/****************************************************************************
 * Copyright (c) 2014, Joel Kivelä, Erkki Koskenkorva, Oskari Leppäaho,
 * Mika Lehtinen and Petri Partanen.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the copyright holders nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
****************************************************************************/
#ifndef ANALYSISCONTROLLER_H
#define ANALYSISCONTROLLER_H

#include <map>
#include <string>
#include <vector>

#include <QObject>
#include <QTimer>

#include "common.h"
#include "results.h"
#include "source/camera.h"

namespace cavapa_gui
{
class AnalysisController : public QObject
{
    Q_OBJECT
public:
    AnalysisController();

    ~AnalysisController() { stop(); }

    DISALLOW_COPY_AND_ASSIGN(AnalysisController);

    SourceID addSource(const std::string& path, SourceID id = UNDEFINED_SOURCE,
                       FrameTime start_point = 0);

    bool addSource(const std::vector<std::string>& paths,
                   SourceID id = UNDEFINED_SOURCE, FrameTime start_point = 0);

    bool canChangeSourceResolution(SourceID id) const;

    bool canPause() const;

    int countAvailableCameras() const;

    bool exportResults(const ExportOptions& options) const
        { return results.exportToCSV(options); }

    double getCalculationFPS() const
        { return running ? Camera::getDefaultFPS() : 0.0; }

    std::string getLastError() const { return last_error; }

    std::vector<FrameStats> getResults(FrameTime start, FrameTime stop,
                                       int points) const
        { return results.getStatistics(start, stop, points); }

    int getSourceCount() const { return sources.size(); }

    std::string getSourceDescription(SourceID id) const;

    std::vector<cv::Rect> getSourceExcludes(SourceID id) const;

    std::vector<std::string> getSourceFilenames(SourceID id) const;

    std::vector<SourceID> getSourceListing() const;

    FrameTime getSourcePosition(SourceID id) const;

    cv::Size getSourceResolution(SourceID id) const;

    SourceStats getSourceStats(SourceID id) const;

    SourceType getSourceType(SourceID id) const;

    FrameTime getVideoLength(SourceID id) const;

    int initCameras(int max_loops = 10);

    bool isPaused() const { return paused; }

    bool isRunning() const { return running; }

    bool load(const std::string& path = "results.cpa");

    bool pause();

    bool removeSource(SourceID id);

    bool reset();

    bool save(const std::string& path = "results.cpa");

    bool setCameraFPS(double fps);

    void setHighlight(bool highlight) { highlight_sightings = highlight; }

    void setHighlightColor(const cv::Scalar& color)
            { highlight_color = color; }

    bool setPosition(FrameTime pos);

    bool setRecorderCodec(const std::string& codec,
                          const std::string& extension = "avi");

    void setRecordTimeLimit(unsigned int length) { max_record_length = length; }

    bool setSourceBarrelCorrection(SourceID id, double amount);

    void setSourceExcludes(SourceID id, const std::vector<cv::Rect>& rects);

    bool setSourceResolution(SourceID id, const cv::Size& new_size);

    bool setVideoSpeed(double ratio = 1.0);

    void setWorkDirectory(const std::string& path);

    bool sourceCanRecord(SourceID id) const;

    bool sourcePlay(SourceID id);

    bool sourceSeek(SourceID id, FrameTime position);

    bool sourceStepBackward(SourceID id) { return stepSource(id, -1); }

    bool sourceStepForward(SourceID id) { return stepSource(id, 1); }

    bool sourceStop(SourceID id);

    bool start(const std::vector<SourceID>& calc_sources,
               const std::vector<cavapa::CameraSettings>& settings,
               const std::vector<cavapa::CalibrationPoint>& points,
               bool record = false,
               int calc_time = 0);

    void stop();

private:
    bool checkDiskSpace();

    void checkLag(FrameTime time_passed);

    void checkRecordLimits();

    inline std::string createRecordName(SourceID id) const;

    cv::Mat drawExcludes(SourceID id, const cv::Mat& image);

    static unsigned int getFreeDiskSpace(const std::string& path);

    inline std::shared_ptr<Source> getSource(SourceID id) const;

    SourceID getSourceDevice(int device) const;

    std::vector<FrameCapture> highlight(
                         const std::vector<FrameCapture>& captures,
                         const std::vector<cavapa::Sightings>& sightings) const;

    inline cv::Mat highlightFrame(const cv::Mat& image,
                   const std::vector<cavapa::Sighting>& sightings) const;

    static inline bool isVideoFile(const std::shared_ptr<Source>& src);

    inline void playSelectedSources();

    static cv::Mat printText(const cv::Mat& image, const std::string& text);

    inline bool selectedAreVideos() const;

    inline bool selectedSourcesOpen() const;

    std::vector<cavapa::CameraSettings> setCalculationSettings(
            const std::vector<SourceID>& calc_sources,
            const std::vector<cavapa::CameraSettings>& settings);

    void setLastError(const std::string& desc) { last_error = desc; }

    inline bool sourceExists(SourceID id) const;

    inline bool sourceInSelection(SourceID id) const;

    bool stepSource(SourceID id, int amount);

    inline void stopSelectedSources();

    static inline FrameTime timeNow();

    // How many concurrent lag misses we need to trigger a warning.
    static const unsigned int LAG_WARNING_CONCURRENT = 5;

    // Interval for lag warnings in seconds.
    static const unsigned int LAG_WARNING_INTERVAL = 5;

    // Maximum possible fps that can be set.
    static const unsigned int MAXIMUM_FPS = 50.0;

    FrameTime calculation_time;             // Calculation time
    FrameTime calculation_stop;             // Holds automatic stop time
    std::unique_ptr<cavapa::CavapaDetector> detector = nullptr; // Detector
    std::map<SourceID, std::vector<cv::Rect>> exclude_rectangles;
    std::string folder = "";                // Work folder
    cv::Scalar highlight_color = cv::Scalar(0, 0, 255);  // Coloring
    bool highlight_sightings = false;       // Sighting highlighting
    FrameTime lag_warning_last = 0;         // Holds last lag time warning
    unsigned int lag_warning_concurrent = 0;// Concurrent lag warnings
    std::string last_error = "";            // Last occurred error
    FrameTime last_space_check = 0;         // Last disk space checktime
    FrameTime last_update_time = 0;         // Holds last source retrieve time
    unsigned int max_record_length = 0;     // Maximum seconds per video file
    bool paused = true;                     // Calculation pause status.
    Results results;                        // Calculation results
    bool recording = false;                 // If calculation is recording
    bool running = false;                   // If calculation is in progress
    std::vector<SourceID> selected_sources; // Sources in calculation
    std::vector<std::shared_ptr<Source>> sources; // All video sources
    double speed_ratio = 1.0;               // Source framerate ratio
    QTimer timer;                           // Source frame update timer
    std::string video_extension = "avi";    // Default extension for video files

#ifdef _DEBUG_TIMERS
    int processed_frames = 0;
    std::uint64_t total_process_time = 0;
#endif // _DEBUG_TIMERS

private slots:
    void updateSources();

signals:
    void calculationComplete();

    void error(const std::string& message, ErrorLevel level);

    void updated(const std::vector<FrameCapture>& frames,
                 const FrameStats& statistics);
};
} // namespace

#endif // ANALYSISCONTROLLER_H