Erhöhen der Auflösung der Kameraaufnahme in OpenCV

In meinem C/C++-Programm verwende ich OpenCV um Bilder von meiner Webcam aufzunehmen. Die Kamera (Logitech QuickCam IM) kann mit Auflösungen erfassen 320 x 240, 640 x 480 und 1280 x 960. Aber aus irgendeinem seltsamen Grund gibt mir OpenCV Bilder mit Auflösung 320 x 240 nur. Aufrufe zum Ändern der Auflösung mit cvSetCaptureProperty() mit anderen Auflösungswerten funktionieren einfach nicht. Wie nehme ich Bilder mit anderen Auflösungen auf, die mit meiner Webcam möglich sind?

Ich verwende openCV 1.1pre1 unter Windows (die Videoeingangsbibliothek wird standardmäßig von dieser Version von openCv unter Windows verwendet).

Mit dieser Anleitung kann ich die Kameraauflösung einstellen. Beachten Sie, dass ich das alte cvCreateCameraCapture anstelle von cvCaptureFromCam nenne.

capture = cvCreateCameraCapture(cameraIndex);

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, 640 );

cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, 480 );


videoFrame = cvQueryFrame(capture);

Ich habe es mit Webcams von Logitech, Trust und Philips getestet

Eine Lösung scheint es nicht zu geben. Die Auflösung kann erhöht werden 640 x 480 verwenden dieser Hack geteilt von Rettungsring77. Hier sind die Details wiedergegeben:

Hinzufügen 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

Fügen Sie die Funktion hinzu icvSetPropertyCAM_VFW zu 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;
}

und bearbeiten captureCAM_VFW_vtable wie folgt:

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
};

Jetzt umgebaut highgui.dll.

Ich habe zuvor Bildverarbeitung in Linux durchgeführt und die integrierte Kamerafunktion von OpenCV übersprungen, da sie (wie Sie festgestellt haben) unvollständig ist.

Abhängig von Ihrem Betriebssystem haben Sie möglicherweise mehr Glück, wenn Sie über normale Kanäle direkt zur Hardware gelangen, als über openCV. Wenn Sie Linux verwenden, sollten Ihnen video4linux oder video4linux2 relativ einfachen Zugriff auf USB-Webcams geben, und Sie können libavc1394 für Firewire verwenden. Abhängig vom Gerät und der Qualität des Beispielcodes, dem Sie folgen, sollten Sie in der Lage sein, das Gerät mit den gewünschten Parametern in ein oder zwei Stunden zum Laufen zu bringen.

Bearbeitet zum Hinzufügen: Sie sind auf sich allein gestellt, wenn es Windows ist. Ich stelle mir vor, dass es nicht viel schwieriger ist, aber ich habe es noch nie gemacht.

Ich empfehle dringend die Verwendung VideoInput-lib, es unterstützt jedes DirectShow-Gerät (sogar mehrere Geräte gleichzeitig) und ist besser konfigurierbar. Sie verbringen fünf Minuten damit, es mit OpenCV abzuspielen.

Sehen Sie sich dieses Ticket an:
https://code.ros.org/trac/opencv/ticket/376

„Die Lösung besteht darin, den neueren libv4l-basierten Wrapper zu verwenden.

1. installiere libv4l-dev (so heißt es in Ubuntu)

2. Führen Sie cmake erneut aus, Sie werden “V4L/V4L2: Using libv4l” sehen.

3. erneut ausführen machen. Jetzt kann die Auflösung geändert werden. getestet mit eingebautem isight auf MBP.”

Dies hat es für mich mit Ubuntu behoben und könnte auch für Sie funktionieren.

Code Ich habe endlich angefangen, in Python zu arbeiten, nachdem Aaron Haun darauf hingewiesen hat, dass ich die Argumente der set-Funktion definieren muss, bevor ich sie verwende.

#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")

Ich verwende Debian und Ubuntu, ich hatte das gleiche Problem, ich konnte die Auflösung der Videoeingabe nicht ändern CV_CAP_PROP_FRAME_WIDTH und CV_CAP_PROP_FRAME_HEIGHT

Es stellte sich heraus, dass der Grund eine fehlende Bibliothek war. ich installierte lib4l-dev durch synaptische, wieder aufgebaut OpenCV und das Problem ist gelöst!