Discussion :

[Photon4691]

Bonjour,

j'ai ce problème de framerate avec opencv. Dans mon programme je peux appuyer sur une touche longuement, et j'ai un imshow et un waitkey pour afficher en continue. Seulement quand j'appuie longuement sur une touche, le programme lag à cause de cela, j'imagine que le buffer grossi avant de surcharger waitkey... Je me demande comment je suis censé régler ce problème... Visiblement opencv accède au buffer quoi qu'il arrive, même en utilisant des threads par exemple. le problème reste que waitkey accède au buffer lié à mon clavier. Auriez vous la moindre idée de comment je pourrais régler ce problème ? Merci

[fred1599]

Hello,

Votre question est trop basique pour une réponse bien plus complexe, vous ne spécifiez pas sur quel OS vous faîtes tourner votre application, alors que c'est le fonctionnement du système et la manière dont sont gérés les événements qui est la base de votre problème (je suppose que votre OS est Windows...) ! Lorsque la fréquence de génération des événements clavier par le système d'exploitation dépasse la fréquence de rafraîchissement de la boucle principale de l'application, souvent ralentie par des traitements d'image lourds, le tampon d'événements sature.

Lorsqu'un utilisateur appuie sur une touche et la maintient enfoncée, le contrôleur matériel du clavier détecte la fermeture du circuit et envoie un code de scan ("scancode") au contrôleur d'interruptions du processeur. Le noyau du système d'exploitation (Kernel) intercepte cette interruption via son pilote de périphérique. À ce stade, une première transformation s'opère : le pilote traduit le scancode brut en un code de touche virtuel ("Virtual Key Code") standardisé par l'OS.
Cependant, la complexité s'accroît avec la fonctionnalité de répétition automatique ("Typematic Repeat"). Cette fonctionnalité n'est pas toujours gérée par le matériel, mais souvent synthétisée par le système d'exploitation.

Sans plus d'éclaircissement, je proposerai ce concept : Au lieu d'appeler cv::waitKey(1) une seule fois par itération, l'application doit boucler sur waitKey(1) tant que des événements sont présents dans la file d'attente. Cela permet de "vider" (flush) le tampon de tous les événements de répétition accumulés pendant le traitement de l'image précédente.

Voici une implémentation rapide en C++

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <opencv2/opencv.hpp>
#include <iostream>
 
void processingLoop() {
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) return;
 
    cv::Mat frame;
    while (true) {
        // 1. Acquisition et Traitement (Temps consommateur)
        cap >> frame;
        if (frame.empty()) break;
 
        // Simulation d'un traitement lourd (ex: 50ms)
        // C'est ce temps qui permet au buffer clavier de se remplir
        // doHeavyProcessing(frame); 
 
        cv::imshow("Flux Video", frame);
 
        // 2. Stratégie de Drainage du Tampon
        int key = -1;
        int tempKey = -1;
 
        // On boucle tant que waitKey renvoie un code valide (!= -1)
        // waitKey(1) est utilisé pour garantir un passage rapide mais traiter l'événement
        while ((tempKey = cv::waitKey(1))!= -1) {
            key = tempKey; // On ne garde que la dernière touche pressée
            // Si on voulait détecter des frappes uniques, on pourrait stocker tempKey dans un vecteur
        }
 
        // 3. Logique de Contrôle
        // À ce stade, 'key' contient l'état le plus récent du clavier (ou -1 si rien)
        // Tous les événements "en retard" ont été consommés et ignorés par la boucle while
 
        if (key == 27) { // Touche ESC pour quitter
            break; 
        } else if (key == 'a') {
            std::cout << "Action A activée (sans latence accumulée)" << std::endl;
        }
    }
}