opencvcapture.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 OPENCVCAPTURE_H
#define OPENCVCAPTURE_H

#include <condition_variable>
#include <string>
#include <thread>

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

#include "captureinterface.h"

namespace cavapa_gui
{
class OpenCVCapture : public CaptureInterface
{
public:
    OpenCVCapture() {}
    virtual ~OpenCVCapture();

    DISALLOW_COPY_AND_ASSIGN(OpenCVCapture);

    double getBarrelCorrection() override;

    FrameCapture getBuffered() override;

    std::string getDescription() const override;

    int getDeviceID() const override { return device_id; }

    double getFramerate() const override { return framerate; }

    int getMissedFrames() const override { return missed_frames; }

    FrameCapture getNext(bool skip, bool* error) override;

    std::string getPath() const override { return path; }

    double getProperty(int propId);

    cv::Size getResolution() const override { return resolution; }

    int getRetrievedFrames() const override { return retrieved_frames; }

    INTERFACE_TYPE getType() const override final
        { return INTERFACE_TYPE::OPENCV; }

    bool hasNew() override;

    bool isOpen() const override { return opened; }

    bool open(int index);

    bool open(const std::string& path) override;

    void release();

    void resetStats() override { missed_frames = 0; retrieved_frames = 0; }

    void setBarrelCorrection(double amount) override;

    bool setProperty(int propId, double value);

    bool setResolution(const cv::Size &new_size) override;

private:
    static cv::Mat applyBarrel(const cv::Mat& image, double effect);

    void clearBuffer() { buffer = createEmptyFrame(resolution); }

    static cv::Mat convertTo3Channels(const cv::Mat& image);

    static FrameCapture createEmptyFrame(const cv::Size& frame_size);

    inline void getFrameSize();

    void init();

    inline void keepWorkerReady();

    void retrieve();

    inline bool retrieve_next(std::unique_lock<std::mutex>& guard);

    static inline FrameTime timeNow();

    // Variables that are only used by the main thread
    int device_id = UNKNOWN_DEVICE;     // Device initialization index
    double framerate;                   // Device FPS
    FrameTime last_timestamp = 0;       // Timestamp of the last image get.
    int missed_frames;                  // Recorded frame misses
    bool opened = false;                // If device was opened at init
    std::string path = "";              // Device initialization path
    cv::Size resolution;                // Device resolution
    int retrieved_frames;               // Total frame count by getNext()

    // Variables that are protected by a mutex
    FrameCapture buffer;                    // Frame buffer
    double barrel_correction = 0.0;         // Barrel effect applied
    bool capture = false;                   // If retrieval is in progress
    std::condition_variable capture_next;   // Conditional for next retrieve
    std::mutex lock;                        // Thread mutex
    bool read_error = false;                // Indicates retrieval error
    std::condition_variable retrieved;      // Conditional for retrieve
    std::unique_ptr<std::thread> retriever = nullptr; // Retrieval thread
    cv::VideoCapture source;                // OpenCV source
    bool terminate = false;                 // Terminate message for thread
};
} // namespace

#endif // OPENCVCAPTURE_H