VideoPlaybackStrategy.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    visionx::imrec
 * @author     Christian R. G. Dreher <christian.dreher@student.kit.edu>
 * @date       2018
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
 
#include <VisionX/libraries/imrec/playback/strats/VideoPlaybackStrategy.h>
 
 
// STD/STL
#include <cstring>
#include <filesystem>
 
// OpenCV 2
#include <opencv2/imgproc/imgproc.hpp>
 
// ArmarX
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
visionx::imrec::strats::VideoPlaybackStrategy::VideoPlaybackStrategy()
{
    this->filePath = "";
}
 
visionx::imrec::strats::VideoPlaybackStrategy::VideoPlaybackStrategy(
    const std::filesystem::path& filePath)
{
    this->startPlayback(filePath);
}
 
visionx::imrec::strats::VideoPlaybackStrategy::~VideoPlaybackStrategy()
{
    this->stopPlayback();
}
 
bool
visionx::imrec::strats::VideoPlaybackStrategy::isPlayingBack() const
{
    return this->videoCapture.isOpened();
}
 
unsigned int
visionx::imrec::strats::VideoPlaybackStrategy::getFps() const
{
    return this->fps;
}
 
unsigned int
visionx::imrec::strats::VideoPlaybackStrategy::getFrameCount() const
{
    return this->frameCount;
}
 
unsigned int
visionx::imrec::strats::VideoPlaybackStrategy::getFrameHeight() const
{
    return this->frameHeight;
}
 
unsigned int
visionx::imrec::strats::VideoPlaybackStrategy::getFrameWidth() const
{
    return this->frameWidth;
}
 
void
visionx::imrec::strats::VideoPlaybackStrategy::setCurrentFrame(unsigned int frame)
{
    ARMARX_CHECK_LESS(frame, this->frameCount)
        << "Desired frame number to set is above the number of frames in total";
    if (frame != currentFrame)
    {
        this->videoCapture.set(cv::CAP_PROP_POS_FRAMES, static_cast<double>(frame));
        this->currentFrame = frame;
    }
}
 
unsigned int
visionx::imrec::strats::VideoPlaybackStrategy::getCurrentFrame() const
{
    return this->currentFrame;
}
 
bool
visionx::imrec::strats::VideoPlaybackStrategy::hasNextFrame() const
{
    return this->currentFrame < this->frameCount;
}
 
void
visionx::imrec::strats::VideoPlaybackStrategy::startPlayback(const std::filesystem::path& file_path)
{
    this->filePath = std::filesystem::canonical(file_path);
    this->videoCapture.open(this->filePath.string());
 
    ARMARX_CHECK_EXPRESSION(this->videoCapture.isOpened())
        << "Could not open the output video file '" + this->filePath.string() + "' for writing";
 
    this->fps = static_cast<unsigned int>(this->videoCapture.get(cv::CAP_PROP_FPS));
    this->frameHeight =
        static_cast<unsigned int>(this->videoCapture.get(cv::CAP_PROP_FRAME_HEIGHT));
    this->frameWidth = static_cast<unsigned int>(this->videoCapture.get(cv::CAP_PROP_FRAME_WIDTH));
    this->frameCount = static_cast<unsigned int>(this->videoCapture.get(cv::CAP_PROP_FRAME_COUNT));
    this->currentFrame = 0;
}
 
bool
visionx::imrec::strats::VideoPlaybackStrategy::getNextFrame(void* buffer)
{
    ARMARX_CHECK_EXPRESSION(this->videoCapture.isOpened())
        << "Could not open the output video file '" + this->filePath.string() + "' for writing";
 
    cv::Mat frame;
    const bool success = this->videoCapture.read(frame);
    ++this->currentFrame;
 
    // Convert OpenCV BGR to common sense RGB and copy to buffer
    if (success)
    {
        cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);
        std::memcpy(buffer,
                    frame.data,
                    this->frameHeight * this->frameWidth *
                        static_cast<unsigned int>(frame.channels()));
        return true;
    }
 
    return false;
}
 
bool
visionx::imrec::strats::VideoPlaybackStrategy::getNextFrame(::CByteImage& buffer)
{
    const bool success = this->getNextFrame(buffer.pixels);
    ++this->currentFrame;
    return success;
}
 
bool
visionx::imrec::strats::VideoPlaybackStrategy::getNextFrame(cv::Mat& buffer)
{
    ARMARX_CHECK_EXPRESSION(this->videoCapture.isOpened())
        << "Could not open the output video file '" + this->filePath.string() + "' for writing";
 
    return this->videoCapture.read(buffer);
}
 
void
visionx::imrec::strats::VideoPlaybackStrategy::stopPlayback()
{
    if (this->videoCapture.isOpened())
    {
        this->videoCapture.release();
    }
}