API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 22nd, 2018
77
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.20 KB | None | 0 0
raw download clone embed print report
  1. // OpenCVApplication.cpp : Defines the entry point for the console application.
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include "common.h"
  6. #include <queue>
  7. using namespace std;
  8.  
  9. void testOpenImage()
  10. {
  11. char fname[MAX_PATH];
  12. while (openFileDlg(fname))
  13. {
  14. Mat src;
  15. src = imread(fname);
  16. imshow("image", src);
  17. waitKey();
  18. }
  19. }
  20.  
  21.  
  22. void negative_grayscale()
  23. {
  24. char fname[MAX_PATH];
  25. while (openFileDlg(fname))
  26. {
  27. Mat src, dst;
  28. int i, j;
  29. src = imread(fname, 0);
  30. dst = src.clone();
  31. for (i = 0; i < src.rows; i++)
  32. for (j = 0; j < src.cols; j++)
  33. dst.at<uchar>(i, j) = 255 - src.at<uchar>(i, j);
  34. imshow("image", dst);
  35. waitKey();
  36. }
  37. }
  38.  
  39.  
  40. void negative_color()
  41. {
  42. char fname[MAX_PATH];
  43. while (openFileDlg(fname))
  44. {
  45. Mat src, dst;
  46. int i, j;
  47. src = imread(fname);
  48. dst = src.clone();
  49. Vec3b p, p1;
  50. for (i = 0; i < src.rows; i++)
  51. for (j = 0; j < src.cols; j++)
  52. {
  53. p = src.at<Vec3b>(i, j);
  54. p1[0] = 255 - p[0];
  55. p1[1] = 255 - p[1];
  56. p1[2] = 255 - p[2];
  57. dst.at<Vec3b>(i, j) = p1;
  58. }
  59. imshow("image", dst);
  60. waitKey();
  61. }
  62. }
  63.  
  64.  
  65. void cr_mat()
  66. {
  67.  
  68. Mat dst(256, 256, CV_8UC3);
  69. int i, j;
  70. Vec3b p, p1;
  71.  
  72. i = 0;
  73. j = 0;
  74. p[0] = 255;
  75. p[1] = 255;
  76. p[2] = 255;
  77. while (i < 128)
  78. {
  79. j = 0;
  80. while (j < 128)
  81. {
  82. dst.at < Vec3b >(i, j) = p;
  83. j++;
  84. }
  85. i++;
  86. }
  87.  
  88. i = 0;
  89. j = 128;
  90. p[0] = 0;
  91. p[1] = 0;
  92. p[2] = 255;
  93. while (i < 128)
  94. {
  95. j = 128;
  96. while (j < 256)
  97. {
  98. dst.at < Vec3b >(i, j) = p;
  99. j++;
  100. }
  101. i++;
  102. }
  103.  
  104. j = 0;
  105. i = 128;
  106. p[0] = 0;
  107. p[1] = 255;
  108. p[2] = 0;
  109. while (i < 256)
  110. {
  111. j = 0;
  112. while (j < 128)
  113. {
  114. dst.at < Vec3b >(i, j) = p;
  115. j++;
  116. }
  117. i++;
  118. }
  119.  
  120. i = 128;
  121. j = 128;
  122. p[0] = 0;
  123. p[1] = 255;
  124. p[2] = 255;
  125. while (i < 256)
  126. {
  127. j = 128;
  128. while (j < 256)
  129. {
  130. dst.at < Vec3b >(i, j) = p;
  131. j++;
  132. }
  133. i++;
  134. }
  135.  
  136. imshow("image", dst);
  137. waitKey();
  138. }
  139.  
  140. int saturate(int x)
  141. {
  142. if (x > 255)
  143. return 255;
  144. if (x < 0)
  145. return 0;
  146. return x;
  147. }
  148.  
  149. void add50_grayscale()
  150. {
  151. char fname[MAX_PATH];
  152. while (openFileDlg(fname))
  153. {
  154. Mat src, dst;
  155. int i, j;
  156. src = imread(fname, 0);
  157. dst = src.clone();
  158. for (i = 0; i < src.rows; i++)
  159. for (j = 0; j < src.cols; j++)
  160. {
  161. uchar c = src.at<uchar>(i, j);
  162. int c1 = c + 50;
  163. dst.at<uchar>(i, j) = saturate(c1);
  164. }
  165. imshow("image", dst);
  166. waitKey();
  167. }
  168. }
  169.  
  170.  
  171. void add50_color()
  172. {
  173. char fname[MAX_PATH];
  174. while (openFileDlg(fname))
  175. {
  176. Mat src, dst;
  177. int i, j, x;
  178. src = imread(fname);
  179. dst = src.clone();
  180. Vec3b p, p1;
  181. for (i = 0; i < src.rows; i++)
  182. for (j = 0; j < src.cols; j++)
  183. {
  184. p = src.at<Vec3b>(i, j);
  185. x = p[0] + 50;
  186. p1[0] = saturate(x);
  187. x = p[1] + 50;
  188. p1[1] = saturate(x);
  189. x = p[2] + 50;
  190. p1[2] = saturate(x);
  191. dst.at<Vec3b>(i, j) = p1;
  192. }
  193. imshow("image", dst);
  194. waitKey();
  195. }
  196. }
  197.  
  198.  
  199. void enlight_grayscale()
  200. {
  201. char fname[MAX_PATH];
  202. while (openFileDlg(fname))
  203. {
  204. Mat src, dst;
  205. int ic, jc, i, j;
  206. double dmax, d;
  207. src = imread(fname, 0);
  208. ic = src.rows / 2;
  209. jc = src.cols / 2;
  210. dmax = sqrt((src.rows / 2)*(src.rows / 2) + (src.cols / 2) *(src.cols / 2));
  211. dst = src.clone();
  212. uchar p = 255;
  213. for (i = 0; i < src.rows; i++)
  214. for (j = 0; j < src.cols; j++)
  215. {
  216. d = sqrt(((i - ic) / 2)*((i - ic) / 2) + ((j - jc) / 2) *((j - jc) / 2));
  217. int c = src.at<uchar>(i, j) + (d * p) / dmax;
  218. dst.at<uchar>(i, j) = saturate(c);
  219. }
  220. imshow("image", dst);
  221. waitKey();
  222. }
  223. }
  224.  
  225.  
  226. void enlight_color()
  227. {
  228. char fname[MAX_PATH];
  229. while (openFileDlg(fname))
  230. {
  231. Mat src, dst;
  232. int ic, jc, i, j;
  233. double dmax, d;
  234. src = imread(fname);
  235. ic = src.rows / 2;
  236. jc = src.cols / 2;
  237. dmax = sqrt((src.rows / 2)*(src.rows / 2) + (src.cols / 2) *(src.cols / 2));
  238. dst = src.clone();
  239. uchar p = 255;
  240. for (i = 0; i < src.rows; i++)
  241. for (j = 0; j < src.cols; j++)
  242. {
  243. d = sqrt(((i - ic) / 2)*((i - ic) / 2) + ((j - jc) / 2) *((j - jc) / 2));
  244. Vec3b c = src.at<Vec3b>(i, j);
  245. int t = c[0];
  246. t = t + (d * p) / dmax;
  247. t = saturate(t);
  248. c[0] = t;
  249. t = c[1];
  250. t = t + (d * p) / dmax;
  251. t = saturate(t);
  252. c[1] = t;
  253. t = c[2];
  254. t = t + (d * p) / dmax;
  255. t = saturate(t);
  256. c[2] = t;
  257. dst.at<Vec3b>(i, j) = c;
  258. }
  259. imshow("image", dst);
  260. waitKey();
  261. }
  262. }
  263.  
  264. void zoom()
  265. {
  266. char fname[MAX_PATH];
  267. while (openFileDlg(fname))
  268. {
  269. double f = 0.0;
  270. printf("Scale factor=");
  271. scanf("%lf", &f);
  272. Mat src;
  273. int i, j;
  274. src = imread(fname);
  275. int x = src.rows, y = src.cols;
  276. x = x * f;
  277. y = y * f;
  278. Mat dst(x, y, CV_8UC3);
  279.  
  280. for (i = 0; i < dst.rows; i++)
  281. for (j = 0; j < dst.cols; j++)
  282. {
  283. x = i / f;
  284. y = j / f;
  285. dst.at<Vec3b>(i, j) = src.at<Vec3b>(x, y);
  286. }
  287. imshow("image", dst);
  288. waitKey();
  289. }
  290. }
  291.  
  292. void rgb_mat()
  293. {
  294. char fname[MAX_PATH];
  295. while (openFileDlg(fname))
  296. {
  297. Mat src;
  298. src = imread(fname);
  299. Mat r(256, 256, CV_8UC1);
  300. Mat g(256, 256, CV_8UC1);
  301. Mat b(256, 256, CV_8UC1);
  302. int i, j;
  303. Vec3b p;
  304. for (i = 0; i < 255; i++)
  305. for (j = 0; j < 255; j++)
  306. {
  307. p = src.at<Vec3b>(i, j);
  308. b.at<uchar>(i, j) = p[0];
  309. g.at<uchar>(i, j) = p[1];
  310. r.at<uchar>(i, j) = p[2];
  311. }
  312. imshow("Original", src);
  313. imshow("Red", r);
  314. imshow("Green", g);
  315. imshow("Blue", b);
  316. waitKey();
  317. }
  318. }
  319.  
  320. void rgb_mats()
  321. {
  322.  
  323. char fname[MAX_PATH];
  324. while (openFileDlg(fname))
  325. {
  326. Mat src;
  327. src = imread(fname);
  328. Mat r(256, 256, CV_8UC3);
  329. Mat g(256, 256, CV_8UC3);
  330. Mat b(256, 256, CV_8UC3);
  331. int i, j;
  332. Vec3b p, p1;
  333. for (i = 0; i < 255; i++)
  334. for (j = 0; j < 255; j++)
  335. {
  336. p = src.at<Vec3b>(i, j);
  337. p1[0] = p[0];
  338. b.at<Vec3b>(i, j) = p1;
  339. p1[0] = 0;
  340. p1[1] = p[1];
  341. g.at<Vec3b>(i, j) = p1;
  342. p1[1] = 0;
  343. p1[2] = p[2];
  344. r.at<Vec3b>(i, j) = p1;
  345. p1[2] = 0;
  346. }
  347. imshow("Original", src);
  348. imshow("Red", r);
  349. imshow("Green", g);
  350. imshow("Blue", b);
  351. waitKey();
  352. }
  353. }
  354.  
  355. void color_To_GrayScale(){
  356. char fname[MAX_PATH];
  357. while (openFileDlg(fname))
  358. {
  359. Mat src;
  360. src = imread(fname, CV_LOAD_IMAGE_COLOR);
  361. Mat img(src.rows, src.cols, CV_8UC1);
  362.  
  363. for (int i = 0; i < src.rows; i++)
  364. for (int j = 0; j < src.cols; j++){
  365. Vec3b pixel = src.at<Vec3b>(i, j);
  366. img.at<uchar>(i, j) = (pixel[0] + pixel[1] + pixel[2]) / 3;
  367. }
  368.  
  369.  
  370. imshow("CopyRGBchannels", src);
  371. imshow("Gri", img);
  372. waitKey();
  373. }
  374. }
  375.  
  376. void grayToBW(){
  377. char fname[MAX_PATH];
  378. while (openFileDlg(fname))
  379. {
  380. Mat src;
  381. src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  382. Mat img(src.rows, src.cols, CV_8UC1);
  383.  
  384. for (int i = 0; i < src.rows; i++)
  385. for (int j = 0; j < src.cols; j++){
  386. if (src.at<uchar>(i, j) <= 128) img.at<uchar>(i, j) = 0;
  387. else img.at<uchar>(i, j) = 255;
  388. }
  389.  
  390.  
  391. imshow("CopyRGBchannels", src);
  392. imshow("Binary", img);
  393. waitKey();
  394. }
  395. }
  396.  
  397. void compute_HSV(){
  398.  
  399. char fname[MAX_PATH];
  400. while (openFileDlg(fname)){
  401. Mat src;
  402. src = imread(fname);
  403. int rows = src.rows;
  404. int cols = src.cols;
  405. float H_norm, V_norm, S_norm;
  406. Mat imgDestH(rows, cols, CV_8UC1);
  407. Mat imgDestS(rows, cols, CV_8UC1);
  408. Mat imgDestV(rows, cols, CV_8UC1);
  409.  
  410.  
  411. float r, g, b;
  412. float M, m, C, V, S, H;
  413.  
  414. for (int i = 0; i < src.rows; i++)
  415. for (int j = 0; j < src.cols; j++)
  416. {
  417. r = (float)src.at<Vec3b>(i, j)[2] / 255.0f;
  418. g = (float)src.at<Vec3b>(i, j)[1] / 255.0f;
  419. b = (float)src.at<Vec3b>(i, j)[0] / 255.0f;
  420.  
  421.  
  422. M = max(max(r, g), b);
  423. m = min(min(r, g), b);
  424. C = M - m;
  425. V = M;
  426.  
  427. if (C)
  428. S = C / V;
  429. else
  430. S = 0;
  431.  
  432. if (C){
  433. if (M == r) H = 60 * (g - b) / C;
  434. if (M == g) H = 120 + 60 * (b - r) / C;
  435. if (M == b) H = 240 + 60 * (r - g) / C;
  436. }
  437. else{
  438. H = 0;
  439. }
  440.  
  441. if (H < 0)
  442. H += 360;
  443.  
  444. H_norm = H * 255 / 360;
  445. S_norm = S * 255;
  446. V_norm = V * 255;
  447.  
  448. imgDestH.at<uchar>(i, j) = H_norm;
  449. imgDestS.at<uchar>(i, j) = S_norm;
  450. imgDestV.at<uchar>(i, j) = V_norm;
  451. }
  452.  
  453. imshow("RGB_HSV", src);
  454. imshow("imgDestH", imgDestH);
  455. imshow("imgDestS", imgDestS);
  456. imshow("imgDestV", imgDestV);
  457. waitKey();
  458.  
  459. }
  460.  
  461. }
  462.  
  463. void testOpenImagesFld()
  464. {
  465. char folderName[MAX_PATH];
  466. if (openFolderDlg(folderName) == 0)
  467. return;
  468. char fname[MAX_PATH];
  469. FileGetter fg(folderName, "bmp");
  470. while (fg.getNextAbsFile(fname))
  471. {
  472. Mat src;
  473. src = imread(fname);
  474. imshow(fg.getFoundFileName(), src);
  475. if (waitKey() == 27) //ESC pressed
  476. break;
  477. }
  478. }
  479.  
  480.  
  481. void testResize()
  482. {
  483. char fname[MAX_PATH];
  484. while (openFileDlg(fname))
  485. {
  486. Mat src;
  487. src = imread(fname);
  488. Mat dst1, dst2;
  489. //without interpolation
  490. resizeImg(src, dst1, 320, false);
  491. //with interpolation
  492. resizeImg(src, dst2, 320, true);
  493. imshow("input image", src);
  494. imshow("resized image (without interpolation)", dst1);
  495. imshow("resized image (with interpolation)", dst2);
  496. waitKey();
  497. }
  498. }
  499.  
  500.  
  501. void testVideoSequence()
  502. {
  503. VideoCapture cap("Videos/rubic.avi"); // off-line video from file
  504. //VideoCapture cap(0); // live video from web cam
  505. if (!cap.isOpened()) {
  506. printf("Cannot open video capture device.\n");
  507. waitKey(0);
  508. return;
  509. }
  510.  
  511. Mat edges;
  512. Mat frame;
  513. char c;
  514.  
  515. while (cap.read(frame))
  516. {
  517. Mat grayFrame;
  518. cvtColor(frame, grayFrame, CV_BGR2GRAY);
  519. imshow("source", frame);
  520. imshow("gray", grayFrame);
  521. c = cvWaitKey(0); // waits a key press to advance to the next frame
  522. if (c == 27) {
  523. // press ESC to exit
  524. printf("ESC pressed - capture finished\n");
  525. break; //ESC pressed
  526. };
  527. }
  528. }
  529.  
  530.  
  531. void testSnap()
  532. {
  533. VideoCapture cap(0); // open the deafult camera (i.e. the built in web cam)
  534. if (!cap.isOpened()) // openenig the video device failed
  535. {
  536. printf("Cannot open video capture device.\n");
  537. return;
  538. }
  539.  
  540. Mat frame;
  541. char numberStr[256];
  542. char fileName[256];
  543.  
  544. // video resolution
  545. Size capS = Size((int)cap.get(CV_CAP_PROP_FRAME_WIDTH),
  546. (int)cap.get(CV_CAP_PROP_FRAME_HEIGHT));
  547.  
  548. // Display window
  549. const char* WIN_SRC = "Src"; //window for the source frame
  550. namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  551. cvMoveWindow(WIN_SRC, 0, 0);
  552.  
  553. const char* WIN_DST = "Snapped"; //window for showing the snapped frame
  554. namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  555. cvMoveWindow(WIN_DST, capS.width + 10, 0);
  556.  
  557. char c;
  558. int frameNum = -1;
  559. int frameCount = 0;
  560.  
  561. for (;;)
  562. {
  563. cap >> frame; // get a new frame from camera
  564. if (frame.empty())
  565. {
  566. printf("End of the video file\n");
  567. break;
  568. }
  569.  
  570. ++frameNum;
  571.  
  572. imshow(WIN_SRC, frame);
  573.  
  574. c = cvWaitKey(10); // waits a key press to advance to the next frame
  575. if (c == 27) {
  576. // press ESC to exit
  577. printf("ESC pressed - capture finished");
  578. break; //ESC pressed
  579. }
  580. if (c == 115){ //'s' pressed - snapp the image to a file
  581. frameCount++;
  582. fileName[0] = NULL;
  583. sprintf(numberStr, "%d", frameCount);
  584. strcat(fileName, "Images/A");
  585. strcat(fileName, numberStr);
  586. strcat(fileName, ".bmp");
  587. bool bSuccess = imwrite(fileName, frame);
  588. if (!bSuccess)
  589. {
  590. printf("Error writing the snapped image\n");
  591. }
  592. else
  593. imshow(WIN_DST, frame);
  594. }
  595. }
  596.  
  597. }
  598.  
  599. void MyCallBackFunc(int event, int x, int y, int flags, void* param)
  600. {
  601. //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  602. Mat* src = (Mat*)param;
  603. if (event == EVENT_LBUTTONDOWN)
  604. {
  605. printf("Pos(x,y): %d,%d Color(RGB): %d,%d,%d\n",
  606. x, y,
  607. (int)(*src).at<Vec3b>(y, x)[2],
  608. (int)(*src).at<Vec3b>(y, x)[1],
  609. (int)(*src).at<Vec3b>(y, x)[0]);
  610. }
  611. }
  612.  
  613. void compute_HSV2(void *param, int *vect){
  614.  
  615. Mat* src;
  616. src = (Mat*)param;
  617. int rows = src->rows;
  618. int cols = src->cols;
  619. float H_norm, V_norm, S_norm;
  620. float H_norm1, V_norm1, S_norm1;
  621. Mat imgDestH(rows, cols, CV_8UC1);
  622. Mat imgDestS(rows, cols, CV_8UC1);
  623. Mat imgDestV(rows, cols, CV_8UC1);
  624.  
  625. float r1, g1, b1;
  626. float M1, m1, C1, V1, S1, H1;
  627.  
  628. //calcul pentru pct ales
  629. r1 = (float)*(vect + 2) / 255.0f;
  630. g1 = (float)*(vect + 3) / 255.0f;
  631. b1 = (float)*(vect + 4) / 255.0f;
  632.  
  633. M1 = max(max(r1, g1), b1);
  634. m1 = min(min(r1, g1), b1);
  635. C1 = M1 - m1;
  636. V1 = M1;
  637.  
  638. if (C1)
  639. S1 = C1 / V1;
  640. else
  641. S1 = 0;
  642.  
  643. if (C1){
  644. if (M1 == r1) H1 = 60 * (g1 - b1) / C1;
  645. if (M1 == g1) H1 = 120 + 60 * (b1 - r1) / C1;
  646. if (M1 == b1) H1 = 240 + 60 * (r1 - g1) / C1;
  647. }
  648. else{
  649. H1 = 0;
  650. }
  651.  
  652. if (H1 < 0)
  653. H1 += 360;
  654.  
  655. H_norm1 = H1 * 255 / 360;
  656. S_norm1 = S1 * 255;
  657. V_norm1 = V1 * 255;
  658.  
  659.  
  660. //calcul pt punct ales
  661.  
  662.  
  663. float r, g, b;
  664. float M, m, C, V, S, H;
  665.  
  666. for (int i = 0; i < src->rows; i++)
  667. for (int j = 0; j < src->cols; j++)
  668. {
  669. r = (float)(*src).at<Vec3b>(i, j)[2] / 255.0f;
  670. g = (float)(*src).at<Vec3b>(i, j)[1] / 255.0f;
  671. b = (float)(*src).at<Vec3b>(i, j)[0] / 255.0f;
  672.  
  673.  
  674. M = max(max(r, g), b);
  675. m = min(min(r, g), b);
  676. C = M - m;
  677. V = M;
  678.  
  679. if (C)
  680. S = C / V;
  681. else
  682. S = 0;
  683.  
  684. if (C){
  685. if (M == r) H = 60 * (g - b) / C;
  686. if (M == g) H = 120 + 60 * (b - r) / C;
  687. if (M == b) H = 240 + 60 * (r - g) / C;
  688. }
  689. else{
  690. H = 0;
  691. }
  692.  
  693. if (H < 0)
  694. H += 360;
  695.  
  696. H_norm = H * 255 / 360;
  697. S_norm = S * 255;
  698. V_norm = V * 255;
  699.  
  700. int d1 = H_norm - H_norm1;
  701. if (d1 < 0){
  702. d1 = d1 + 256;
  703. }
  704. int d2 = H_norm1 - H_norm;
  705. if (d2 < 0){
  706. d2 = d2 + 256;
  707. }
  708. int ceva = min(d1, d2);
  709. if (ceva < 10 && S_norm>30){
  710. imgDestH.at<uchar>(i, j) = 0;
  711. imgDestS.at<uchar>(i, j) = S_norm;
  712. imgDestV.at<uchar>(i, j) = V_norm;
  713. }
  714. else{
  715. imgDestH.at<uchar>(i, j) = 255;
  716. }
  717. //imgDestS.at<uchar>(i, j) = S_norm;
  718. //imgDestV.at<uchar>(i, j) = V_norm;
  719. }
  720.  
  721. //imshow("RGB_HSV", *src);
  722. imshow("imgDestH", imgDestH);
  723. //imshow("imgDestS", imgDestS);
  724. //imshow("imgDestV", imgDestV);
  725. waitKey();
  726. }
  727.  
  728. void MyCallBackFunc2(int event, int x, int y, int flags, void* param)
  729. {
  730. //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  731. int *p;
  732. p = (int *)malloc(5 * sizeof(int*));
  733. Mat* src = (Mat*)param;
  734. if (event == EVENT_LBUTTONDOWN)
  735. {
  736. printf("Pos(x,y): %d,%d Color(RGB): %d,%d,%d\n",
  737. x, y,
  738. (int)(*src).at<Vec3b>(y, x)[2],
  739. (int)(*src).at<Vec3b>(y, x)[1],
  740. (int)(*src).at<Vec3b>(y, x)[0]);
  741. *p = x;
  742. *(p + 1) = y;
  743. *(p + 2) = (int)(*src).at<Vec3b>(y, x)[2];
  744. *(p + 3) = (int)(*src).at<Vec3b>(y, x)[1];
  745. *(p + 4) = (int)(*src).at<Vec3b>(y, x)[0];
  746. compute_HSV2(src, p);
  747. }
  748.  
  749. }
  750.  
  751. void testMouseClick()
  752. {
  753. Mat src;
  754. // Read image from file
  755. char fname[MAX_PATH];
  756. while (openFileDlg(fname))
  757. {
  758. src = imread(fname);
  759. //Create a window
  760. namedWindow("My Window", 1);
  761.  
  762. //set the callback function for any mouse event
  763. setMouseCallback("My Window", MyCallBackFunc2, &src);
  764.  
  765. //show the image
  766. imshow("My Window", src);
  767.  
  768. // Wait until user press some key
  769. waitKey(0);
  770. }
  771. }
  772.  
  773. void AreaCallBack(int event, int x, int y, int flags, void* param)
  774. {
  775. Mat* src = (Mat*)param;
  776. Mat src1 = *src;
  777. Mat dest((int)(*src).rows, (int)(*src).cols, CV_8UC3);
  778. Vec3b label = 0;
  779. double rSum = 0;
  780. double cSum = 0;
  781. double s1=0, s2=0, s3=0;
  782. Vec3b white;
  783. Vec3b negru;
  784. int perimetru = 0;
  785. Vec3b label1;
  786. white[0] = 255;
  787. white[1] = 255;
  788. white[2] = 255;
  789. negru[0] = 0;
  790. negru[1] = 0;
  791. negru[2] = 0;
  792. if (event == CV_EVENT_LBUTTONDOWN)
  793. {
  794.  
  795. label = src1.at<Vec3b>(y, x);
  796. int area = 0;
  797. for (int i = 0; i < src1.rows; i++){
  798. for (int j = 0; j < src1.cols; j++){
  799. if (src1.at<Vec3b>(i, j) == label)
  800. area++;
  801. }
  802. }
  803. printf("Area is %d \n", area);
  804.  
  805.  
  806. for (int i = 0; i < src1.rows; i++) {
  807. for (int j = 0; j < src1.cols; j++) {
  808. if (src1.at<Vec3b>(i, j) == label){
  809. rSum += i;
  810. cSum += j;
  811. }
  812. }
  813. }
  814.  
  815. double r = rSum / (double)area;
  816. double c = cSum / (double)area;
  817. printf("Weight center is %f %f \n", r, c);
  818. for (int i = r - 10; i < r+10; i++)
  819. dest.at<Vec3b>(i, c) = negru;
  820. for (int j = c - 10; j < c+10; j++)
  821. dest.at<Vec3b>(r, j) = negru;
  822.  
  823. for (int i = 0; i < (*src).rows; i++) {
  824. for (int j = 0; j < (*src).cols; j++) {
  825. label1 = (*src).at<Vec3b>(i, j);
  826. if (label1 == label){
  827.  
  828. if (label1 != (*src).at<Vec3b>(i + 1, j) ||
  829. label1 != (*src).at<Vec3b>(i - 1, j) ||
  830. label1 != (*src).at<Vec3b>(i, j + 1) ||
  831. label1 != (*src).at<Vec3b>(i, j - 1)){
  832. dest.at<Vec3b>(i, j) = label1;
  833. }
  834. else{
  835. dest.at<Vec3b>(i, j) = white;
  836. }
  837. }
  838. else{
  839. dest.at<Vec3b>(i, j) = white;
  840. }
  841. }
  842. }
  843. imshow("Destination",dest);
  844.  
  845.  
  846. for (int i = 0; i < (*src).rows; i++) {
  847. for (int j = 0; j < (*src).cols; j++) {
  848. Vec3b current = (*src).at<Vec3b>(i, j);
  849. if (current == label && ((*src).at<Vec3b>(i + 1, j) !=label || (*src).at<Vec3b>(i - 1, j) != label ||
  850. (*src).at<Vec3b>(i, j - 1) != label || (*src).at<Vec3b>(i, j + 1) != label)) {
  851. perimetru++;
  852. }
  853. }
  854. }
  855. printf("Perimetrul este %d \n", perimetru);
  856.  
  857. double fact = 4 * 3.14*area / (perimetru*perimetru);
  858. printf("Factorul de subtiere este %f \n",fact);
  859.  
  860. for (int i = 0; i < (*src).rows; i++) {
  861. for (int j = 0; j < (*src).cols; j++) {
  862. Vec3b current = (*src).at<Vec3b>(i, j);
  863. if (label == current){
  864. s1 += (i - r)*(j - c);
  865. s2 += (j - c)*(j - c);
  866. s3 += (i - r)*(i - r);
  867. }
  868. }
  869. }
  870. s1 = 2 * s1;
  871. s2 = s2 - s3;
  872. double tang = atan2(s1,s2);
  873. tang = tang / 2;
  874. printf("Teta angle %f \n",tang);
  875.  
  876.  
  877. /////////////////////////////
  878.  
  879. line(dest, Point(c - 40 * cos(tang), r - 40 * sin(tang)), Point(c + 40 * cos(tang), r + 40 * sin(tang)),255,1);
  880.  
  881. imshow("Destination", dest);
  882.  
  883. ////////////////////////////////
  884.  
  885. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  886.  
  887. Mat img4 = (*src).clone();
  888.  
  889. for (int i = 0; i < (*src).rows; i++) {
  890. int h = 0;
  891.  
  892. for (int j = 0; j < (*src).cols; j++) {
  893. if ((*src).at<Vec3b>(i, j) == label)
  894. h++;
  895. }
  896.  
  897. for (int k = 0; k < h; k++) {
  898. img4.at<Vec3b>(i, k) = 128;
  899. }
  900.  
  901. }
  902.  
  903. for (int j = 0; j < (*src).cols; j++) {
  904. int v = 0;
  905.  
  906. for (int i = 0; i < (*src).rows; i++) {
  907. if ((*src).at<Vec3b>(i, j) == label)
  908. v++;
  909. }
  910.  
  911. for (int k = 0; k < v; k++) {
  912. img4.at<Vec3b>(k, j) = 128;
  913. }
  914.  
  915. }
  916. imshow("Proiectie", img4);
  917.  
  918.  
  919. }
  920.  
  921. }
  922.  
  923. void effective_label(int event, int x, int y, int flags, void* param){
  924. Mat* src = (Mat*)param;
  925. Mat src1 = *src;
  926. int label = 0;
  927. Mat labels = Mat::zeros(src1.size(), CV_8UC1);
  928. int di[9] = { -1, -1, -1, 0, 0, 1, 1, 1 };
  929. int dj[9] = { -1, 0, 1, -1, -1, -1, 0, 1 };
  930. uchar neighbors[8];
  931. for (int i = 1; i < labels.rows-1; i++){
  932. for (int j = 1; j < labels.cols-1; j++){
  933. if (src1.at<uchar>(i, j) == 0 && labels.at<uchar>(i, j) == 0){
  934. label++;
  935. labels.at<uchar>(i, j) = label;
  936. std::queue<Point2i> queue;
  937. queue.push({ j, i });
  938. while (!queue.empty()){
  939. Point2i q = queue.front();
  940. queue.pop();
  941. int dummy1 = q.x;
  942. int dummy2 = q.y;
  943. for (int k = 0; k < 8; k++){
  944. if (src1.at<uchar>(dummy2 + dj[k], dummy1 + di[k]) == 0 && labels.at<uchar>(dummy2 + dj[k], dummy1 + di[k])){
  945. labels.at<uchar>(dummy2 + dj[k], dummy1 + di[k]) = label;
  946. queue.push({ dummy2 + dj[k], dummy1 + di[k] });
  947. }
  948. }
  949.  
  950. }
  951.  
  952. }
  953. }
  954. }
  955. for (int i = 1; i < labels.rows - 1; i++){
  956. for (int j = 1; j < labels.cols - 1; j++){
  957. printf("%d ", labels.at<uchar>(j,i));
  958. }
  959. printf("\n");
  960. }
  961.  
  962.  
  963. }
  964.  
  965. void label(){
  966. char fname[MAX_PATH];
  967. while (openFileDlg(fname))
  968. {
  969. Mat src;
  970. src = imread(fname, 0);
  971. //Create a window
  972. namedWindow("My Window", 1);
  973.  
  974. //set the callback function for any mouse event
  975. //setMouseCallback("My Window", effective_label, &src);
  976. int label = 0;
  977. Mat labels = Mat::zeros(src.size(), CV_8UC1);
  978. int di[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };
  979. int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
  980.  
  981. for (int i = 1; i < labels.rows - 1; i++){
  982. for (int j = 1; j < labels.cols - 1; j++){
  983. if (src.at<uchar>(i, j) == 0 && labels.at<uchar>(i, j) == 0){
  984. label++;
  985. printf("label %d \n",label);
  986. labels.at<uchar>(i, j) = label;
  987. //printf("Val labels %d label %d ", labels.at<uchar>(i, j),label);
  988. std::queue<Point2i> queue;
  989. queue.push({ i, j });
  990. while (!(queue.empty())){
  991. Point2i q = queue.front();
  992. queue.pop();
  993. for (int k = 0; k < 8; k++){
  994. if ((src.at<uchar>(q.x + di[k], q.y + dj[k]) == 0) && (labels.at<uchar>(q.x + di[k], q.y + dj[k])==0)){
  995. labels.at<uchar>(q.x + di[k], q.y + dj[k]) = label;
  996. queue.push({ q.x + di[k], q.y + dj[k] });
  997. }
  998. }
  999.  
  1000. }
  1001.  
  1002. }
  1003. }
  1004. }
  1005.  
  1006. for (int i = 1; i < labels.rows - 1; i++){
  1007. for (int j = 1; j < labels.cols - 1; j++){
  1008. if (labels.at<uchar>(i, j) != 0){
  1009. labels.at<uchar>(i, j) = 255;
  1010. }
  1011. else {
  1012. labels.at<uchar>(i, j) = 0;
  1013. }
  1014. }
  1015. }
  1016. //show the image
  1017. imshow("new window", labels);
  1018. imshow("My Window", src);
  1019.  
  1020. waitKey();
  1021. }
  1022.  
  1023. }
  1024.  
  1025. void computeAreaObject(){
  1026. char fname[MAX_PATH];
  1027. while (openFileDlg(fname))
  1028. {
  1029. Mat src;
  1030. src = imread(fname, CV_LOAD_IMAGE_COLOR);
  1031. //Create a window
  1032. namedWindow("My Window", 1);
  1033.  
  1034. //set the callback function for any mouse event
  1035. setMouseCallback("My Window", AreaCallBack, &src);
  1036.  
  1037. //show the image
  1038. imshow("My Window", src);
  1039.  
  1040. waitKey();
  1041. }
  1042. }
  1043.  
  1044. /* Histogram display function - display a histogram using bars (simlilar to L3 / PI)
  1045. Input:
  1046. name - destination (output) window name
  1047. hist - pointer to the vector containing the histogram values
  1048. hist_cols - no. of bins (elements) in the histogram = histogram image width
  1049. hist_height - height of the histogram image
  1050. Call example:
  1051. showHistogram ("MyHist", hist_dir, 255, 200);
  1052. */
  1053. void showHistogram(const string& name, int* hist, const int hist_cols, const int hist_height)
  1054. {
  1055. Mat imgHist(hist_height, hist_cols, CV_8UC3, CV_RGB(255, 255, 255)); // constructs a white image
  1056.  
  1057. //computes histogram maximum
  1058. int max_hist = 0;
  1059. for (int i = 0; i<hist_cols; i++)
  1060. if (hist[i] > max_hist)
  1061. max_hist = hist[i];
  1062. double scale = 1.0;
  1063. scale = (double)hist_height / max_hist;
  1064. int baseline = hist_height - 1;
  1065.  
  1066. for (int x = 0; x < hist_cols; x++) {
  1067. Point p1 = Point(x, baseline);
  1068. Point p2 = Point(x, baseline - cvRound(hist[x] * scale));
  1069. line(imgHist, p1, p2, CV_RGB(255, 0, 255)); // histogram bins colored in magenta
  1070. }
  1071.  
  1072. imshow(name, imgHist);
  1073. }
  1074.  
  1075. int main()
  1076. {
  1077. int op;
  1078. do
  1079. {
  1080. system("cls");
  1081. destroyAllWindows();
  1082. printf("Menu:\n");
  1083. printf(" 1 - Open image\n");
  1084. printf(" 2 - Open BMP images from folder\n");
  1085. printf(" 3 - Resize image\n");
  1086. printf(" 4 - Process video\n");
  1087. printf(" 5 - Snap frame from live video\n");
  1088. printf(" 6 - Mouse callback demo\n");
  1089. printf(" 7 - Negative grayscale image\n");
  1090. printf(" 8 - Negative color image\n");
  1091. printf(" 9 - Add 50 grayscale\n");
  1092. printf(" 10 - Add 50 color\n");
  1093. printf(" 11 - Create color matrix\n");
  1094. printf(" 12 - Enlight grayscale\n");
  1095. printf(" 13 - Enlight color\n");
  1096. printf(" 14 - Zoom\n");
  1097. printf(" 15 - RGB_MAT\n");
  1098. printf(" 16 - RGB_MATS\n");
  1099. printf(" 17 - Color To GrayScale\n");
  1100. printf(" 18 - GrayScale To Black&White\n");
  1101. printf(" 19 - Compute HSV\n");
  1102. printf(" 20 - Proprietati geometrice\n");
  1103. printf(" 21 - Etichetare\n");
  1104. printf(" 0 - Exit\n\n");
  1105. printf("Option: ");
  1106. scanf("%d", &op);
  1107. switch (op)
  1108. {
  1109. case 1:
  1110. testOpenImage();
  1111. break;
  1112. case 2:
  1113. testOpenImagesFld();
  1114. break;
  1115. case 3:
  1116. testResize();
  1117. break;
  1118. case 4:
  1119. testVideoSequence();
  1120. break;
  1121. case 5:
  1122. testSnap();
  1123. break;
  1124. case 6:
  1125. testMouseClick();
  1126. break;
  1127. case 7:
  1128. negative_grayscale();
  1129. break;
  1130. case 8:
  1131. negative_color();
  1132. break;
  1133. case 9:
  1134. add50_grayscale();
  1135. break;
  1136. case 10:
  1137. add50_color();
  1138. break;
  1139. case 11:
  1140. cr_mat();
  1141. break;
  1142. case 12:
  1143. enlight_grayscale();
  1144. break;
  1145. case 13:
  1146. enlight_color();
  1147. break;
  1148. case 14:
  1149. zoom();
  1150. break;
  1151. case 15:
  1152. rgb_mat();
  1153. break;
  1154. case 16:
  1155. rgb_mats();
  1156. break;
  1157. case 17:
  1158. color_To_GrayScale();
  1159. break;
  1160. case 18:
  1161. grayToBW();
  1162. break;
  1163. case 19:
  1164. compute_HSV();
  1165. break;
  1166. case 20:
  1167. computeAreaObject();
  1168. break;
  1169. case 21:
  1170. label();
  1171. }
  1172. } while (op != 0);
  1173. return 0;
  1174. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!