Vista general de la cámara

La API Qt Multimedia proporciona una serie de clases relacionadas con la cámara, para que pueda acceder a imágenes y vídeos de cámaras de dispositivos móviles o cámaras web. Existen API de C++ y QML para tareas comunes.

Características de la cámara

Para poder utilizar las clases de cámara, es necesario tener una visión general del funcionamiento de una cámara. Si ya estás familiarizado con esto, puedes pasar a los detalles de implementación de la cámara. Para una explicación más detallada del funcionamiento de una cámara, consulte el siguiente clip de YouTube.

El conjunto de lentes

En un extremo del conjunto de la cámara se encuentra el objetivo (una o varias lentes dispuestas para enfocar la luz en el sensor). En ocasiones, los objetivos pueden moverse para ajustar aspectos como el enfoque y el zoom. También pueden estar fijas para mantener un buen equilibrio entre el enfoque y el coste.

Algunos conjuntos de objetivos pueden ajustarse automáticamente para mantener enfocado un objeto situado a distintas distancias de la cámara. Esto se suele hacer midiendo la nitidez de una zona concreta del fotograma y ajustando el conjunto del objetivo para encontrar el pico de nitidez. En algunos casos, la cámara utilizará siempre el centro del encuadre para ello. En otros casos, una cámara también puede permitir que se especifique esta región de enfoque objetivo. Algunos ejemplos de esta función son:

• Zoom facial: Uso de visión por ordenador para detectar y utilizar una o más caras como objetivo.
• Tocar para hacer zoom: Permite al usuario seleccionar manualmente un área a través de la pantalla de vista previa.

El sensor

Una vez que la luz llega al sensor, se convierte en píxeles digitales. Este proceso puede depender de varias cosas, pero en última instancia se reduce a dos:

• El tiempo de conversión. También conocido como tiempo de exposición.
• La intensidad de la luz.

Cuanto más tiempo dure la conversión, mejor será la calidad de la imagen resultante. El uso del flash puede ayudar a que incida más luz en el sensor, lo que permite convertir los píxeles más rápidamente y obtener una mejor calidad con el mismo tiempo. A la inversa, permitir un tiempo de conversión más largo puede permitirte hacer fotos en entornos más oscuros, siempre que la cámara esté fija. Si la cámara se mueve mientras el sensor está grabando, la imagen resultante sale borrosa.

Procesado de imágenes

Después de que la imagen haya sido capturada por el sensor, el firmware de la cámara realiza varias tareas de procesamiento de imagen en ella para compensar varias características del sensor, la iluminación actual y las propiedades de imagen deseadas. Los tiempos de conversión de píxeles del sensor más rápidos pueden introducir ruido digital, por lo que se puede realizar una cierta cantidad de procesamiento de imagen para eliminarlo, basándose en los ajustes del sensor de la cámara.

El color de la imagen también se puede ajustar en esta fase para compensar las diferentes fuentes de luz: las luces fluorescentes y la luz solar dan apariencias muy diferentes al mismo objeto, por lo que la imagen se puede ajustar en función del balance de blancos de la fotografía (debido a las diferentes temperaturas de color de las fuentes de luz).

En esta fase también se pueden realizar algunas formas de "efectos especiales". Se pueden producir imágenes en blanco y negro, sepia o estilo "negativo".

Grabación para la posteridad

Por último, una vez creada una imagen perfectamente enfocada, expuesta y procesada, se le puede dar un buen uso. Las imágenes de la cámara pueden ser procesadas por el código de la aplicación (por ejemplo, para detectar códigos de barras, o para unir una imagen panorámica), o guardadas en un formato común como JPEG, o utilizadas para crear una película. Muchas de estas tareas cuentan con clases que las asisten.

Detalles de la implementación de la cámara

Detección y selección de una cámara

Antes de utilizar las APIs de cámara, deberías comprobar que hay una cámara disponible en tiempo de ejecución. Si no hay ninguna disponible, podría desactivar las funciones relacionadas con la cámara en su aplicación. Para realizar esta comprobación en C++, utilice la función QMediaDevices::videoInputs(), como se muestra en el siguiente ejemplo:

bool checkCameraAvailability()
{
    if (QMediaDevices::videoInputs().count() > 0)
        return true;
    else
        return false;
}

Accede a una cámara utilizando la clase QCamera en C++ o el tipo Camera en QML.

Si se dispone de varios dispositivos de cámara, se puede especificar cuál utilizar.

En C++:

const QList<QCameraDevice> cameras = QMediaDevices::videoInputs();
for (const QCameraDevice &cameraDevice : cameras) {
    if (cameraDevice.description() == "mycamera")
        camera = new QCamera(cameraDevice);
}

En QML, puedes seleccionar la cámara estableciendo la propiedad Camera::cameraDevice. En C++, también puedes seleccionar un dispositivo con cámara por su orientación física en lugar de por la información de la cámara. Esto es útil en dispositivos móviles, que a menudo tienen una cámara frontal y otra trasera.

En C++:

camera = new QCamera(QCameraDevice::FrontFace);

Si no se especifica QCameraDevice, se utilizará el dispositivo predeterminado. El dispositivo por defecto se elige en función de la información proporcionada por el sistema operativo. En las plataformas de sobremesa, el usuario suele configurar la cámara predeterminada en los ajustes del sistema. En un dispositivo móvil, la cámara trasera suele ser el dispositivo de cámara predeterminado. Puedes obtener la cámara predeterminada con QMediaDevices::defaultVideoInput() en C++, o MediaDevices.defaultVideoInput en QML.

El dispositivo de cámara predeterminado puede cambiar con el tiempo, por ejemplo, si el usuario final desconecta el dispositivo de cámara predeterminado actual. Los desarrolladores de aplicaciones pueden realizar un seguimiento del cambio consultando de nuevo el dispositivo de cámara predeterminado cuando se emita la señal QMediaDevices::videoInputsChanged.

Vista previa

Aunque no es estrictamente necesario, a menudo es útil poder ver a qué está apuntando la cámara. Esto se conoce como vista previa.

Dependiendo de si estás usando QML o C++, puedes hacer esto de múltiples maneras. En QML, puedes usar Camera y videoOutput juntos para monitorizar una captureSession.

Item {
    VideoOutput {
        id: output
        anchors.fill: parent
    }
    CaptureSession {
        videoOutput: output

        Camera {
            // You can adjust various settings in here
        }
    }
}

En C++, tu elección depende de si estás usando widgets, o QGraphicsView. La clase QVideoWidget se usa en el caso de widgets, y QGraphicsVideoItem es útil para QGraphicsView.

QMediaCaptureSession captureSession;
camera = new QCamera;
captureSession.setCamera(camera);
viewfinder = new QVideoWidget;
captureSession.setVideoOutput(viewfinder);
viewfinder->show();

camera->start(); // to start the camera

Para un uso avanzado (como procesar los fotogramas de previsualización a medida que llegan, lo que permite la detección de objetos o patrones), también puede utilizar su propio QVideoSink y establecerlo como videoOutput para el QMediaCaptureSession. En este caso, tendrá que renderizar la imagen de previsualización usted mismo procesando los datos recibidos de la señal videoFrameChanged().

QMediaCaptureSession captureSession;
camera = new QCamera;
captureSession.setCamera(camera);
mySink = new QVideoSink;
captureSession.setVideoOutput(mySink);

camera->start();
// MyVideoSink::setVideoFrame(..) will be called with video frames

En dispositivos móviles, la imagen de previsualización está orientada por defecto de la misma forma que el dispositivo. Así, a medida que el usuario gira el dispositivo, la imagen de previsualización cambiará entre modo vertical y horizontal. Una vez iniciada la grabación, la orientación quedará bloqueada. Para evitar una mala experiencia de usuario, también debes bloquear la orientación de la interfaz de usuario de las aplicaciones mientras grabas. Esto se puede conseguir utilizando la propiedad contentOrientation de QWindow.

Imágenes fijas

Después de configurar un visor y encontrar algo fotogénico, para capturar una imagen necesitamos inicializar un nuevo objeto QImageCapture. Todo lo que se necesita entonces es iniciar la cámara y capturar la imagen.

QMediaCaptureSession captureSession;
camera = new QCamera;
captureSession.setCamera(camera);
imageCapture = new QImageCapture;
captureSession.setImageCapture(imageCapture);

camera->start(); // Viewfinder frames start flowing

//on shutter button pressed
imageCapture->capture();

Películas

Anteriormente vimos código que permitía capturar una imagen fija. La grabación de vídeo requiere el uso de un objeto QMediaRecorder.

Para grabar vídeo necesitamos crear un objeto cámara como antes pero esta vez además de crear un visor, también inicializaremos un objeto grabador multimedia.

QMediaCaptureSession captureSession;
camera = new QCamera;
captureSession.setCamera(camera);
recorder = new QMediaRecorder(camera);
captureSession.setRecorder(recorder);

camera->start();

// setup output format for the recorder
QMediaFormat format(QMediaFormat::MPEG4);
format.setVideoCodec(QMediaRecorder::VideoCodec::H264);
format.setAudioCodec(QMediaRecorder::AudioCodec::MP3);
recorder->setMediaFormat(settings);

//on shutter button pressed
recorder->record();

// sometime later, or on another press
recorder->stop();

Las señales del QMediaRecorder pueden conectarse a ranuras para reaccionar a cambios en el estado del proceso de codificación o a eventos de error. La grabación comienza cuando se llama a QMediaRecorder::record(). Esto hace que se emita la señal recorderStateChanged(). La grabación se controla mediante las ranuras record(), stop() y pause() de QMediaRecorder.

Control de la canalización de imágenes

Ahora que los fundamentos de la captura de imágenes y películas están cubiertos, hay un número de maneras de controlar la tubería de imágenes para implementar algunas técnicas interesantes. Como se explicó anteriormente, varios elementos físicos y electrónicos se combinan para determinar las imágenes finales, y puedes controlarlos con diferentes clases.

Enfoque y zoom

QCamera permite establecer la política general de enfoque mediante los enums de FocusMode. FocusMode se ocupa de ajustes como QCamera::FocusModeAuto, y QCamera::FocusModeInfinity.

Para el hardware de cámara que lo soporta, QCamera::FocusModeAutoNear permite obtener imágenes de cosas que están cerca del sensor. Esto es útil en aplicaciones como el reconocimiento de códigos de barras, o el escaneo de tarjetas de visita.

Además del enfoque, QCamera permite controlar cualquier función de zoom disponible mediante setZoomFactor() o zoomTo(). El rango de zoom disponible puede estar limitado o completamente fijado a la unidad (1:1). El rango permitido puede comprobarse con minimumZoomFactor() y maximumZoomFactor().

Exposición, velocidad de obturación y flash

Hay una serie de ajustes que afectan a la cantidad de luz que llega al sensor de la cámara y, por tanto, a la calidad de la imagen resultante.

Los principales ajustes para la toma automática de imágenes son exposure mode y flash mode. Otros ajustes (como el ajuste ISO y el tiempo de exposición) suelen gestionarse automáticamente, pero también pueden anularse si se desea.

Por último, puedes controlar el hardware del flash (si está presente) utilizando esta clase. En algunos casos, el hardware también puede funcionar como linterna.

Tratamiento de imágenes

La clase QCamera le permite ajustar la parte de procesamiento de imagen de la tubería. Estos ajustes incluyen:

• white balance (también conocida como temperatura de color)

La mayoría de las cámaras soportan ajustes automáticos para todos estos parámetros, por lo que no debería ser necesario ajustarlos a menos que el usuario desee un ajuste específico.

Ejemplos

Hay ejemplos disponibles tanto en C++ como en QML.

Ejemplos C

Ejemplos QML

Documentación de referencia

Clases C

Tipos QML