c++ - Query maximum webcam resolution in OpenCV

Question

I'm dealing with several types of cameras and I need to know the maximum resolution each one is capable.

Is there a way to query such property in OpenCV?

If not, is there any other way? The application will work under Windows (by the moment) and all the project is being developed using C++.

score 16 · Accepted Answer

A trick that's working for me:

Just set to a very high resolution (above the capabilities of any usual capture device), then get the current resolution. You will see that the device will automatically switch to his maximum value.

Code example in Python with OpenCV 3.0:

HIGH_VALUE = 10000
WIDTH = HIGH_VALUE
HEIGHT = HIGH_VALUE

self.__capture = cv2.VideoCapture(0)
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.__capture.set(cv2.CAP_PROP_FRAME_WIDTH, WIDTH)
self.__capture.set(cv2.CAP_PROP_FRAME_HEIGHT, HEIGHT)

width = int(self.__capture.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(self.__capture.get(cv2.CAP_PROP_FRAME_HEIGHT))

Hope it helps.

score 4 · Accepted Answer

FINAL SOLUTION

As the accepted answered by user2949634 was written in Python, I'm posting the equivalent implementation in C++ for completeness:

void query_maximum_resolution(cv::VideoCapture* camera, int& max_width, int& max_height)
{
  // Save current resolution
  const int current_width  = static_cast<int>(camera->get(CV_CAP_PROP_FRAME_WIDTH));
  const int current_height = static_cast<int>(camera->get(CV_CAP_PROP_FRAME_HEIGHT));

  // Get maximum resolution
  camera->set(CV_CAP_PROP_FRAME_WIDTH,  10000);
  camera->set(CV_CAP_PROP_FRAME_HEIGHT, 10000);
  max_width  = static_cast<int>(camera->get(CV_CAP_PROP_FRAME_WIDTH));
  max_height = static_cast<int>(camera->get(CV_CAP_PROP_FRAME_HEIGHT));

  // Restore resolution
  camera->set(CV_CAP_PROP_FRAME_WIDTH,  current_width);
  camera->set(CV_CAP_PROP_FRAME_HEIGHT, current_height);
}

score 2 · Accepted Answer

VideoCapture::get(int propId)

Passing in CV_CAP_PROP_FRAME_WIDTH and CV_CAP_PROP_FRAME_HEIGHT will get you the resolution.

For getting the maximum possible resolution, all the functionality for cv::VideoCapture is in that link. There does not seem to be a possible way to do that directly, probably because many cameras expect you to know the possible resolutions from the manual and to set some flags to toggle what you want. One thing you can try is to keep a list of all common resolutions, then try all of them for each camera with VideoCapture::set while checking the return value to see if it was successful. There aren't many resolutions to search, so this should be viable.

score 2 · Accepted Answer

Searching on same topic myself : As previously answered there is no direct property, but you could find supported resolutions trying to figure out accepted camera resolutions :

trying all possible common resolutions
probing minimum resolution and increasing width/height

Here C++ OpenCV 2.4.8/Windows tested code sample

trying common resolutions solution :

const CvSize CommonResolutions[] = {
  cvSize(120, 90),
  cvSize(352, 240),
  cvSize(352, 288),
  // and so on
  cvSize(8192, 4608)
};

vector<CvSize> getSupportedResolutions(VideoCapture camera)
{
  vector<CvSize> supportedVideoResolutions;
  int nbTests = sizeof(CommonResolutions) / sizeof(CommonResolutions[0]);

  for (int i = 0; i < nbTests; i++) {
    CvSize test = CommonResolutions[i];

    // try to set resolution
    camera.set(CV_CAP_PROP_FRAME_WIDTH, test.width);
    camera.set(CV_CAP_PROP_FRAME_HEIGHT, test.height);

    double width = camera.get(CV_CAP_PROP_FRAME_WIDTH);
    double height = camera.get(CV_CAP_PROP_FRAME_HEIGHT);

    if (test.width == width && test.height == height) {
      supportedVideoResolutions.push_back(test);
    }
  }

  return supportedVideoResolutions;
}

Probing solution based on width increment :

vector<CvSize> getSupportedResolutionsProbing(VideoCapture camera)
{
    vector<CvSize> supportedVideoResolutions;

    int step = 100;
    double minimumWidth = 16; // Microvision
    double maximumWidth = 1920 + step; // 1080

    CvSize currentSize = cvSize(minimumWidth, 1);
    CvSize previousSize = currentSize;

    while (1) {
        camera.set(CV_CAP_PROP_FRAME_WIDTH, currentSize.width);
        camera.set(CV_CAP_PROP_FRAME_HEIGHT, currentSize.height);

        CvSize cameraResolution = cvSize(
            camera.get(CV_CAP_PROP_FRAME_WIDTH),
            camera.get(CV_CAP_PROP_FRAME_HEIGHT));


        if (cameraResolution.width == previousSize.width 
                 && cameraResolution.height == previousSize.height)
        {
            supportedVideoResolutions.push_back(cameraResolution);
            currentSize = previousSize = cameraResolution;
        }
        currentSize.width += step;
        if (currentSize.width > maximumWidth)
        {
            break;
        }
    }

    return supportedVideoResolutions;
}

I hope this will be helpful for futur users.

score 2 · Accepted Answer

For Ubuntu: install

sudo apt install v4l-utils

And then, run:

v4l2-ctl -d /dev/video0 --list-formats-ext

score 1 · Accepted Answer

This kind of hardware capabilities can be queried from USB devices if the camera is UVC compliant. It depends on the driver / firmware of the device. See for example these Microsoft requirements to guess what kind of support you can expect on Windows platforms.

c++ - Query maximum webcam resolution in OpenCV

6 回答 6

Related

Reference