关于opencv更改摄像头参数（帧率，分辨率，曝光度……）的几个问题

1，适用于VideoCapture打开的摄像头

VideoCapture capture(0); 设置摄像头参数 不要随意修改

capture.set(CV_CAP_PROP_FRAME_WIDTH, 1080);//宽度

capture.set(CV_CAP_PROP_FRAME_HEIGHT, 960);//高度

capture.set(CV_CAP_PROP_FPS, 30);//帧率 帧/秒

capture.set(CV_CAP_PROP_BRIGHTNESS, 1);//亮度 

capture.set(CV_CAP_PROP_CONTRAST,40);//对比度 40

capture.set(CV_CAP_PROP_SATURATION, 50);//饱和度 50

capture.set(CV_CAP_PROP_HUE, 50);//色调 50

capture.set(CV_CAP_PROP_EXPOSURE, 50);//曝光 50 获取摄像头参数

得到摄像头的参数

capture.get(CV_CAP_PROP_FRAME_WIDTH);

capture.get(CV_CAP_PROP_FRAME_HEIGHT);

capture.get(CV_CAP_PROP_FPS);

capture.get(CV_CAP_PROP_BRIGHTNESS);

capture.get(CV_CAP_PROP_CONTRAST);

capture.get(CV_CAP_PROP_SATURATION);

capture.get(CV_CAP_PROP_HUE);

capture.get(CV_CAP_PROP_EXPOSURE); 获取视频参数：

capture.get(CV_CAP_PROP_FRAME_COUNT);//视频帧数 

然后你会发现除了个别参数你能更改之外（如曝光度），大分布你是不能更改的，甚至都没办法得到，这种并不适用

2，不做开发，只是单纯的更改

那么推荐一个软件，amcap，百度网盘链接，百度网盘-链接不存在，很简单很容易上手。

补，现在突然想起来我的一个学长告诉我的，利用这个软件调节摄像头的曝光度，可以改变帧率，且摄像头会记住曝光度的设置（其他特性就没有这个特点）。-2019.3.12

3，修改opencv的文件，不过效果可能和第一个差不多

大概是在opencv的这个位置，找一下，modules/highgui/src/cap_v4l.cpp，里面有关于参数的设置，位置比较靠前，可以搜索，也可以直接找到

大致在200多行

4，v4l2

下面是我找到的一篇参考，可以突破帧率的限制，当然前提是摄像头支持

Jetson TX1开发笔记(六)：V4L2+OpenCV3.1以MJPG格式读取USB摄像头图像并实时显示_Jack-Cui的博客-CSDN博客

目前只适用于Linux系统，本人试验过，120帧的摄像头在只打开摄像头时可以达到100帧左右，设置的图片分辨率越小，能达到的帧率越高

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #include

14. #include

15. #include

16. #include "opencv2/highgui/highgui.hpp"

17. #include "opencv2/imgproc/imgproc.hpp"

18. #include

19. #include

20. #include

21. #include

23. using namespace std;

24. using namespace cv;

25. #define CLEAR(x) memset(&(x), 0, sizeof(x))

27. #define IMAGEWIDTH 3264

28. #define IMAGEHEIGHT 2448

30. #define WINDOW_NAME1 "【原始图】" //为窗口标题定义的宏

31. #define WINDOW_NAME2 "【图像轮廓】" //为窗口标题定义的宏

33. Mat g_srcImage; Mat g_grayImage;

34. int g_nThresh = 90;

35. int g_nMaxThresh = 255;

36. RNG g_rng(12345);

37. Mat g_cannyMat_output;

38. vector > g_vContours;

39. vector g_vHierarchy;

40. Point point1[100000];

41. Point point2[100000];

42. Point point3[100000];

43. int ii,iii;

44. int flag2 = 0;//避障用

45. float number = 0;

46. int fps=0;

49. class V4L2Capture {

50. public:

51. V4L2Capture(char *devName, int width, int height);

52. virtual ~V4L2Capture();

54. int openDevice();

55. int closeDevice();

56. int initDevice();

57. int startCapture();

58. int stopCapture();

59. int freeBuffers();

60. int getFrame(void **,size_t *);

61. int backFrame();

62. static void test();

64. private:

65. int initBuffers();

67. struct cam_buffer

68. {

69. void* start;

70. unsigned int length;

71. };

72. char *devName;

73. int capW;

74. int capH;

75. int fd_cam;

76. cam_buffer *buffers;

77. unsigned int n_buffers;

78. int frameIndex;

79. };

81. V4L2Capture::V4L2Capture(char *devName, int width, int height) {

82. // TODO Auto-generated constructor stub

83. this->devName = devName;

84. this->fd_cam = -1;

85. this->buffers = NULL;

86. this->n_buffers = 0;

87. this->frameIndex = -1;

88. this->capW=width;

89. this->capH=height;

90. }

92. V4L2Capture::~V4L2Capture() {

93. // TODO Auto-generated destructor stub

94. }

96. int V4L2Capture::openDevice() {

97. /*设备的打开*/

98. printf("video dev : %s\n", devName);

99. fd_cam = open(devName, O_RDWR);

100. if (fd_cam < 0) {

101. perror("Can't open video device");

102. }

103. return 0;

104. }

106. int V4L2Capture::closeDevice() {

107. if (fd_cam > 0) {

108. int ret = 0;

109. if ((ret = close(fd_cam)) < 0) {

110. perror("Can't close video device");

111. }

112. return 0;

113. } else {

114. return -1;

115. }

116. }

118. int V4L2Capture::initDevice() {

119. int ret;

120. struct v4l2_capability cam_cap; //显示设备信息

121. struct v4l2_cropcap cam_cropcap; //设置摄像头的捕捉能力

122. struct v4l2_fmtdesc cam_fmtdesc; //查询所有支持的格式：VIDIOC_ENUM_FMT

123. struct v4l2_crop cam_crop; //图像的缩放

124. struct v4l2_format cam_format; //设置摄像头的视频制式、帧格式等

126. /* 使用IOCTL命令VIDIOC_QUERYCAP，获取摄像头的基本信息*/

127. ret = ioctl(fd_cam, VIDIOC_QUERYCAP, &cam_cap);

128. if (ret < 0) {

129. perror("Can't get device information: VIDIOCGCAP");

130. }

131. printf(

132. "Driver Name:%s\nCard Name:%s\nBus info:%s\nDriver Version:%u.%u.%u\n",

133. cam_cap.driver, cam_cap.card, cam_cap.bus_info,

134. (cam_cap.version >> 16) & 0XFF, (cam_cap.version >> 8) & 0XFF,

135. cam_cap.version & 0XFF);

137. /* 使用IOCTL命令VIDIOC_ENUM_FMT，获取摄像头所有支持的格式*/

138. cam_fmtdesc.index = 0;

139. cam_fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

140. printf("Support format:\n");

141. while (ioctl(fd_cam, VIDIOC_ENUM_FMT, &cam_fmtdesc) != -1) {

142. printf("\t%d.%s\n", cam_fmtdesc.index + 1, cam_fmtdesc.description);

143. cam_fmtdesc.index++;

144. }

146. /* 使用IOCTL命令VIDIOC_CROPCAP，获取摄像头的捕捉能力*/

147. cam_cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

148. if (0 == ioctl(fd_cam, VIDIOC_CROPCAP, &cam_cropcap)) {

149. printf("Default rec:\n\tleft:%d\n\ttop:%d\n\twidth:%d\n\theight:%d\n",

150. cam_cropcap.defrect.left, cam_cropcap.defrect.top,

151. cam_cropcap.defrect.width, cam_cropcap.defrect.height);

152. /* 使用IOCTL命令VIDIOC_S_CROP，获取摄像头的窗口取景参数*/

153. cam_crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

154. cam_crop.c = cam_cropcap.defrect; //默认取景窗口大小

155. if (-1 == ioctl(fd_cam, VIDIOC_S_CROP, &cam_crop)) {

156. //printf("Can't set crop para\n");

157. }

158. } else {

159. printf("Can't set cropcap para\n");

160. }

162. /* 使用IOCTL命令VIDIOC_S_FMT，设置摄像头帧信息*/

163. cam_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

164. cam_format.fmt.pix.width = capW;

165. cam_format.fmt.pix.height = capH;

166. cam_format.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; //要和摄像头支持的类型对应

167. cam_format.fmt.pix.field = V4L2_FIELD_INTERLACED;

168. ret = ioctl(fd_cam, VIDIOC_S_FMT, &cam_format);

169. if (ret < 0) {

170. perror("Can't set frame information");

171. }

172. /* 使用IOCTL命令VIDIOC_G_FMT，获取摄像头帧信息*/

173. cam_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

174. ret = ioctl(fd_cam, VIDIOC_G_FMT, &cam_format);

175. if (ret < 0) {

176. perror("Can't get frame information");

177. }

178. printf("Current data format information:\n\twidth:%d\n\theight:%d\n",

179. cam_format.fmt.pix.width, cam_format.fmt.pix.height);

180. ret = initBuffers();

181. if (ret < 0) {

182. perror("Buffers init error");

183. //exit(-1);

184. }

185. return 0;

186. }

188. int V4L2Capture::initBuffers() {

189. int ret;

190. /* 使用IOCTL命令VIDIOC_REQBUFS，申请帧缓冲*/

191. struct v4l2_requestbuffers req;

192. CLEAR(req);

193. req.count = 4;

194. req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

195. req.memory = V4L2_MEMORY_MMAP;

196. ret = ioctl(fd_cam, VIDIOC_REQBUFS, &req);

197. if (ret < 0) {

198. perror("Request frame buffers failed");

199. }

200. if (req.count < 2) {

201. perror("Request frame buffers while insufficient buffer memory");

202. }

203. buffers = (struct cam_buffer*) calloc(req.count, sizeof(*buffers));

204. if (!buffers) {

205. perror("Out of memory");

206. }

207. for (n_buffers = 0; n_buffers < req.count; n_buffers++) {

208. struct v4l2_buffer buf;

209. CLEAR(buf);

210. // 查询序号为n_buffers 的缓冲区，得到其起始物理地址和大小

211. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

212. buf.memory = V4L2_MEMORY_MMAP;

213. buf.index = n_buffers;

214. ret = ioctl(fd_cam, VIDIOC_QUERYBUF, &buf);

215. if (ret < 0) {

216. printf("VIDIOC_QUERYBUF %d failed\n", n_buffers);

217. return -1;

218. }

219. buffers[n_buffers].length = buf.length;

220. //printf("buf.length= %d\n",buf.length);

221. // 映射内存

222. buffers[n_buffers].start = mmap(

223. NULL, // start anywhere

224. buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd_cam,

225. buf.m.offset);

226. if (MAP_FAILED == buffers[n_buffers].start) {

227. printf("mmap buffer%d failed\n", n_buffers);

228. return -1;

229. }

230. }

231. return 0;

232. }

234. int V4L2Capture::startCapture() {

235. unsigned int i;

236. for (i = 0; i < n_buffers; i++) {

237. struct v4l2_buffer buf;

238. CLEAR(buf);

239. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

240. buf.memory = V4L2_MEMORY_MMAP;

241. buf.index = i;

242. if (-1 == ioctl(fd_cam, VIDIOC_QBUF, &buf)) {

243. printf("VIDIOC_QBUF buffer%d failed\n", i);

244. return -1;

245. }

246. }

247. enum v4l2_buf_type type;

248. type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

249. if (-1 == ioctl(fd_cam, VIDIOC_STREAMON, &type)) {

250. printf("VIDIOC_STREAMON error");

251. return -1;

252. }

253. return 0;

254. }

256. int V4L2Capture::stopCapture() {

257. enum v4l2_buf_type type;

258. type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

259. if (-1 == ioctl(fd_cam, VIDIOC_STREAMOFF, &type)) {

260. printf("VIDIOC_STREAMOFF error\n");

261. return -1;

262. }

263. return 0;

264. }/*ok*/

266. int V4L2Capture::freeBuffers() {

267. unsigned int i;

268. for (i = 0; i < n_buffers; ++i) {

269. if (-1 == munmap(buffers[i].start, buffers[i].length)) {

270. printf("munmap buffer%d failed\n", i);

271. return -1;

272. }

273. }

274. free(buffers);

275. return 0;

276. }

278. int V4L2Capture::getFrame(void **frame_buf, size_t* len) {

279. struct v4l2_buffer queue_buf;

280. CLEAR(queue_buf);

281. queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

282. queue_buf.memory = V4L2_MEMORY_MMAP;

283. if (-1 == ioctl(fd_cam, VIDIOC_DQBUF, &queue_buf)) {

284. printf("VIDIOC_DQBUF error\n");

285. return -1;

286. }

287. *frame_buf = buffers[queue_buf.index].start;

288. *len = buffers[queue_buf.index].length;

289. frameIndex = queue_buf.index;

290. return 0;

291. }

293. int V4L2Capture::backFrame() {

294. if (frameIndex != -1) {

295. struct v4l2_buffer queue_buf;

296. CLEAR(queue_buf);

297. queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

298. queue_buf.memory = V4L2_MEMORY_MMAP;

299. queue_buf.index = frameIndex;

300. if (-1 == ioctl(fd_cam, VIDIOC_QBUF, &queue_buf)) {

301. printf("VIDIOC_QBUF error\n");

302. return -1;

303. }

304. return 0;

305. }

306. return -1;

307. }

308. void V4L2Capture::test() {

309. unsigned char *yuv422frame = NULL;

310. unsigned long yuvframeSize = 0;

312. string videoDev="/dev/video0";

313. V4L2Capture *vcap = new V4L2Capture(const_cast(videoDev.c_str()),

314. 1920, 1080);

315. vcap->openDevice();

316. vcap->initDevice();

317. vcap->startCapture();

318. vcap->getFrame((void **) &yuv422frame, (size_t *)&yuvframeSize);

320. vcap->backFrame();

321. vcap->freeBuffers();

322. vcap->closeDevice();

323. }

324. void line2(Point point3[100000], int n)

325. {

326. float aa, bb, cc, dd, ee, ff, gg;

327. int jj = 0;

328. for (;jj

329. {

330. aa += point3[jj].x*point3[jj].x;

331. bb += point3[jj].x;

332. cc += point3[jj].x*point3[jj].y;

333. dd += point3[jj].y;

334. }

335. ee = aa*n - bb*bb;

336. if ((int)(ee* 100) != 0)

337. {

338. ff = (n*cc - bb*dd) / ee;

339. gg = (dd - bb*ff) / n;

340. }

341. else {

342. ff = 0;

343. gg = 1;

344. }

345. Point point0, pointn;

346. point0.y = 0;

347. point0.x = gg;

348. pointn.y = (n-1);

349. pointn.x = ((n-1) * ff + gg);

351. Mat draw_ing2 = Mat::zeros(g_cannyMat_output.size(), CV_8UC3);

352. line(draw_ing2, point0, pointn, (255, 255, 255));

353. imshow("10", draw_ing2);

354. //cout << "\n"<

355. float the =180*atan(ff)/3.14159;

356. float dis = ff * 160+gg - 160;

357. cout << the << " " << dis << endl;

358. //正中心ff=0，gg=160，逆时ff为正，顺时ff为负

359. }

360. void findcolor(cv::Mat &image)

361. {

362. cv::Mat_::iterator it = image.begin();

363. cv::Mat_::iterator itend = image.end();

364. ii = 0;

365. iii = 0;

366. int flagg = 0;

367. cv::Mat srcX(image.rows, image.cols , CV_32F);

368. cv::Mat srcY(image.rows, image.cols, CV_32F);

369. for (int i = 0;i < image.rows;i++)

370. {

371. for (int j = 0;j < image.cols;j++)

372. {

373. if (flagg == 0)/*这样遍历水平方向无法得到有效数据*/

374. {

376. if ((*it)[0] == 255 && (*it)[1] == 0 && (*it)[2] == 255)

377. {

378. flagg = 1;

379. point1[ii].x = i;

380. point1[ii].y = j;

381. ii++;

382. }

384. }

385. else

386. {

387. if ((*it)[0] == 255 && (*it)[1] == 0 && (*it)[2] == 255)

388. {

389. flagg = 0;

390. point2[iii].x = i;

391. point2[iii].y = j;

392. iii++;

393. }

394. }

395. if (it == itend)

396. break;

397. else it++;

398. }

399. }

400. IplImage pImg = IplImage(image);

401. CvArr* arr = (CvArr*)&pImg;

402. int nn = ii;

403. for (;ii > 0;ii--)

404. {

405. point3[ii].x = (point1[ii].x + point2[ii].x) / 2;

406. point3[ii].y = (point1[ii].y + point2[ii].y) / 2;

407. //circle(image, point3[ii], 1, (255, 255, 255));

408. cvSet2D(arr, point3[ii].x, point3[ii].y, Scalar(255, 255, 255));

409. }

410. line2(point3, nn);

411. }

413. void on_ThreshChange(int, void* )

414. {

415. // 使用Canndy检测边缘

416. Canny( g_grayImage, g_cannyMat_output, g_nThresh, g_nThresh*2, 3 );

418. // 找到轮廓

419. findContours( g_cannyMat_output, g_vContours, g_vHierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) );

421. // 计算矩

422. vector mu(g_vContours.size() );

423. for(unsigned int i = 0; i < g_vContours.size(); i++ )

424. { mu[i] = moments( g_vContours[i], false ); }

426. // 计算中心矩

427. vector mc( g_vContours.size() );

428. for( unsigned int i = 0; i < g_vContours.size(); i++ )

429. { mc[i] = Point2f( static_cast(mu[i].m10/mu[i].m00), static_cast(mu[i].m01/mu[i].m00 )); }

431. // 绘制轮廓

432. Mat drawing = Mat::zeros(g_cannyMat_output.size(), CV_8UC3);

433. for( unsigned int i = 0; i< g_vContours.size(); i++ )

434. {

435. //Scalar color = Scalar( g_rng.uniform(0, 255), g_rng.uniform(0,255), g_rng.uniform(0,255) );//随机生成颜色值

436. Scalar color = Scalar(255, 0, 255);

437. drawContours( drawing, g_vContours, i, color, 2, 8, g_vHierarchy, 0, Point() );//绘制外层和内层轮廓

438. circle( drawing, mc[i], 4, color, -1, 8, 0 );;//绘制圆

439. }

441. findcolor(drawing);

442. //line1(point1,point2,ii,iii);

444. // 显示到窗口中

445. // namedWindow( WINDOW_NAME2, WINDOW_AUTOSIZE );

446. imshow( WINDOW_NAME2, drawing );

448. }

450. void findline(Mat image)

451. {

452. cv::Mat_::iterator it = image.begin();

453. cv::Mat_::iterator itend = image.end();

454. for (;it != itend;it++)

455. {

456. if ((*it)[1] == 0 && (*it)[2] >= 100)//条件可能需要改变

457. {

458. if(flag2==0)

459. {

460. flag2 = 1;

461. cout << "注意line1，避障"<

462. //向主控发送消息

463. }

464. else

465. {

466. cout << "注意line2，避障" << endl;

467. //向主控发送消息

468. //避障一与避障二中间要隔一段时间

469. }

471. }

472. }

473. }

474. void wave(const cv::Mat &image, cv::Mat &result)

475. {

476. cv::Mat srcX(image.rows / 2, image.cols / 2, CV_32F);

477. cv::Mat srcY(image.rows / 2, image.cols / 2, CV_32F);

478. for (int i = 0;i

479. for (int j = 0;j < image.cols /2;j++)

480. {

481. srcX.at(i, j) = 2 * j;

482. srcY.at(i, j) = 2 * i;

483. }

484. cv::remap(image, result, srcX, srcY, cv::INTER_LINEAR);

485. }

487. void VideoPlayer() {

488. unsigned char *yuv422frame = NULL;

489. unsigned long yuvframeSize = 0;

491. string videoDev = "/dev/video0";

492. V4L2Capture *vcap = new V4L2Capture(const_cast(videoDev.c_str()), 640, 480);

493. vcap->openDevice();

494. vcap->initDevice();

495. vcap->startCapture();

497. cvNamedWindow("Capture",CV_WINDOW_AUTOSIZE);

498. IplImage* img;

499. CvMat cvmat;

500. double t;

501. clock_t start, end;

502. double number=0;

503. int fps=0;

504. while(1){

505. start=clock();

506. t = (double)cvGetTickCount();

507. vcap->getFrame((void **) &yuv422frame, (size_t *)&yuvframeSize);

508. cvmat = cvMat(IMAGEHEIGHT,IMAGEWIDTH,CV_8UC3,(void*)yuv422frame); //CV_8UC3

509. //解码

510. img = cvDecodeImage(&cvmat,1);

511. if(!img){

512. printf("DecodeImage error!\n");

513. }

515. cv::Mat g_srcImage = cv::cvarrToMat(img,true);

517. cvShowImage("Capture",img);

518. cvReleaseImage(&img);

519. vcap->backFrame();

520. if((cvWaitKey(1)&255) == 27){

521. exit(0);

522. }

526. wave(g_srcImage, g_srcImage);

527. findline(g_srcImage);

529. // 把原图像转化成灰度图像并进行平滑

530. cvtColor(g_srcImage, g_grayImage, COLOR_BGR2GRAY);

531. blur(g_grayImage, g_grayImage, Size(3, 3));

534. //创建滚动条并进行初始化

535. createTrackbar(" 阈值", WINDOW_NAME1, &g_nThresh, g_nMaxThresh, on_ThreshChange);

536. on_ThreshChange(0, 0);

537. t = (double)cvGetTickCount() - t;

538. printf("Used time is %g ms\n", (t / (cvGetTickFrequency() * 1000)));

540. end =clock();

541. number=number+end-start;

542. fps++;

543. if (number/ CLOCKS_PER_SEC>= 0.25)//windows10 for CLK_TCK

544. {

545. cout<

546. fps = 0;

547. number = 0;

548. }

549. }

550. vcap->stopCapture();

551. vcap->freeBuffers();

552. vcap->closeDevice();

554. }

556. int main() {

557. VideoPlayer();

559. return 0;

560. }