Présentation de la caméra

L'API « Qt Multimedia » fournit un certain nombre de classes liées à l'appareil photo, ce qui vous permet d'accéder aux images et aux vidéos provenant des appareils photo des appareils mobiles ou des webcams. Des API en C++ et en QML sont disponibles pour les tâches courantes.

Fonctionnalités de l'appareil photo

Pour utiliser les classes d'appareil photo, il est nécessaire d'avoir un aperçu rapide du fonctionnement d'un appareil photo. Si vous maîtrisez déjà ce sujet, vous pouvez passer directement à la section « Détails de l'implémentation de l'appareil photo ». Pour une explication plus détaillée du fonctionnement d'un appareil photo, consultez la vidéo YouTube suivante.

L'ensemble objectif

À l'une des extrémités de l'ensemble de la caméra se trouve l'ensemble optique (composé d'une ou plusieurs lentilles, disposées de manière à focaliser la lumière sur le capteur). Les lentilles elles-mêmes peuvent parfois être déplacées pour régler des paramètres tels que la mise au point et le zoom. Elles peuvent également être fixées dans une configuration permettant d'atteindre un bon équilibre entre le maintien de la mise au point et le coût.

Certains ensembles d'objectifs peuvent être réglés automatiquement afin de maintenir la mise au point sur un objet situé à différentes distances de la caméra. Cela s'effectue généralement en mesurant la netteté d'une zone particulière du cadre, puis en ajustant l'ensemble d'objectifs pour obtenir une netteté optimale. Dans certains cas, la caméra utilise systématiquement le centre du cadre à cette fin. Dans d’autres cas, un appareil photo peut également permettre de spécifier cette zone de mise au point cible. Voici quelques exemples de cette fonctionnalité :

• Zoom sur le visage : utilisation de la vision par ordinateur pour détecter et sélectionner un ou plusieurs visages comme cible.
• Zoom tactile : permet à l’utilisateur de sélectionner manuellement une zone via l’écran de prévisualisation.

Le capteur

Une fois que la lumière atteint le capteur, elle est convertie en pixels numériques. Ce processus peut dépendre de plusieurs facteurs, mais se résume en fin de compte à deux éléments :

• La durée pendant laquelle la conversion peut s'effectuer, également appelée temps d'exposition.
• L'intensité de la lumière.

Plus le temps de conversion est long, meilleure est la qualité de l'image obtenue. L'utilisation d'un flash peut aider à faire parvenir davantage de lumière au capteur, ce qui lui permet de convertir les pixels plus rapidement et d'obtenir une meilleure qualité pour un temps de conversion identique. À l'inverse, un temps de conversion plus long permet de prendre des photos dans des environnements plus sombres, à condition que l'appareil photo soit stable. Si l'appareil bouge pendant que le capteur enregistre, l'image obtenue sera floue.

Traitement de l'image

Une fois l’image capturée par le capteur, le micrologiciel de l’appareil photo effectue diverses tâches de traitement d’image afin de compenser les caractéristiques du capteur, les conditions d’éclairage du moment et les propriétés souhaitées pour l’image. Des temps de conversion des pixels du capteur plus rapides peuvent introduire du bruit numérique ; un certain traitement d’image peut donc être effectué pour le supprimer, en fonction des réglages du capteur de l’appareil photo.

La couleur de l’image peut également être ajustée à ce stade pour tenir compte des différentes sources lumineuses : la lumière fluorescente et la lumière du soleil donnent en effet un rendu très différent d’un même objet ; l’image peut donc être ajustée en fonction de la balance des blancs (en raison des différentes températures de couleur des sources lumineuses).

Certains « effets spéciaux » peuvent également être appliqués à ce stade. Il est ainsi possible de produire des images en noir et blanc, en sépia ou de style « négatif ».

Conservation pour la postérité

Enfin, une fois qu’une image parfaitement mise au point, exposée et traitée a été créée, elle peut être mise à profit. Les images capturées par la caméra peuvent être traitées davantage par un code d’application (par exemple, pour détecter des codes-barres ou pour assembler une image panoramique), ou enregistrées dans un format courant tel que le JPEG, ou encore utilisées pour créer une vidéo. De nombreuses tâches de ce type disposent de classes pour faciliter leur réalisation.

Détails de l'implémentation de l'appareil photo

Détection et sélection d'un appareil photo

Avant d'utiliser les API de la caméra, vous devez vérifier qu'une caméra est disponible au moment de l'exécution. Si aucune n'est disponible, vous pouvez désactiver les fonctionnalités liées à la caméra dans votre application. Pour effectuer cette vérification en C++, utilisez la fonction QMediaDevices::videoInputs(), comme indiqué dans l'exemple ci-dessous :

bool checkCameraAvailability()
{
    return !QMediaDevices::videoInputs().isEmpty();
}

Accédez à une caméra à l'aide de la classe ` QCamera ` en C++ ou du type ` Camera ` en QML.

Lorsque plusieurs appareils photo sont disponibles, vous pouvez spécifier celui que vous souhaitez utiliser.

En C++ :

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

En QML, vous pouvez sélectionner la caméra en définissant la propriété ` Camera::cameraDevice `. En C++, vous pouvez également sélectionner une caméra en fonction de son orientation physique plutôt qu'en fonction de ses informations. Cela s'avère utile sur les appareils mobiles, qui disposent souvent d'une caméra avant et d'une caméra arrière.

En C++ :

camera = new QCamera(QCameraDevice::FrontFace);

Si aucune propriété ` QCameraDevice ` n’est spécifiée, le périphérique par défaut sera utilisé. Le périphérique par défaut est choisi en fonction des informations fournies par le système d’exploitation. Sur les plateformes de bureau, l’appareil photo par défaut est généralement défini par l’utilisateur final dans les paramètres système. Sur un appareil mobile, la caméra arrière est généralement le périphérique de caméra par défaut. Vous pouvez obtenir le périphérique de caméra par défaut à l'aide de la fonction ` QMediaDevices::defaultVideoInput()` en C++, ou de ` MediaDevices.defaultVideoInput ` en QML.

Le périphérique de caméra par défaut peut changer au fil du temps, par exemple si l’utilisateur final déconnecte le périphérique de caméra par défaut actuel. Les développeurs d’applications peuvent suivre ce changement en interrogeant à nouveau le périphérique de caméra par défaut lorsque le signal QMediaDevices::videoInputsChanged est émis.

Aperçu

Bien que cela ne soit pas strictement nécessaire, il est souvent utile de pouvoir voir ce que la caméra filme. C'est ce qu'on appelle un aperçu.

Selon que vous utilisiez QML ou C++, plusieurs méthodes s’offrent à vous. En QML, vous pouvez utiliser conjointement ` Camera ` et `videoOutput` pour surveiller une `captureSession`.

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

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

En C++, votre choix dépend de l'utilisation de widgets ou d'QGraphicsView. La classe QVideoWidget est utilisée dans le cas des widgets, tandis que QGraphicsVideoItem est utile pour QGraphicsView.

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

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

Pour une utilisation avancée (comme le traitement des images de prévisualisation au fur et à mesure de leur réception, ce qui permet la détection d’objets ou de motifs), vous pouvez également utiliser votre propre ` QVideoSink ` et le définir comme `videoOutput` pour ` QMediaCaptureSession`. Dans ce cas, vous devrez générer vous-même l’image de prévisualisation en traitant les données reçues via le signal `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

Sur les appareils mobiles, l’image d’aperçu est par défaut orientée de la même manière que l’appareil. Ainsi, lorsque l’utilisateur fait pivoter l’appareil, l’image d’aperçu bascule entre le mode portrait et le mode paysage. Une fois l'enregistrement lancé, l'orientation sera verrouillée. Pour éviter une expérience utilisateur médiocre, vous devriez également verrouiller l'orientation de l'interface utilisateur de l'application pendant l'enregistrement. Pour ce faire, utilisez la propriété « contentOrientation » de ` QWindow`.

Images fixes

Après avoir configuré un viseur et trouvé un sujet photogénique, pour capturer une image, il faut initialiser un nouvel objet ` QImageCapture `. Il suffit ensuite de lancer l’appareil photo et de capturer l’image.

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();

Vidéos

Nous avons vu précédemment du code permettant de capturer une image fixe. L'enregistrement d'une vidéo nécessite l'utilisation d'un objet ` QMediaRecorder `.

Pour enregistrer une vidéo, nous devons créer un objet `camera` comme précédemment, mais cette fois-ci, en plus de créer un viseur, nous allons également initialiser un objet `media recorder`.

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

camera->start();

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

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

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

Les signaux provenant de QMediaRecorder peuvent être connectés à des slots afin de réagir aux changements d’état du processus d’encodage ou aux événements d’erreur. L’enregistrement démarre lorsque la fonction QMediaRecorder::record() est appelée. Cela provoque l’émission du signal recorderStateChanged(). L’enregistrement est contrôlé par les slots record(), stop() et pause() de QMediaRecorder.

Contrôle de la chaîne de traitement d’images

Maintenant que les bases de la capture d’images et de vidéos ont été abordées, il existe plusieurs façons de contrôler le pipeline d’imagerie afin de mettre en œuvre des techniques intéressantes. Comme expliqué précédemment, plusieurs éléments physiques et électroniques se combinent pour déterminer les images finales, et vous pouvez les contrôler à l’aide de différentes classes.

Mise au point et zoom

QCamera vous permet de définir la politique générale de mise au point à l'aide des énumérations de la classe ` FocusMode`. La classe ` FocusMode ` gère des paramètres tels que ` QCamera::FocusModeAuto` et ` QCamera::FocusModeInfinity`.

Pour les caméras qui le prennent en charge, l'option « QCamera::FocusModeAutoNear » permet de capturer des images d'objets situés à proximité du capteur. Cette fonctionnalité est utile dans des applications telles que la reconnaissance de codes-barres ou la numérisation de cartes de visite.

Outre la mise au point, la fonction ` QCamera ` vous permet de contrôler toute fonctionnalité de zoom disponible à l’aide de ` setZoomFactor()` ou ` zoomTo()`. La plage de zoom disponible peut être limitée ou entièrement fixée à l’unité (1:1). La plage autorisée peut être vérifiée à l’aide de ` minimumZoomFactor()` et ` maximumZoomFactor()`.

Exposition, vitesse d'obturation et flash

Plusieurs paramètres influent sur la quantité de lumière qui atteint le capteur de l'appareil photo, et donc sur la qualité de l'image obtenue.

Les principaux réglages pour la prise de vue en mode automatique sont l'exposure mode et l'flash mode. Plusieurs autres paramètres (tels que le réglage ISO et la durée d'exposition) sont généralement gérés automatiquement, mais peuvent également être modifiés manuellement si vous le souhaitez.

Enfin, cette classe vous permet de contrôler le flash (le cas échéant). Dans certains cas, celui-ci peut également servir de lampe de poche.

Traitement d'image

La classe ` QCamera ` vous permet de régler la partie du pipeline dédiée au traitement d'image. Ces paramètres comprennent :

• white balance (également appelée « température de couleur »)

La plupart des appareils photo prennent en charge les réglages automatiques pour tous ces paramètres ; vous ne devriez donc pas avoir besoin de les modifier, sauf si l'utilisateur souhaite un réglage spécifique.

Exemples

Des exemples en C++ et en QML sont disponibles.

Exemples en C++

Exemples QML

Documentation de référence

Classes C++

Types QML