OpenCV em C

Em um artigo anterior fiz um exemplo de opencv em Python.

Programador Python/Opencv

Neste artigo irei apresentar um exemplo de código de opencv em C++.

Irei comentar traçando referencias entre o código do C e o código do python.

O Exemplo utililizado será fornecido pela própria biblioteca em python.

OpenCV em Python

Para traçar um paralelo usaremos os códigos do opencv, o programa chamado video_v4l2.py

Conforme apresentado abaixo:

#!/usr/bin/env python

'''
VideoCapture sample showcasing  some features of the Video4Linux2 backend

Sample shows how VideoCapture class can be used to control parameters
of a webcam such as focus or framerate.
Also the sample provides an example how to access raw images delivered
by the hardware to get a grayscale image in a very efficient fashion.

Keys:
    ESC    - exit
    g      - toggle optimized grayscale conversion

'''

# Python 2/3 compatibility
from __future__ import print_function

import numpy as np
import cv2 as cv

def main():

    def decode_fourcc(v):
        v = int(v)
        return "".join([chr((v >> 8 * i) & 0xFF) for i in range(4)])

    font = cv.FONT_HERSHEY_SIMPLEX
    color = (0, 255, 0)

    cap = cv.VideoCapture(0)
    cap.set(cv.CAP_PROP_AUTOFOCUS, 0)  # Known bug: https://github.com/opencv/opencv/pull/5474

    cv.namedWindow("Video")

    convert_rgb = True
    fps = int(cap.get(cv.CAP_PROP_FPS))
    focus = int(min(cap.get(cv.CAP_PROP_FOCUS) * 100, 2**31-1))  # ceil focus to C_LONG as Python3 int can go to +inf

    cv.createTrackbar("FPS", "Video", fps, 30, lambda v: cap.set(cv.CAP_PROP_FPS, v))
    cv.createTrackbar("Focus", "Video", focus, 100, lambda v: cap.set(cv.CAP_PROP_FOCUS, v / 100))

    while True:
        _status, img = cap.read()

        fourcc = decode_fourcc(cap.get(cv.CAP_PROP_FOURCC))

        fps = cap.get(cv.CAP_PROP_FPS)

        if not bool(cap.get(cv.CAP_PROP_CONVERT_RGB)):
            if fourcc == "MJPG":
                img = cv.imdecode(img, cv.IMREAD_GRAYSCALE)
            elif fourcc == "YUYV":
                img = cv.cvtColor(img, cv.COLOR_YUV2GRAY_YUYV)
            else:
                print("unsupported format")
                break

        cv.putText(img, "Mode: {}".format(fourcc), (15, 40), font, 1.0, color)
        cv.putText(img, "FPS: {}".format(fps), (15, 80), font, 1.0, color)
        cv.imshow("Video", img)

        k = cv.waitKey(1)

        if k == 27:
            break
        elif k == ord('g'):
            convert_rgb = not convert_rgb
            cap.set(cv.CAP_PROP_CONVERT_RGB, 1 if convert_rgb else 0)

    print('Done')


if __name__ == '__main__':
    print(__doc__)
    main()
    cv.destroyAllWindows()

A primeira informação importante é a carga das bibliotecas do opencv em python.

import cv2 as cvimport cv2 as cv

carga da lib em python

O proximo ponto importante é onde capturamos o vídeo.

cap = cv.VideoCapture(0)

Captura do vídeo

O Parametro 0, indica que o device de vídeo é o padrão do sistema.

O ponto importante no código é o uso do cap, no código abaixo:

_status, img = cap.read()

captura do frame

Ao chamar a função read, dois parametros são retornados, _status (retorno de sucesso) e img, a imagem capturada.

Por fim, uma janela é montada com a visualização da imagem capturada:

cv.imshow(“Video”, img)

janela é montada

Agora iremos analisar o mesmo código em C.

OpenCV em C

Agora mostraremos o código em C, o exemplo é o videocapture_basic.cpp:

#include <opencv2/core.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <stdio.h>

using namespace cv;
using namespace std;

int main(int, char**)
{
    Mat frame;
    //--- INITIALIZE VIDEOCAPTURE
    VideoCapture cap;
    // open the default camera using default API
    // cap.open(0);
    // OR advance usage: select any API backend
    int deviceID = 0;             // 0 = open default camera
    int apiID = cv::CAP_ANY;      // 0 = autodetect default API
    // open selected camera using selected API
    cap.open(deviceID, apiID);
    // check if we succeeded
    if (!cap.isOpened()) {
        cerr << "ERROR! Unable to open camera\n";
        return -1;
    }

    //--- GRAB AND WRITE LOOP
    cout << "Start grabbing" << endl
        << "Press any key to terminate" << endl;
    for (;;)
    {
        // wait for a new frame from camera and store it into 'frame'
        cap.read(frame);
        // check if we succeeded
        if (frame.empty()) {
            cerr << "ERROR! blank frame grabbed\n";
            break;
        }
        // show live and wait for a key with timeout long enough to show images
        imshow("Live", frame);
        if (waitKey(5) >= 0)
            break;
    }
    // the camera will be deinitialized automatically in VideoCapture destructor
    return 0;
}

O primeiro ponto assim como no código em python, e a chamada da biblioteca em c.

#include <opencv2/core.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/highgui.hpp>

Sem esses includes não teriamos acessos aos tipos do C, como o que segue:

VideoCapture cap;

O tipo VideoCapture é o tipo associado a captura de vídeo da câmera.

Onde usaremos, conforme fragmento abaixo:

int deviceID = 0;             // 0 = open default camera
int apiID = cv::CAP_ANY;      // 0 = autodetect default API
// open selected camera using selected API
cap.open(deviceID, apiID);

Aqui, definimos o deviceID como 0, ou seja, o valor padrão, veja a semelhança do uso do python.

E apiID, passando o escopo (variavel) CAP_ANY, que tem por valor 0.

Chamamos o método open da classe VideoCapture, indicando o deviceID, e o apiID.

Agora iremos ler a imagem da camera, que podemos fazer, através da seguinte função:

cap.read(frame);

Neste fragmento de código, passamos o parametro frame, que é do tipo Mat.

O frame receberá a imagem capturada.

E por fim, no código abaixo a janela que irá mostrar a imagem na interface gráfica.

imshow("Live", frame);

Conclusão

Apesar das diferenças de linguagem, podemos ver o pontos em comum, e a sutileza da semelhança.

É lógico que os códigos foram escolhidos a dedo. Justamente por conta da semelhança e simplicidade.

O opencv é uma biblioteca rica, cheia de opções e dificuldades, este tutorial, bem como o autor, esta apenas adentrando neste mundo para mim misterioso.

Espero que tenham gostado deste artigo. 😉