Vue d'ensemble de l'appareil photo

L'API Qt Multimedia fournit un certain nombre de classes relatives aux caméras, afin que vous puissiez accéder aux images et aux vidéos des caméras des appareils mobiles ou des caméras Web. Il existe des API C++ et QML pour les tâches courantes.

Caractéristiques de la caméra

Afin d'utiliser les classes de caméras, il est nécessaire d'avoir une vue d'ensemble du fonctionnement d'une caméra. Si vous êtes déjà familiarisé avec ce fonctionnement, vous pouvez passer directement aux détails de l'implémentation de la caméra. Pour une explication plus détaillée du fonctionnement d'une caméra, consultez le clip YouTube suivant.

L'assemblage de l'objectif

À l'une des extrémités de l'appareil photo se trouve l'objectif (une ou plusieurs lentilles, disposées de manière à focaliser la lumière sur le capteur). Les objectifs eux-mêmes peuvent parfois être déplacés pour ajuster des éléments tels que la mise au point et le zoom. Ils peuvent également être fixés de manière à obtenir 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 de manière à ce qu'un objet situé à différentes distances de l'appareil photo reste net. Cela se fait généralement en mesurant la netteté d'une zone particulière du cadre, puis en réglant l'ensemble de l'objectif pour obtenir la meilleure netteté possible. Dans certains cas, l'appareil photo utilisera toujours le centre du cadre pour cette opération. Dans d'autres cas, l'appareil photo peut également permettre de spécifier cette zone de mise au point cible. Voici quelques exemples de cette fonction :

• Zoom sur le visage : Utilisation de la vision par ordinateur pour détecter et utiliser un ou plusieurs visages comme cible.
• Toucher pour zoomer : Permet à l'utilisateur de sélectionner manuellement une zone via l'écran de prévisualisation.

Le capteur

Une fois que la lumière arrive au capteur, elle est convertie en pixels numériques. Ce processus peut dépendre d'un certain nombre de facteurs, mais se résume en fin de compte à deux choses :

• La durée de la conversion. C'est ce qu'on appelle le temps d'exposition.
• La luminosité de la lumière.

Plus la conversion est longue, meilleure est la qualité de l'image obtenue. L'utilisation d'un flash peut contribuer à laisser plus de lumière atteindre le capteur, ce qui lui permet de convertir les pixels plus rapidement et d'obtenir une meilleure qualité pour le même laps de temps. Inversement, un temps de conversion plus long peut vous permettre de prendre des photos dans des environnements plus sombres, à condition que l'appareil photo soit stable. Si l'appareil photo bouge pendant que le capteur enregistre, l'image obtenue est floue.

Traitement de l'image

Une fois que l'image a été capturée par le capteur, le micrologiciel de l'appareil photo effectue diverses tâches de traitement de l'image afin de compenser les différentes caractéristiques du capteur, l'éclairage actuel et les propriétés souhaitées de l'image. Les temps de conversion plus rapides des pixels du capteur peuvent introduire du bruit numérique. Un certain degré de traitement de l'image peut donc être effectué pour supprimer ce bruit, en fonction des paramètres du capteur de l'appareil photo.

La couleur de l'image peut également être ajustée à ce stade pour compenser les différentes sources de lumière - les lampes fluorescentes et la lumière du soleil donnent des apparences très différentes au même objet, de sorte que l'image peut être ajustée sur la base de la balance des blancs de l'image (en raison des différentes températures de couleur des sources de lumière).

Certaines formes d'"effets spéciaux" peuvent également être réalisées à ce stade. Des images en noir et blanc, en sépia ou en style "négatif" peuvent être produites.

Enregistrement 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 utilisée à bon escient. Les images de la caméra peuvent être traitées par le code de l'application (par exemple, pour détecter des codes-barres ou pour assembler une image panoramique), ou enregistrées dans un format courant comme le JPEG, ou encore utilisées pour créer un film. La plupart de ces tâches sont assistées par des classes.

Détails de l'implémentation de la caméra

Détection et sélection d'une caméra

Avant d'utiliser les API de caméra, vous devez vérifier qu'une caméra est disponible au moment de l'exécution. Si aucune caméra n'est disponible, vous pouvez désactiver les fonctions 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()
{
    if (QMediaDevices::videoInputs().count() > 0)
        return true;
    else
        return false;
}

Accédez à une caméra en utilisant la classe QCamera en C++ ou le type Camera en QML.

Lorsque plusieurs appareils photo sont disponibles, vous pouvez spécifier lequel 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 un appareil photo en fonction de son orientation physique plutôt qu'en fonction des informations relatives à l'appareil photo. Cette fonction est utile sur les appareils mobiles, qui disposent souvent d'une caméra frontale et d'une caméra dorsale.

En C++ :

camera = new QCamera(QCameraDevice::FrontFace);

Si aucun QCameraDevice n'est spécifié, 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 du système. Sur un appareil mobile, l'appareil photo dorsal est généralement l'appareil photo par défaut. Vous pouvez obtenir l'appareil photo par défaut avec QMediaDevices::defaultVideoInput() en C++, ou MediaDevices.defaultVideoInput en QML.

L'appareil photo par défaut peut changer au fil du temps, par exemple si l'utilisateur final déconnecte l'appareil photo par défaut actuel. Les développeurs d'applications peuvent suivre le changement en interrogeant à nouveau l'appareil photo 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 vers quoi la caméra pointe. C'est ce qu'on appelle un aperçu.

Selon que vous utilisez QML ou C++, vous pouvez le faire de différentes manières. En QML, vous pouvez utiliser Camera et videoOutput ensemble pour surveiller une session 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 de QGraphicsView. La classe QVideoWidget est utilisée dans le cas des widgets, et 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, ce qui permet de détecter des objets ou des motifs), vous pouvez également utiliser votre propre QVideoSink et le définir comme sortie vidéo pour QMediaCaptureSession. Dans ce cas, vous devrez rendre l'image de prévisualisation vous-même en traitant les données reçues du 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 de prévisualisation 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 de prévisualisation passe du mode portrait au mode paysage. Lorsque vous commencez à enregistrer, l'orientation est verrouillée. Pour éviter une mauvaise expérience utilisateur, vous devez également verrouiller l'orientation de l'interface utilisateur de l'application pendant l'enregistrement. Pour ce faire, vous pouvez utiliser la propriété contentOrientation de QWindow.

Images fixes

Après avoir installé un viseur et trouvé quelque chose de photogénique, nous devons, pour capturer une image, initialiser un nouvel objet QImageCapture. Il suffit ensuite de démarrer 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();

Les films

Nous avons vu précédemment un code permettant la capture d'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 caméra comme précédemment, mais cette fois-ci, en plus de créer un viseur, nous allons également initialiser un objet enregistreur de médias.

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

Les signaux du QMediaRecorder peuvent être connectés à des slots pour réagir aux changements d'état du processus d'encodage ou aux événements d'erreur. L'enregistrement commence lorsque QMediaRecorder::record() est appelé. Le signal recorderStateChanged() est alors émis. L'enregistrement est contrôlé par les slots record(), stop() et pause() de QMediaRecorder.

Contrôle du pipeline d'imagerie

Maintenant que les principes de base de la capture d'images et de vidéos sont couverts, il existe un certain nombre de façons de contrôler le pipeline d'imagerie afin de mettre en œuvre des techniques intéressantes. Comme nous l'avons 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 au moyen des enums de la classe FocusMode. FocusMode traite des paramètres tels que QCamera::FocusModeAuto, et QCamera::FocusModeInfinity.

Pour les appareils photo qui le prennent en charge, QCamera::FocusModeAutoNear permet de prendre des images d'objets proches du capteur. Cela 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, 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

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

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

Enfin, vous pouvez contrôler le flash (s'il est présent) à l'aide de cette classe. Dans certains cas, le matériel peut également servir de torche.

Traitement de l'image

La classe QCamera vous permet de régler la partie traitement d'image du pipeline. Ces réglages comprennent :

• white balance la température de couleur (également connue sous le nom de température de couleur)

La plupart des caméras prennent en charge les réglages automatiques pour tous ces paramètres, vous ne devriez donc pas avoir besoin de les ajuster à moins que l'utilisateur ne souhaite un réglage spécifique.

Exemples de réglages

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

Exemples C++

Exemples QML

Documentation de référence

Classes C++

Types QML