CVCapture.cpp File Reference

OpenCV Capture Device. More...

#include <CVCamera.h>
#include <algorithm>
#include <CVCapture.h>
#include <CVImage.h>
#include <Utils.h>
#include <FtpUtils.h>
#include <AppCommon.h>
#include <Profiler.h>
#include <opencv2/core/utils/logger.hpp>

Include dependency graph for CVCapture.cpp:

Go to the source code of this file.

Classes
struct	colorBGR
	YUV to RGB image infos. Offset value can be negative for mirrored copy. More...
struct	YUV2RGB_ImageInfo
	YUV to RGB image infos. Offset value can be negative for mirrored copy. More...
struct	YUV2RGB_BlockInfo
	YUV to RGB image block infos that are different per thread. More...

Functions
void	yuv2rbg (uchar y, uchar u, uchar v, uchar &r, uchar &g, uchar &b)
	YUV to RGB image infos. Offset value can be negative for mirrored copy. More...
void *	convertYUV2RGB (YUV2RGB_BlockInfo *block)
	YUV to RGB conversion function called by multiple threads. More...

Detailed Description

OpenCV Capture Device.

Authors

Michael Goettlicher, Marcus Hudritsch, Jan Dellsperger

Date

Winter 2016

Authors

Marcus Hudritsch

Copyright

http://opensource.org/licenses/GPL-3.0

Remarks

Please use clangformat to format the code. See more code style on https://github.com/cpvrlab/SLProject4/wiki/SLProject-Coding-Style

Definition in file CVCapture.cpp.

Function Documentation

convertYUV2RGB()

void* convertYUV2RGB

(

YUV2RGB_BlockInfo *

block

)

YUV to RGB conversion function called by multiple threads.

/param info image block information struct with thread specific information

Definition at line 594 of file CVCapture.cpp.

{
    YUV2RGB_ImageInfo* image = block->imageInfo;
 
    for (int row = 0; row < block->rowCount; ++row)
    {
        colorBGR* bgrCol  = (colorBGR*)block->bgrRow;
        uchar*    grayCol = block->grayRow;
        uchar*    yCol    = block->yRow;
        uchar*    uCol    = block->uRow;
        uchar*    vCol    = block->vRow;
 
        // convert 2 pixels in the inner loop
        for (int col = 0; col < block->colCount; col += 2)
        {
            yuv2rbg(*yCol, *uCol, *vCol, bgrCol->r, bgrCol->g, bgrCol->b);
            *grayCol = *yCol;
 
            bgrCol += image->bgrColOffest;
            grayCol += image->grayColOffest;
            yCol += image->yColOffest;
 
            yuv2rbg(*yCol, *uCol, *vCol, bgrCol->r, bgrCol->g, bgrCol->b);
            *grayCol = *yCol;
 
            bgrCol += image->bgrColOffest;
            grayCol += image->grayColOffest;
            yCol += image->yColOffest;
 
            uCol += image->uColOffest;
            vCol += image->vColOffset;
        }
 
        block->bgrRow += image->bgrRowOffset;
        block->grayRow += image->grayRowOffset;
        block->yRow += image->yRowOffset;
 
        // if odd row
        if (row & 1)
        {
            block->uRow += image->uRowOffset;
            block->vRow += image->vRowOffest;
        }
    }
 
    return nullptr;
}

yuv2rbg()

void yuv2rbg ( uchar  y, uchar  u, uchar  v, uchar &  r, uchar &  g, uchar &  b  )

inline

YUV to RGB image infos. Offset value can be negative for mirrored copy.

Definition at line 528 of file CVCapture.cpp.

{
    // Conversion from:
    // https://de.wikipedia.org/wiki/YUV-Farbmodell
    // float c = 1.164f*(float)(yVal-16);
    // float d = (float)(uVal-128);
    // float e = (float)(vVal-128);
    // r = clipFToUInt8(c + 1.596f*e);
    // g = clipFToUInt8(c - 0.391f*d - 0.813f*e);
    // b = clipFToUInt8(c + 2.018f*d);
 
    // Conversion from:
    // http://www.wordsaretoys.com/2013/10/18/making-yuv-conversion-a-little-faster
    // I've multiplied each floating point constant by 1024 and truncated it.
    // Now I can add/subtract the scaled integers, and apply a bit shift right to
    // divide each result by 1024
    int e  = v - 128;
    int d  = u - 128;
    int a0 = 1192 * (y - 16);
    int a1 = 1634 * e;
    int a2 = 832 * e;
    int a3 = 400 * d;
    int a4 = 2066 * d;
    r      = (uchar)Utils::clamp((a0 + a1) >> 10, 0, 255);
    g      = (uchar)Utils::clamp((a0 - a2 - a3) >> 10, 0, 255);
    b      = (uchar)Utils::clamp((a0 + a4) >> 10, 0, 255);
}