common.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 COMMON_H
#define COMMON_H

#include <string>

#include <QDebug>

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>

#include "cavapa/cavapa.h"

// Timers for retrieval/calculation etc. information.
//#define _DEBUG_TIMERS 1 // Comment out if you don't want them.

namespace cavapa
{
// Name re-definitions for cavapa, as these might still change quite a lot.
using CalibrationPoint = calibration_point;
using CameraSettings = camera;
using CavapaDetector = detector;
using Sighting = sighting;
using Sightings = sightings;
} // namespace

namespace cavapa_gui
{
enum class SourceType { CAMERA, NOTHING, STREAM, VIDEO, VIDEOSET };

enum class ErrorLevel : int { INFO = 1, WARNING = 2, CRITICAL = 3 };

enum class EXPORT_FLAGS : int {
    NOTHING         = 0x00, // No flags
    APPEND          = 0x01, // Append information to the file
    USE_COMMA       = 0x02, // Use comma as decimal separator
};

static inline constexpr bool operator& (EXPORT_FLAGS a, EXPORT_FLAGS b)
{
    return static_cast<int>(a) & static_cast<int>(b);
}

static inline constexpr EXPORT_FLAGS operator| (EXPORT_FLAGS a, EXPORT_FLAGS b)
{
    return static_cast<EXPORT_FLAGS>(static_cast<int>(a) | static_cast<int>(b));
}

static inline constexpr EXPORT_FLAGS operator|= (EXPORT_FLAGS a, EXPORT_FLAGS b)
{
    return EXPORT_FLAGS(a | b);
}

static inline bool isNaN(double value)
{
    return value != value;
}

using FrameTime = std::uint64_t;

struct Marker
{
    bool active;

    FrameTime pos;

    std::string text;

    bool operator < (const Marker& str) const{
      return pos < str.pos;
    }
};

using GraphMarker = Marker;

struct ExportOptions
{
    std::string filename;

    EXPORT_FLAGS flags;

    FrameTime interval;

    std::vector<Marker> markers;

    FrameTime start;

    FrameTime stop;

    int time_offset;
};

const int UNKNOWN_DEVICE = -2;

using SourceID = unsigned int;

const SourceID UNDEFINED_SOURCE = 0;

struct FrameCapture
{
    SourceID id;

    FrameTime time;

    cv::Mat image;
};

enum class FrameFlags : std::uint32_t {
    FRAME_DEFAULT = 0,  // Nothing special.
    FRAME_STOP    = 1,  // This frame is an end frame.
    FRAME_START   = 2,  // This frame is a start frame.
    FRAME_DUPLICATE = 4,// This frame contains no new information from previous.
    FRAME_WARNING   = 8,// This frame had warnings during calculation.
};

struct FrameStats
{
    FrameTime time;

    float activity;

    float count;

    //FrameFlags flags;

    // This check is performed in order to check the correct member size of the
    // structure to maintain 32bit & 64bit file format integrity.
    static_assert(sizeof(FrameStats::activity) == 4
                  && sizeof(FrameStats::time) == 8
                  && sizeof(FrameStats::count) == 4,
                 "The size of the structure members is not correct.");
};

struct SourceStats
{
    unsigned int missed;

    unsigned int recorded;

    unsigned int retrieved;

    unsigned int total_recorded;
};

// Empty statistics that can be used for zeroing
static const FrameCapture EMPTY_FRAME_CAPTURE = {0,0,cv::Mat()};
static const FrameStats EMPTY_FRAME_STATS = {0,0,0};
static const SourceStats EMPTY_SOURCE_STATS = {0,0,0,0};

#define DISALLOW_COPY_AND_ASSIGN(f) \
    f(const f&) = delete; \
    f(f&&) = delete; \
    f& operator =(const f&) = delete; \
    f& operator =(f&&) = delete
} // namespace

#endif // COMMON_H