Augmentation de la résolution de capture de la caméra dans OpenCV

Question

Dans mon programme C/C++, j'utilise OuvrirCV pour capturer des images de ma webcam.L'appareil photo (Logitech QuickCam IM) peut capturer à des résolutions 320x240, 640x480 et 1280x960.Mais, pour une raison étrange, OpenCV me donne des images de résolution 320x240 seulement.Appels pour changer la résolution en utilisant cvSetCaptureProperty() avec d'autres valeurs de résolution, cela ne fonctionne tout simplement pas.Comment capturer des images avec les autres résolutions possibles avec ma webcam ?

Answer 1

Il ne semble pas y avoir de solution.La résolution peut être augmentée à 640x480 en utilisant ce hack partagé par bouée de sauvetage77.Voici les détails reproduits :

Ajouter à highgui.h:

#define CV_CAP_PROP_DIALOG_DISPLAY 8
#define CV_CAP_PROP_DIALOG_FORMAT 9
#define CV_CAP_PROP_DIALOG_SOURCE 10
#define CV_CAP_PROP_DIALOG_COMPRESSION 11
#define CV_CAP_PROP_FRAME_WIDTH_HEIGHT 12

Ajouter la fonction icvSetPropertyCAM_VFW à cvcap.cpp:

static int icvSetPropertyCAM_VFW( CvCaptureCAM_VFW* capture, int property_id, double value )
{
    int result = -1;
    CAPSTATUS capstat;
    CAPTUREPARMS capparam;
    BITMAPINFO btmp;

    switch( property_id )
    {
        case CV_CAP_PROP_DIALOG_DISPLAY:
            result = capDlgVideoDisplay(capture->capWnd);
            //SendMessage(capture->capWnd,WM_CAP_DLG_VIDEODISPLAY,0,0);
            break;

        case CV_CAP_PROP_DIALOG_FORMAT:
            result = capDlgVideoFormat(capture->capWnd);
            //SendMessage(capture->capWnd,WM_CAP_DLG_VIDEOFORMAT,0,0);
            break;

        case CV_CAP_PROP_DIALOG_SOURCE:
            result = capDlgVideoSource(capture->capWnd);
            //SendMessage(capture->capWnd,WM_CAP_DLG_VIDEOSOURCE,0,0);
            break;

        case CV_CAP_PROP_DIALOG_COMPRESSION:
            result = capDlgVideoCompression(capture->capWnd);
            break;

        case CV_CAP_PROP_FRAME_WIDTH_HEIGHT:
            capGetVideoFormat(capture->capWnd, &btmp, sizeof(BITMAPINFO));
            btmp.bmiHeader.biWidth = floor(value/1000);
            btmp.bmiHeader.biHeight = value-floor(value/1000)*1000;
            btmp.bmiHeader.biSizeImage = btmp.bmiHeader.biHeight *
            btmp.bmiHeader.biWidth * btmp.bmiHeader.biPlanes *
            btmp.bmiHeader.biBitCount / 8;
            capSetVideoFormat(capture->capWnd, &btmp, sizeof(BITMAPINFO));
            break;

        default:
            break;
    }

    return result;
}

et éditer captureCAM_VFW_vtable comme suit:

static CvCaptureVTable captureCAM_VFW_vtable =
{
6,
(CvCaptureCloseFunc)icvCloseCAM_VFW,
(CvCaptureGrabFrameFunc)icvGrabFrameCAM_VFW,
(CvCaptureRetrieveFrameFunc)icvRetrieveFrameCAM_VFW,
(CvCaptureGetPropertyFunc)icvGetPropertyCAM_VFW,
(CvCaptureSetPropertyFunc)icvSetPropertyCAM_VFW, // was NULL
(CvCaptureGetDescriptionFunc)0
};

Maintenant reconstruit highgui.dll.

Answer 2

J'utilise openCV 1.1pre1 sous Windows (la bibliothèque videoinput est utilisée par défaut par cette version d'openCv sous Windows).

Avec ces instructions, je peux définir la résolution de la caméra.Notez que j'appelle l'ancien cvCreateCameraCapture au lieu de cvCaptureFromCam.

capture = cvCreateCameraCapture(cameraIndex);

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, 640 );

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, 480 );


videoFrame = cvQueryFrame(capture);

Je l'ai testé avec les webcams Logitech, Trust et Philips

Answer 3

J'ai déjà effectué du traitement d'image sous Linux et j'ai ignoré la fonctionnalité de caméra intégrée d'OpenCV car elle est (comme vous l'avez découvert) incomplète.

En fonction de votre système d'exploitation, vous aurez peut-être plus de chance d'accéder directement au matériel via les canaux normaux plutôt que via openCV.Si vous utilisez Linux, video4linux ou video4linux2 devrait vous donner un accès relativement trivial aux webcams USB et vous pouvez utiliser libavc1394 pour Firewire.En fonction de l'appareil et de la qualité de l'exemple de code que vous suivez, vous devriez pouvoir faire fonctionner l'appareil avec les paramètres souhaités en une heure ou deux.

Modifié pour ajouter :Vous êtes seul si c'est Windows.J'imagine que ce n'est pas beaucoup plus difficile mais je ne l'ai jamais fait.

Answer 4

Je suggère fortement d'utiliser Bibliothèque d'entrée vidéo, il prend en charge n'importe quel appareil DirectShow (même plusieurs appareils en même temps) et est plus configurable.Vous passerez cinq minutes à le faire jouer avec OpenCV.

Answer 5

Découvrez ce billet :https://code.ros.org/trac/opencv/ticket/376

"La solution consiste à utiliser le nouveau wrapper basé sur libv4l.

1. installez libv4l-dev (c'est ainsi qu'on l'appelle dans Ubuntu)

2. réexécutez cmake, vous verrez "V4L/V4L2 :Utiliser libv4l"

3. relancer make.maintenant la résolution peut être modifiée.testé avec isight intégré sur MBP."

Cela a résolu le problème pour moi en utilisant Ubuntu et pourrait également fonctionner pour vous.

Answer 6

Code J'ai finalement commencé à travailler en Python une fois qu'Aaron Haun a souligné que je devais définir les arguments de la fonction set avant de les utiliser.

#Camera_Get_Set.py
#By Forrest L. Erickson of VRX Company Inc. 8-31-12.
#Opens the camera and reads and reports the settings.
#Then tries to set for higher resolution.
#Workes with Logitech C525 for resolutions 960 by 720 and 1600 by 896


import cv2.cv as cv
import numpy

CV_CAP_PROP_POS_MSEC = 0
CV_CAP_PROP_POS_FRAMES = 1
CV_CAP_PROP_POS_AVI_RATIO = 2
CV_CAP_PROP_FRAME_WIDTH = 3
CV_CAP_PROP_FRAME_HEIGHT = 4
CV_CAP_PROP_FPS = 5
CV_CAP_PROP_POS_FOURCC = 6
CV_CAP_PROP_POS_FRAME_COUNT = 7
CV_CAP_PROP_BRIGHTNESS = 8
CV_CAP_PROP_CONTRAST = 9
CV_CAP_PROP_SATURATION = 10
CV_CAP_PROP_HUE = 11

CV_CAPTURE_PROPERTIES = tuple({
CV_CAP_PROP_POS_MSEC,
CV_CAP_PROP_POS_FRAMES,
CV_CAP_PROP_POS_AVI_RATIO,
CV_CAP_PROP_FRAME_WIDTH,
CV_CAP_PROP_FRAME_HEIGHT,
CV_CAP_PROP_FPS,
CV_CAP_PROP_POS_FOURCC,
CV_CAP_PROP_POS_FRAME_COUNT,
CV_CAP_PROP_BRIGHTNESS,
CV_CAP_PROP_CONTRAST,
CV_CAP_PROP_SATURATION,
CV_CAP_PROP_HUE})

CV_CAPTURE_PROPERTIES_NAMES = [
"CV_CAP_PROP_POS_MSEC",
"CV_CAP_PROP_POS_FRAMES",
"CV_CAP_PROP_POS_AVI_RATIO",
"CV_CAP_PROP_FRAME_WIDTH",
"CV_CAP_PROP_FRAME_HEIGHT",
"CV_CAP_PROP_FPS",
"CV_CAP_PROP_POS_FOURCC",
"CV_CAP_PROP_POS_FRAME_COUNT",
"CV_CAP_PROP_BRIGHTNESS",
"CV_CAP_PROP_CONTRAST",
"CV_CAP_PROP_SATURATION",
"CV_CAP_PROP_HUE"]


capture = cv.CaptureFromCAM(0)

print ("\nCamera properties before query of frame.")
for i in range(len(CV_CAPTURE_PROPERTIES_NAMES)):
#    camera_valeus =[CV_CAPTURE_PROPERTIES_NAMES, foo]
    foo = cv.GetCaptureProperty(capture, CV_CAPTURE_PROPERTIES[i])
    camera_values =[CV_CAPTURE_PROPERTIES_NAMES[i], foo]
#    print str(camera_values)
    print str(CV_CAPTURE_PROPERTIES_NAMES[i]) + ": " + str(foo)


print ("\nOpen a window for display of image")
cv.NamedWindow("Camera", 1)
while True:
    img = cv.QueryFrame(capture)
    cv.ShowImage("Camera", img)
    if cv.WaitKey(10) == 27:
        break
cv.DestroyWindow("Camera")


#cv.SetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 1024)
#cv.SetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 768)
cv.SetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 1600)
cv.SetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 896)


print ("\nCamera properties after query and display of frame.")
for i in range(len(CV_CAPTURE_PROPERTIES_NAMES)):
#    camera_valeus =[CV_CAPTURE_PROPERTIES_NAMES, foo]
    foo = cv.GetCaptureProperty(capture, CV_CAPTURE_PROPERTIES[i])
    camera_values =[CV_CAPTURE_PROPERTIES_NAMES[i], foo]
#    print str(camera_values)
    print str(CV_CAPTURE_PROPERTIES_NAMES[i]) + ": " + str(foo)


print ("/nOpen a window for display of image")
cv.NamedWindow("Camera", 1)
while True:
    img = cv.QueryFrame(capture)
    cv.ShowImage("Camera", img)
    if cv.WaitKey(10) == 27:
        break
cv.DestroyWindow("Camera")

Answer 7

J'utilise Debian et Ubuntu, j'ai eu le même problème, je n'ai pas pu changer la résolution de l'entrée vidéo en utilisant CV_CAP_PROP_FRAME_WIDTH et CV_CAP_PROP_FRAME_HEIGHT

Il s'est avéré que la raison était une bibliothèque manquante.j'ai installé lib4l-dev par synaptique, reconstruit OpenCV et le problème est RÉSOLU !

Answer 8

Je publie ceci pour m'assurer que personne d'autre ne perd de temps sur cette fonction setproperty.J'ai passé 2 jours là-dessus pour voir que rien ne semble fonctionner.J'ai donc extrait le code (j'avais installé la bibliothèque la première fois).C'est ce qui se passe réellement - cvSetCaptureProperty, appelle setProperty dans la classe CvCapture et voilà, setProperty ne fait rien.Cela renvoie simplement faux.Au lieu de cela, je vais utiliser une autre bibliothèque pour alimenter OpenCV en capture vidéo/images.J'utilise OpenCV 2.2

Answer 9

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, WIDTH );

cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, HEIGHT);

cvQueryFrame(capturer);

Cela ne fonctionnera pas avec OpenCV 2.2, mais si vous utilisez OpenCV 2.1 cela fonctionnera bien !

Answer 10

Si vous êtes sur la plate-forme Windows, essayez DirectShow (IAMStreamConfig).

http://msdn.microsoft.com/en-us/library/dd319784%28v=vs.85%29.aspx

Answer 11

Sous Windows, essayez d'utiliser la bibliothèque VideoInput :http://robocraft.ru/blog/computervision/420.html

Answer 12

Je trouve que sous Windows (de Win98 à WinXP SP3), OpenCV utilise souvent la bibliothèque VFW de Microsoft pour accéder à la caméra.Le problème est qu'il est souvent très lent (disons une capture d'image maximale de 15 FPS) et bogué (d'où la raison pour laquelle cvSetCaptureProperty ne fonctionne souvent pas).Heureusement, vous pouvez généralement modifier la résolution dans d'autres logiciels (en particulier "AMCAP", qui est un programme de démonstration facilement disponible) et cela affectera la résolution qu'OpenCV utilisera.Par exemple, vous pouvez exécuter AMCAP pour définir la résolution sur 640x480, puis OpenCV l'utilisera par défaut à partir de ce moment !

Mais si vous pouvez utiliser une autre bibliothèque d'accès à la caméra Windows telle que la bibliothèque "videoInput" http://muonics.net/school/spring05/videoInput/ qui accède à la caméra en utilisant DirectShow très efficace (qui fait partie de DirectX).Ou si vous disposez d'une caméra de qualité professionnelle, elle sera souvent livrée avec une API personnalisée qui vous permet d'accéder à la caméra, et vous pourrez l'utiliser pour un accès rapide avec la possibilité de modifier la résolution et bien d'autres choses.

Answer 13

Juste une information qui pourrait être précieuse pour les personnes ayant des difficultés à changer la résolution de capture par défaut (640 x 480) !J'ai moi-même expérimenté un tel problème avec opencv 2.4.x et une caméra Logitech...et j'ai trouvé une solution de contournement !

Le comportement que j'ai détecté est que le format par défaut est configuré comme paramètres initiaux lorsque la capture de la caméra est démarrée (cvCreateCameraCapture), et toutes les demandes de modification de hauteur ou de largeur :

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, ... 

ou

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, ...

ne sont pas possibles après !En effet, j'ai découvert en ajoutant l'erreur de retour des fonctions ioctl que le pilote V4l2 renvoie ÉBUSY pour ces demandes !Par conséquent, une solution de contournement devrait consister à modifier la valeur par défaut directement dans highgui/cap_v4l.cpp :

*#define DEFAULT_V4L_WIDTH  1280    // Originally 640* 

*#define DEFAULT_V4L_HEIGHT 720     // Originally 480*

Après ça, j'ai juste recompilé ouvrir cv ...et suis arrivé à obtenir du 1280 x 720 sans aucun problème !Bien sûr, une meilleure solution devrait être d'arrêter l'acquisition, de modifier les paramètres et de redémarrer le flux après, mais je ne connais pas suffisamment opencv pour faire cela !

J'espère que cela aidera.

Michel BEGEY

Answer 14

Essaye ça:

capture = cvCreateCameraCapture(-1);
//set resolution
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, frameWidth);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, frameHeight);

Answer 15

cvQueryFrame(capture);

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, any_supported_size );

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, any_supported_size);

cvQueryFrame(capture);

ça devrait suffire !