API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 18th, 2019
72
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 31.29 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 <random>
  7.  
  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. void testOpenImagesFld()
  22. {
  23. char folderName[MAX_PATH];
  24. if (openFolderDlg(folderName)==0)
  25. return;
  26. char fname[MAX_PATH];
  27. FileGetter fg(folderName,"bmp");
  28. while(fg.getNextAbsFile(fname))
  29. {
  30. Mat src;
  31. src = imread(fname);
  32. imshow(fg.getFoundFileName(),src);
  33. if (waitKey()==27) //ESC pressed
  34. break;
  35. }
  36. }
  37.  
  38. void testImageOpenAndSave()
  39. {
  40. Mat src, dst;
  41.  
  42. src = imread("Images/Lena_24bits.bmp", CV_LOAD_IMAGE_COLOR); // Read the image
  43.  
  44. if (!src.data) // Check for invalid input
  45. {
  46. printf("Could not open or find the image\n");
  47. return;
  48. }
  49.  
  50. // Get the image resolution
  51. Size src_size = Size(src.cols, src.rows);
  52.  
  53. // Display window
  54. const char* WIN_SRC = "Src"; //window for the source image
  55. namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  56. cvMoveWindow(WIN_SRC, 0, 0);
  57.  
  58. const char* WIN_DST = "Dst"; //window for the destination (processed) image
  59. namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  60. cvMoveWindow(WIN_DST, src_size.width + 10, 0);
  61.  
  62. cvtColor(src, dst, CV_BGR2GRAY); //converts the source image to a grayscale one
  63.  
  64. imwrite("Images/Lena_24bits_gray.bmp", dst); //writes the destination to file
  65.  
  66. imshow(WIN_SRC, src);
  67. imshow(WIN_DST, dst);
  68.  
  69. printf("Press any key to continue ...\n");
  70. waitKey(0);
  71. }
  72.  
  73. void testNegativeImage()
  74. {
  75. char fname[MAX_PATH];
  76. while(openFileDlg(fname))
  77. {
  78. double t = (double)getTickCount(); // Get the current time [s]
  79.  
  80. Mat src = imread(fname,CV_LOAD_IMAGE_GRAYSCALE);
  81. int height = src.rows;
  82. int width = src.cols;
  83. Mat dst = Mat(height,width,CV_8UC1);
  84. // Asa se acceseaaza pixelii individuali pt. o imagine cu 8 biti/pixel
  85. // Varianta ineficienta (lenta)
  86. for (int i=0; i<height; i++)
  87. {
  88. for (int j=0; j<width; j++)
  89. {
  90. uchar val = src.at<uchar>(i,j);
  91. uchar neg = 255 - val;
  92. dst.at<uchar>(i,j) = neg;
  93. }
  94. }
  95.  
  96. // Get the current time again and compute the time difference [s]
  97. t = ((double)getTickCount() - t) / getTickFrequency();
  98. // Print (in the console window) the processing time in [ms]
  99. printf("Time = %.3f [ms]\n", t * 1000);
  100.  
  101. imshow("input image",src);
  102. imshow("negative image",dst);
  103. waitKey();
  104. }
  105. }
  106.  
  107. void testParcurgereSimplaDiblookStyle()
  108. {
  109. char fname[MAX_PATH];
  110. while (openFileDlg(fname))
  111. {
  112. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  113. int height = src.rows;
  114. int width = src.cols;
  115. Mat dst = src.clone();
  116.  
  117. double t = (double)getTickCount(); // Get the current time [s]
  118.  
  119. // the fastest approach using the “diblook style”
  120. uchar *lpSrc = src.data;
  121. uchar *lpDst = dst.data;
  122. int w = (int) src.step; // no dword alignment is done !!!
  123. for (int i = 0; i<height; i++)
  124. for (int j = 0; j < width; j++) {
  125. uchar val = lpSrc[i*w + j];
  126. lpDst[i*w + j] = 255 - val;
  127. }
  128.  
  129. // Get the current time again and compute the time difference [s]
  130. t = ((double)getTickCount() - t) / getTickFrequency();
  131. // Print (in the console window) the processing time in [ms]
  132. printf("Time = %.3f [ms]\n", t * 1000);
  133.  
  134. imshow("input image",src);
  135. imshow("negative image",dst);
  136. waitKey();
  137. }
  138. }
  139.  
  140. void testColor2Gray()
  141. {
  142. char fname[MAX_PATH];
  143. while(openFileDlg(fname))
  144. {
  145. Mat src = imread(fname);
  146.  
  147. int height = src.rows;
  148. int width = src.cols;
  149.  
  150. Mat dst = Mat(height,width,CV_8UC1);
  151.  
  152. // Asa se acceseaaza pixelii individuali pt. o imagine RGB 24 biti/pixel
  153. // Varianta ineficienta (lenta)
  154. for (int i=0; i<height; i++)
  155. {
  156. for (int j=0; j<width; j++)
  157. {
  158. Vec3b v3 = src.at<Vec3b>(i,j);
  159. uchar b = v3[0];
  160. uchar g = v3[1];
  161. uchar r = v3[2];
  162. dst.at<uchar>(i,j) = (r+g+b)/3;
  163. }
  164. }
  165.  
  166. imshow("input image",src);
  167. imshow("gray image",dst);
  168. waitKey();
  169. }
  170. }
  171.  
  172. void testBGR2HSV()
  173. {
  174. char fname[MAX_PATH];
  175. while (openFileDlg(fname))
  176. {
  177. Mat src = imread(fname);
  178. int height = src.rows;
  179. int width = src.cols;
  180.  
  181. // Componentele d eculoare ale modelului HSV
  182. Mat H = Mat(height, width, CV_8UC1);
  183. Mat S = Mat(height, width, CV_8UC1);
  184. Mat V = Mat(height, width, CV_8UC1);
  185.  
  186. // definire pointeri la matricele (8 biti/pixeli) folosite la afisarea componentelor individuale H,S,V
  187. uchar* lpH = H.data;
  188. uchar* lpS = S.data;
  189. uchar* lpV = V.data;
  190.  
  191. Mat hsvImg;
  192. cvtColor(src, hsvImg, CV_BGR2HSV);
  193.  
  194. // definire pointer la matricea (24 biti/pixeli) a imaginii HSV
  195. uchar* hsvDataPtr = hsvImg.data;
  196.  
  197. for (int i = 0; i<height; i++)
  198. {
  199. for (int j = 0; j<width; j++)
  200. {
  201. int hi = i*width * 3 + j * 3;
  202. int gi = i*width + j;
  203.  
  204. lpH[gi] = hsvDataPtr[hi] * 510 / 360; // lpH = 0 .. 255
  205. lpS[gi] = hsvDataPtr[hi + 1]; // lpS = 0 .. 255
  206. lpV[gi] = hsvDataPtr[hi + 2]; // lpV = 0 .. 255
  207. }
  208. }
  209.  
  210. imshow("input image", src);
  211. imshow("H", H);
  212. imshow("S", S);
  213. imshow("V", V);
  214.  
  215. waitKey();
  216. }
  217. }
  218.  
  219. void testResize()
  220. {
  221. char fname[MAX_PATH];
  222. while(openFileDlg(fname))
  223. {
  224. Mat src;
  225. src = imread(fname);
  226. Mat dst1,dst2;
  227. //without interpolation
  228. resizeImg(src,dst1,320,false);
  229. //with interpolation
  230. resizeImg(src,dst2,320,true);
  231. imshow("input image",src);
  232. imshow("resized image (without interpolation)",dst1);
  233. imshow("resized image (with interpolation)",dst2);
  234. waitKey();
  235. }
  236. }
  237.  
  238. void testCanny()
  239. {
  240. char fname[MAX_PATH];
  241. while(openFileDlg(fname))
  242. {
  243. Mat src,dst,gauss;
  244. src = imread(fname,CV_LOAD_IMAGE_GRAYSCALE);
  245. double k = 0.4;
  246. int pH = 50;
  247. int pL = (int) k*pH;
  248. GaussianBlur(src, gauss, Size(5, 5), 0.8, 0.8);
  249. Canny(gauss,dst,pL,pH,3);
  250. imshow("input image",src);
  251. imshow("canny",dst);
  252. waitKey();
  253. }
  254. }
  255.  
  256. void testVideoSequence()
  257. {
  258. VideoCapture cap("Videos/rubic.avi"); // off-line video from file
  259. //VideoCapture cap(0); // live video from web cam
  260. if (!cap.isOpened()) {
  261. printf("Cannot open video capture device.\n");
  262. waitKey(0);
  263. return;
  264. }
  265.  
  266. Mat edges;
  267. Mat frame;
  268. char c;
  269.  
  270. while (cap.read(frame))
  271. {
  272. Mat grayFrame;
  273. cvtColor(frame, grayFrame, CV_BGR2GRAY);
  274. Canny(grayFrame,edges,40,100,3);
  275. imshow("source", frame);
  276. imshow("gray", grayFrame);
  277. imshow("edges", edges);
  278. c = cvWaitKey(0); // waits a key press to advance to the next frame
  279. if (c == 27) {
  280. // press ESC to exit
  281. printf("ESC pressed - capture finished\n");
  282. break; //ESC pressed
  283. };
  284. }
  285. }
  286.  
  287.  
  288. void testSnap()
  289. {
  290. VideoCapture cap(0); // open the deafult camera (i.e. the built in web cam)
  291. if (!cap.isOpened()) // openenig the video device failed
  292. {
  293. printf("Cannot open video capture device.\n");
  294. return;
  295. }
  296.  
  297. Mat frame;
  298. char numberStr[256];
  299. char fileName[256];
  300.  
  301. // video resolution
  302. Size capS = Size((int)cap.get(CV_CAP_PROP_FRAME_WIDTH),
  303. (int)cap.get(CV_CAP_PROP_FRAME_HEIGHT));
  304.  
  305. // Display window
  306. const char* WIN_SRC = "Src"; //window for the source frame
  307. namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  308. cvMoveWindow(WIN_SRC, 0, 0);
  309.  
  310. const char* WIN_DST = "Snapped"; //window for showing the snapped frame
  311. namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  312. cvMoveWindow(WIN_DST, capS.width + 10, 0);
  313.  
  314. char c;
  315. int frameNum = -1;
  316. int frameCount = 0;
  317.  
  318. for (;;)
  319. {
  320. cap >> frame; // get a new frame from camera
  321. if (frame.empty())
  322. {
  323. printf("End of the video file\n");
  324. break;
  325. }
  326.  
  327. ++frameNum;
  328.  
  329. imshow(WIN_SRC, frame);
  330.  
  331. c = cvWaitKey(10); // waits a key press to advance to the next frame
  332. if (c == 27) {
  333. // press ESC to exit
  334. printf("ESC pressed - capture finished");
  335. break; //ESC pressed
  336. }
  337. if (c == 115){ //'s' pressed - snapp the image to a file
  338. frameCount++;
  339. fileName[0] = NULL;
  340. sprintf(numberStr, "%d", frameCount);
  341. strcat(fileName, "Images/A");
  342. strcat(fileName, numberStr);
  343. strcat(fileName, ".bmp");
  344. bool bSuccess = imwrite(fileName, frame);
  345. if (!bSuccess)
  346. {
  347. printf("Error writing the snapped image\n");
  348. }
  349. else
  350. imshow(WIN_DST, frame);
  351. }
  352. }
  353.  
  354. }
  355.  
  356. float computeElongationAxis(Mat_<Vec3b> src, Vec3b color, int iCenter, int jCenter)
  357. {
  358. int cols = src.cols;
  359. int rows = src.rows;
  360. int s1 = 0, s2 = 0;
  361. for (int i = 0; i < rows; i++)
  362. {
  363. for (int j = 0; j < cols; j++)
  364. {
  365. if (src(i, j) == color)
  366. {
  367. s1 = s1 + (i - iCenter)*(j - jCenter);
  368. s2 = s2 +(j - jCenter)*(j - jCenter) - (i - iCenter)*(i - iCenter);
  369.  
  370. }
  371. }
  372. }
  373. s1 = s1*2;
  374. return atan2(s1, s2)/ 2.0f;
  375.  
  376. }
  377.  
  378. Point computeCenterOfMass(Mat_<Vec3b> src, Vec3b selectedColor, int Area ) {
  379. int cols = src.cols;
  380. int rows = src.rows;
  381. int iCenter = 0, jCenter = 0;
  382. for (int i = 0; i < rows; i++) {
  383. for (int j = 0; j < cols; j++) {
  384. if (src(i, j) == selectedColor) {
  385.  
  386. iCenter = iCenter + i;
  387. jCenter = jCenter + j;
  388. }
  389. }
  390. }
  391. iCenter = iCenter / Area;
  392. jCenter = jCenter / Area;
  393. return Point(jCenter, iCenter);
  394. }
  395.  
  396. int computeArea(Mat_<Vec3b> src, Vec3b selectedColor)
  397. {
  398. int Area = 0;
  399. for (int i = 0; i < src.rows; i++)
  400. {
  401. for (int j = 0; j < src.cols; j++)
  402. {
  403. if (src(i, j) == selectedColor)
  404. {
  405. Area++;
  406. }
  407. }
  408. }
  409. return Area;
  410. }
  411.  
  412. void MyCallBackFunc(int event, int x, int y, int flags, void* param)
  413. {
  414. //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  415. Mat_<Vec3b>* src = (Mat_<Vec3b>*)param;
  416. Mat_<Vec3b> copy;
  417. Vec3b selectedColor;
  418. Point centerOfMass;
  419. Point Point1, Point2;
  420. float angleRad, angleDegree;
  421. if (event == CV_EVENT_LBUTTONDOWN)
  422. {
  423. copy = *src;
  424. printf("Pos(x,y): %d,%d Color(RGB): %d,%d,%d\n",
  425. x, y,
  426. (int)(*src).at<Vec3b>(y, x)[2],
  427. (int)(*src).at<Vec3b>(y, x)[1],
  428. (int)(*src).at<Vec3b>(y, x)[0]);
  429. selectedColor = (*src).at<Vec3b>(y, x);
  430. int Area = computeArea(*src, selectedColor);
  431. printf("%d\n", Area);
  432. centerOfMass = computeCenterOfMass(*src, selectedColor, Area);
  433. printf("%d , %d\n", centerOfMass.x, centerOfMass.y);
  434. circle(copy, centerOfMass, 5, Scalar(255, 0, 255), -1);
  435. imshow("Copy", copy);
  436. angleRad = computeElongationAxis(*src, selectedColor, centerOfMass.y, centerOfMass.x);
  437. angleDegree = angleRad * 180 / 3, 14;
  438. printf("%f\n", angleDegree);
  439. Point1.x = centerOfMass.x - 30;
  440. Point2.x = centerOfMass.x + 30;
  441. int y = 30 * tan(angleRad);
  442. Point1.y = centerOfMass.y - y;
  443. Point2.y = centerOfMass.y + y;
  444. line(copy, Point1, Point2, Scalar(0, 0, 0));
  445. }
  446.  
  447. }
  448.  
  449. void testMouseClick()
  450. {
  451. Mat src;
  452. // Read image from file
  453. char fname[MAX_PATH];
  454. while (openFileDlg(fname))
  455. {
  456. src = imread(fname);
  457. //Create a window
  458. namedWindow("My Window", 1);
  459.  
  460. //set the callback function for any mouse event
  461. setMouseCallback("My Window", MyCallBackFunc, &src);
  462.  
  463. //show the image
  464. imshow("My Window", src);
  465.  
  466. // Wait until user press some key
  467. waitKey(0);
  468. }
  469. }
  470.  
  471. /* Histogram display function - display a histogram using bars (simlilar to L3 / PI)
  472. Input:
  473. name - destination (output) window name
  474. hist - pointer to the vector containing the histogram values
  475. hist_cols - no. of bins (elements) in the histogram = histogram image width
  476. hist_height - height of the histogram image
  477. Call example:
  478. showHistogram ("MyHist", hist_dir, 255, 200);
  479. */
  480. void showHistogram(const std::string& name, int* hist, const int hist_cols, const int hist_height)
  481. {
  482. Mat imgHist(hist_height, hist_cols, CV_8UC3, CV_RGB(255, 255, 255)); // constructs a white image
  483.  
  484. //computes histogram maximum
  485. int max_hist = 0;
  486. for (int i = 0; i<hist_cols; i++)
  487. if (hist[i] > max_hist)
  488. max_hist = hist[i];
  489. double scale = 1.0;
  490. scale = (double)hist_height / max_hist;
  491. int baseline = hist_height - 1;
  492.  
  493. for (int x = 0; x < hist_cols; x++) {
  494. Point p1 = Point(x, baseline);
  495. Point p2 = Point(x, baseline - cvRound(hist[x] * scale));
  496. line(imgHist, p1, p2, CV_RGB(255, 0, 255)); // histogram bins colored in magenta
  497. }
  498.  
  499. imshow(name, imgHist);
  500.  
  501. }
  502.  
  503. void copy_RGB()
  504. {
  505. char filename[MAX_PATH];
  506. openFileDlg(filename);
  507. Mat_<Vec3b> src;
  508. src = imread(filename); ///opencv returns BGR
  509. imshow("image", src);
  510.  
  511. Mat_<uchar> r(src.rows,src.cols);
  512. Mat_<uchar> g(src.rows,src.cols);
  513. Mat_<uchar> b(src.rows,src.cols);
  514.  
  515. for (int i = 0; i < src.rows; i++)
  516. {
  517. for (int j = 0; j < src.cols; j++)
  518. {
  519. b(i, j) = src(i, j)[0];
  520. g(i, j) = src(i, j)[1];
  521. r(i, j) = src(i, j)[2];
  522. }
  523. }
  524.  
  525. imshow("blue", b);
  526. imshow("green", g);
  527. imshow("red", r);
  528. waitKey();
  529.  
  530. }
  531.  
  532. void convert_to_grayscale()
  533. {
  534. char filename[MAX_PATH];
  535. openFileDlg(filename);
  536. Mat_<Vec3b> src;
  537. src = imread(filename);
  538. imshow("image", src);
  539.  
  540. Mat_<uchar> grayscale(src.rows,src.cols);
  541.  
  542. for (int i = 0; i < src.rows; i++)
  543. {
  544. for (int j = 0; j < src.cols; j++)
  545. {
  546. grayscale(i, j) = (src(i, j)[0] + src(i, j)[1] + src(i, j)[2]) / 3;
  547. }
  548. }
  549.  
  550. imshow("grayscale", grayscale);
  551. waitKey();
  552.  
  553. }
  554.  
  555. void convert_to_binary()
  556. {
  557. char filename[MAX_PATH];
  558. openFileDlg(filename);
  559. Mat_<uchar> src;
  560. src = imread(filename,0);
  561.  
  562. int treshold;
  563.  
  564. Mat_<uchar> binary(src.rows,src.cols);
  565. std::cout << "Treshold: ";
  566. std::cin >> treshold;
  567. std::cout << "\n";
  568.  
  569. for (int i = 0; i < src.rows; i++)
  570. {
  571. for (int j = 0; j < src.cols; j++)
  572. {
  573. if (src(i, j) < treshold)
  574. {
  575. binary(i, j) = 0;
  576. }
  577.  
  578. else
  579. {
  580. binary(i, j) = 255;
  581. }
  582. }
  583. }
  584. imshow("image", src);
  585. imshow("binary", binary);
  586. waitKey();
  587.  
  588. }
  589.  
  590. void compute_HSV()
  591. {
  592. char filename[MAX_PATH];
  593. openFileDlg(filename);
  594. Mat_<Vec3b> src;
  595. src = imread(filename);
  596. float r, g, b, m, M, C, V, H, S;
  597.  
  598. Mat_<uchar> h(src.rows, src.cols);
  599. Mat_<uchar> s(src.rows, src.cols);
  600. Mat_<uchar> v(src.rows,src.cols);
  601.  
  602. for (int i = 0; i < src.rows; i++)
  603. {
  604. for (int j = 0; j < src.cols; j++)
  605. {
  606. r = (float)src(i, j)[2] / 255;
  607. g = (float)src(i, j)[1] / 255;
  608. b = (float)src(i, j)[0] / 255;
  609. M = max(max(r, g), b);
  610. m = min(min(r, g), b);
  611. C = M - m;
  612. V = M;
  613.  
  614. if (V != 0)
  615. {
  616. S = C / V;
  617. }
  618. else
  619. {
  620. S = 0;
  621. }
  622.  
  623. if (C != 0)
  624. {
  625. if (M == r)
  626. {
  627. H = 60 * (g - b) / C;
  628. }
  629.  
  630. if (M == g)
  631. {
  632. H = 120 + 60 * (b - r) / C;
  633. }
  634.  
  635. if (M == b)
  636. {
  637. H = 240 + 60 * (r - g) / C;
  638. }
  639. }
  640. else
  641. {
  642. H = 0;
  643. }
  644.  
  645. if (H < 0)
  646. {
  647. H = H + 360;
  648. }
  649.  
  650. uchar H_norm = H * 255 / 360;
  651. uchar S_norm = S * 255;
  652. uchar V_norm = V * 255;
  653. h(i, j) = H_norm;
  654. s(i, j) = S_norm;
  655. v(i, j) = V_norm;
  656.  
  657. }
  658. }
  659.  
  660. imshow("image", src);
  661. imshow("h", h);
  662. imshow("s", s);
  663. imshow("v", v);
  664. waitKey();
  665.  
  666.  
  667. }
  668.  
  669.  
  670. int* compute_histogram(Mat_<uchar> src) {
  671. int * histogram = new int[256]();
  672. for (int i = 0; i < src.rows; i++) {
  673. for (int j = 0; j < src.cols; j++) {
  674. histogram[src(i, j)]++;
  675. }
  676. }
  677. return histogram;
  678. }
  679.  
  680.  
  681. void test_histogram() {
  682. char filename[MAX_PATH];
  683. int * histogram = new int[256]();
  684. openFileDlg(filename);
  685. Mat_<uchar> src;
  686. src = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);
  687. imshow("image", src);
  688. histogram = compute_histogram(src);
  689. showHistogram("Histogram", histogram, 255, 255);
  690. waitKey();
  691. }
  692.  
  693.  
  694. float * compute_PDF(Mat_<uchar> src) {
  695.  
  696. int * histogram = compute_histogram(src);
  697. float PDF[256];
  698. int M = src.rows * src.cols;
  699. for (int i = 0; i < 256; i++) {
  700. PDF[i] = histogram[i] / M;
  701. }
  702. return PDF;
  703. }
  704.  
  705. void test_PDF() {
  706. char filename[MAX_PATH];
  707. openFileDlg(filename);
  708. Mat_<uchar> src;
  709. src = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);
  710. imshow("image", src);
  711. compute_PDF(src);
  712. waitKey();
  713. }
  714.  
  715. int * compute_bins_histogram(Mat_<uchar> src, int bins) {
  716. int * histogram = new int[bins]();
  717. float N = 256 / bins;
  718. for (int i = 0; i < src.rows; i++) {
  719. for (int j = 0; j < src.cols; j++) {
  720. histogram[(int)(src(i, j)/N)]++;
  721. }
  722. }
  723. return histogram;
  724. }
  725.  
  726.  
  727. void test_bins_histogram() {
  728. printf("Bins=");
  729. int bins;
  730. scanf("%d", &bins);
  731. char filename[MAX_PATH];
  732. int * histogram = new int[bins]();
  733. openFileDlg(filename);
  734. Mat_<uchar> src;
  735. src = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);
  736. imshow("image", src);
  737. histogram = compute_bins_histogram(src,bins);
  738. showHistogram("Histogram", histogram, bins, 255);
  739. waitKey();
  740. }
  741.  
  742.  
  743.  
  744. uchar getMaxima(std::vector<int> maximas, uchar pixel)
  745. {
  746. int minDif = 1000;
  747. int pos;
  748. int dif;
  749. for (int i = 0; i < maximas.size(); i++)
  750. {
  751. dif = std::abs(pixel - maximas[i]);
  752. if (dif < minDif)
  753. {
  754. minDif = dif;
  755. pos = maximas[i];
  756. }
  757. }
  758. return pos;
  759. }
  760.  
  761. std::vector<int> computeMaxima(float* pdf)
  762. {
  763. int WH = 5;
  764. float TH = 0.0003;
  765. float avg = 0;
  766. bool maxima = true;
  767. std::vector<int> maximas;
  768. maximas.push_back(0);
  769. for (int k = WH; k < 255 - WH; k++)
  770. {
  771. maxima = true;
  772. avg = 0;
  773. for (int i = k - WH; i <= k + WH; i++)
  774. {
  775. if (pdf[k] < pdf[i])
  776. {
  777. maxima = false;
  778. }
  779. avg += pdf[i];
  780. }
  781. avg = avg / (2 * WH + 1);
  782. if ((pdf[k] > avg + TH) && maxima)
  783. {
  784.  
  785. maximas.push_back(k);
  786. }
  787.  
  788. if (maxima)
  789. {
  790. }
  791. }
  792. maximas.push_back(255);
  793. return maximas;
  794. }
  795.  
  796. void multilevelThresholding(Mat_<uchar> src, float* pdf)
  797. {
  798. int WH = 5;
  799. float TH = 0.0003;
  800. float avg = 0;
  801. bool maxima = true;
  802. int size = src.cols * src.rows;
  803. Mat_<uchar> dest(src.rows, src.cols);
  804. std::vector<int> maximas;
  805. maximas = computeMaxima(pdf);
  806. uchar pixel;
  807. for (int i = 0; i < src.rows; i++)
  808. {
  809. for (int j = 0; j < src.cols; j++)
  810. {
  811. pixel = src(i, j);
  812. dest(i, j) = getMaxima(maximas, pixel);
  813.  
  814. }
  815. }
  816. imshow("src", src);
  817. imshow("dest", dest);
  818. waitKey();
  819. }
  820.  
  821. void testThresholding()
  822. {
  823. char fname[MAX_PATH];
  824. openFileDlg(fname);
  825. Mat_<uchar> src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  826. int* hist = compute_histogram(src);
  827. showHistogram("hist", hist, 255, 255);
  828. float* pdf = compute_PDF(src);
  829. multilevelThresholding(src, pdf);
  830. delete[] pdf;
  831. delete[] hist;
  832. }
  833.  
  834. Mat_<uchar> breadth_first_traversal(Mat_<uchar> src) {
  835. int di[8] = { -1, 0, 1, 0, -1, 1, 1, -1 };
  836. int dj[8] = { 0, -1, 0, 1, -1, -1, 1, 1 };
  837. int N;
  838. int label = 0;
  839. int height = src.rows;
  840. int width = src.cols;
  841. Mat_<uchar> labels = Mat_<uchar>::zeros(height, width);
  842.  
  843. printf("Insert neighborhood type(4 or 8):");
  844. scanf("%d", &N);
  845.  
  846.  
  847. for (int i = 0; i < height; i++) {
  848. for (int j = 0; j < width; j++) {
  849. if (src(i, j) == 0 && labels(i, j) == 0){
  850. label++;
  851. printf("New label found\n");
  852. std::queue<Point> Q;
  853. labels(i, j) = label;
  854. Q.push(Point(i, j));
  855. while (!Q.empty()) {
  856. Point q = Q.front();
  857. Q.pop();
  858. for (int k = 0; k < N; k++) {
  859. Point neighbor(q.x+di[k],q.y+dj[k]);
  860. if(neighbor.x>=0 && neighbor.x < src.rows && neighbor.y >=0 && neighbor.y < src.cols){
  861. if (src(neighbor.x, neighbor.y) == 0 && labels(neighbor.x, neighbor.y) == 0) {
  862. labels(neighbor.x, neighbor.y) = label;
  863. Q.push(neighbor);
  864. }
  865. }
  866. }
  867. }
  868. }
  869. }
  870. }
  871.  
  872. return labels;
  873. }
  874.  
  875. Mat_<Vec3b> colorLabels(Mat_<uchar> labels) {
  876.  
  877. std::default_random_engine gen;
  878. std::uniform_int_distribution<int> d(0, 255);
  879. Mat_<Vec3b> destination(labels.rows,labels.cols);
  880. uchar x = d(gen);
  881. std::vector<Vec3b> colors;
  882. for (int i = 0; i < 255; i++) {
  883. colors.push_back(Vec3b(d(gen), d(gen), d(gen)));
  884. }
  885. for (int i = 0; i < labels.rows; i++)
  886. {
  887. for (int j = 0; j < labels.cols; j++)
  888. {
  889. if (labels(i,j)>0) {
  890.  
  891. destination(i, j) = colors[labels(i, j)];
  892. }
  893. else {
  894. destination(i, j) = Vec3b(255,255,255);
  895. }
  896. }
  897. }
  898. return destination;
  899. }
  900.  
  901. void test_breadth_first_traversal() {
  902. char filename[MAX_PATH];
  903. openFileDlg(filename);
  904. Mat_<Vec3b> img;
  905. Mat_<uchar> src;
  906. src = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);
  907. imshow("image", src);
  908. Mat_<uchar> labels = breadth_first_traversal(src);
  909. img = colorLabels(labels);
  910. imshow("labels", labels);
  911. imshow("color labels", img);
  912. waitKey(0);
  913. }
  914.  
  915. Mat_<uchar> label_two_pass(Mat_<uchar> src){
  916. int di[8] = {0,-1,-1,-1,0,1,1,1};
  917. int dj[8] = {-1,-1,0,1,1,1,0,-1};
  918. int label = 0;
  919. int height = src.rows;
  920. int width = src.cols;
  921. Mat_<uchar> labels = Mat_<uchar>::zeros(height, width);
  922. std::vector<std::vector<int>> edges;
  923.  
  924. for (int i = 0; i < height - 1; i++) {
  925. for (int j = 0; j < width; j++) {
  926.  
  927. if (src(i, j) == 0 && labels(i, j) == 0) {
  928.  
  929. std::vector<uchar> L;
  930. for (int k = 0; k < 4; k++) {
  931. Point neighbor(i + di[k], j + dj[k]);
  932. if (neighbor.x >= 0 && neighbor.x < src.rows && neighbor.y >= 0 && neighbor.y < src.cols) {
  933. if (labels(neighbor.x, neighbor.y) > 0) {
  934. L.push_back(labels(neighbor.x, neighbor.y));
  935. }
  936. }
  937. }
  938.  
  939. if (L.size() == 0) {
  940. label++;
  941. labels(i, j) = label;
  942. }
  943. else {
  944. int x = *std::min_element(L.begin(), L.end());
  945. labels(i, j) = x;
  946. for (int k = 0; k < L.size(); k++) {
  947. if (L[k] != x) {
  948. edges.resize(label+1);
  949. edges[x].push_back(L[k]);
  950. edges[L[k]].push_back(x);
  951. }
  952. }
  953. }
  954. }
  955. }
  956. }
  957.  
  958. int newLabel = 0;
  959. int * newLabels = new int[label + 1]();
  960. for (int i = 1; i <= label; i++) {
  961. if (newLabels[i] == 0) {
  962. newLabel++;
  963. std::queue<int> Q;
  964. newLabels[i] = newLabel;
  965. Q.push(i);
  966. while (!Q.empty()) {
  967. int x = Q.front();
  968. Q.pop();
  969. for (int y = 0; y < edges[x].size(); y++) {
  970. if (newLabels[edges[x][y]] == 0) {
  971. newLabels[edges[x][y]] = newLabel;
  972. Q.push(edges[x][y]);
  973. }
  974. }
  975.  
  976.  
  977.  
  978. }
  979. }
  980. }
  981.  
  982. for (int i = 0; i <= height - 1; i++) {
  983. for (int j = 0; j <= width - 1; j++) {
  984. labels(i, j) = newLabels[labels(i, j)];
  985. }
  986. }
  987. return labels;
  988. }
  989.  
  990. void test_label_two_pass() {
  991. char filename[MAX_PATH];
  992. openFileDlg(filename);
  993. Mat_<uchar> src = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);
  994. Mat_<uchar> labels = label_two_pass(src);
  995. Mat_<Vec3b> colors = colorLabels(labels);
  996. imshow("Source", src);
  997. imshow("Labels", labels);
  998. imshow("Colour", colors);
  999. waitKey();
  1000. }
  1001.  
  1002.  
  1003. std::vector<Point> traceBorder(Mat_<uchar> src, std::vector<int> *codeChain) {
  1004.  
  1005. int rows = src.rows;
  1006. int cols = src.cols;
  1007. Mat_<Vec3b> dst(rows, cols);
  1008. int lastDir = 0;
  1009. int di[8] = { 0,-1,-1,-1,0,1,1,1 };
  1010. int dj[8] = { 1,1,0,-1,-1,-1,0,1 };
  1011. int k = 0;
  1012. lastDir = 7;
  1013. std::vector<Point> border;
  1014. for (int i = 0; i < rows; i++)
  1015. {
  1016. for (int j = 0; j < cols; j++)
  1017. {
  1018. if (src(i, j) < 254)
  1019. {
  1020. dst(i, j) = Vec3b(255, 0, 0);
  1021. int k = 0;
  1022.  
  1023. Point startingPoint(j, i);
  1024. Point lastpoint(j, i);
  1025. Point neighbor(-1, -1);
  1026. while (startingPoint != neighbor)
  1027. {
  1028. k = 0;
  1029. if (lastDir % 2 == 0)
  1030. {
  1031. lastDir = (lastDir + 7) % 8;
  1032. }
  1033. else
  1034. {
  1035. lastDir = (lastDir + 6) % 8;
  1036. }
  1037. while (k < 8)
  1038. {
  1039. neighbor = Point(lastpoint.x + dj[lastDir], lastpoint.y + di[lastDir]);
  1040. if (src(neighbor.y,neighbor.x) == src(i, j))
  1041. {
  1042. border.push_back(neighbor);
  1043. codeChain->push_back(lastDir);
  1044. break;
  1045. }
  1046. k++;
  1047. lastDir = (lastDir + 1) % 8;
  1048.  
  1049. }
  1050. lastpoint = neighbor;
  1051. }
  1052. return border;
  1053. }
  1054. else
  1055. {
  1056. dst(i, j) = Vec3b(src(i, j), src(i, j), src(i, j));
  1057. }
  1058. }
  1059. }
  1060.  
  1061. return border;
  1062. }
  1063.  
  1064. void testBorderTracing()
  1065. {
  1066. int n;
  1067. char fname[MAX_PATH];
  1068. openFileDlg(fname);
  1069. std::vector<int> codeChain;
  1070. Mat_<uchar> src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1071. Mat_<Vec3b> dst(src.rows, src.cols);
  1072. std::vector<Point> border = traceBorder(src, &codeChain);
  1073. std::vector<int> derivate;
  1074. for (int i = 0; i < src.rows; i++)
  1075. {
  1076. for (int j = 0; j < src.cols; j++)
  1077. {
  1078. dst(i, j) = Vec3b(src(i, j), src(i, j), src(i, j));
  1079. }
  1080. }
  1081. for (int i = 0; i < border.size(); i++)
  1082. {
  1083. dst(border[i]) = Vec3b(0,0,255);
  1084.  
  1085.  
  1086. }
  1087.  
  1088. for (int i = 0; i < codeChain.size(); i++) {
  1089. printf("%d ",codeChain[i]);
  1090. }
  1091.  
  1092. imshow("src", src);
  1093. imshow("dst", dst);
  1094. waitKey(0);
  1095. }
  1096.  
  1097.  
  1098. Mat_<uchar> dillation(Mat_<uchar> src, Mat_<uchar> structure)
  1099. {
  1100. int rows = src.rows;
  1101. int cols = src.cols;
  1102. int width = structure.cols;
  1103. int height = structure.rows;
  1104. Mat_<uchar> dst(rows, cols, 255);
  1105.  
  1106. for (int i = 0; i < rows; i++)
  1107. {
  1108. for (int j = 0; j < cols; j++)
  1109. {
  1110. if (src(i, j) == 0)
  1111. {
  1112. dst(i, j) = 0;
  1113. for (int m = -height / 2; m <= height / 2; m++)
  1114. {
  1115. for (int n = -width / 2; n <= width / 2; n++)
  1116. {
  1117. Point neighbor(j + n, i + m);
  1118. if (neighbor.x >= 0 && neighbor.x < cols && neighbor.y >= 0 && neighbor.y < rows)
  1119. {
  1120. if (structure(m + height / 2, n + width / 2) == 0)
  1121. {
  1122. dst(neighbor) = 0;
  1123. }
  1124. }
  1125.  
  1126. }
  1127. }
  1128.  
  1129. }
  1130.  
  1131. }
  1132. }
  1133. return dst;
  1134. }
  1135.  
  1136.  
  1137.  
  1138. Mat_<uchar> erosion(Mat_<uchar> src, Mat_<uchar> structure)
  1139. {
  1140. int rows = src.rows;
  1141. int cols = src.cols;
  1142. int width = structure.cols;
  1143. int height = structure.rows;
  1144. Mat_<uchar> dst(rows, cols, 255);
  1145. int di[8] = { -1, 0, 1, 0, -1, 1, 1, -1 };
  1146. int dj[8] = { 0, -1, 0, 1, -1, -1, 1, 1 };
  1147.  
  1148. for (int i = 0; i < rows; i++)
  1149. {
  1150. for (int j = 0; j < cols; j++)
  1151. {
  1152. if (src(i, j) == 0)
  1153. {
  1154. dst(i, j) = 0;
  1155. for (int m = -height / 2; m <= height / 2; m++)
  1156. {
  1157. for (int n = -width / 2; n <= width / 2; n++)
  1158. {
  1159. Point neighbor(j + n, i + m);
  1160. if (neighbor.x >= 0 && neighbor.x < cols && neighbor.y >= 0 && neighbor.y < rows)
  1161. {
  1162. if (structure(m + height / 2, n + width / 2) == 0 && src(neighbor) == 255)
  1163. {
  1164. dst(i, j) = 255;
  1165. }
  1166. }
  1167.  
  1168. }
  1169. }
  1170. }
  1171.  
  1172. }
  1173. }
  1174. return dst;
  1175. }
  1176.  
  1177.  
  1178.  
  1179. void testErosion()
  1180. {
  1181. char fname[MAX_PATH];
  1182. openFileDlg(fname);
  1183. Mat_<uchar> src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1184. Mat_<uchar> structure(3, 3);
  1185. structure(0, 0) = 255;
  1186. structure(0, 1) = 0;
  1187. structure(0, 2) = 255;
  1188. structure(1, 0) = 0;
  1189. structure(1, 1) = 0;
  1190. structure(1, 2) = 0;
  1191. structure(2, 0) = 255;
  1192. structure(2, 1) = 0;
  1193. structure(2, 2) = 255;
  1194. Mat_<uchar> dst = erosion(src, structure);
  1195.  
  1196. imshow("original", src);
  1197. imshow("eroded", dst);
  1198. waitKey(0);
  1199.  
  1200. }
  1201.  
  1202. void testDillation()
  1203. {
  1204. char fname[MAX_PATH];
  1205. openFileDlg(fname);
  1206. Mat_<uchar> src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1207. Mat_<uchar> structure(3, 3);
  1208. structure(0, 0) = 255;
  1209. structure(0, 1) = 0;
  1210. structure(0, 2) = 255;
  1211. structure(1, 0) = 0;
  1212. structure(1, 1) = 0;
  1213. structure(1, 2) = 0;
  1214. structure(2, 0) = 255;
  1215. structure(2, 1) = 0;
  1216. structure(2, 2) = 255;
  1217. Mat_<uchar> dst = dillation(src, structure);
  1218. imshow("original", src);
  1219. imshow("dillated", dst);
  1220. waitKey(0);
  1221. }
  1222.  
  1223.  
  1224. Mat_<uchar> opening(Mat_<uchar> src, Mat_<uchar> structure)
  1225. {
  1226. int rows = src.rows;
  1227. int cols = src.cols;
  1228. Mat_<uchar> dst(rows,cols);
  1229. Mat_<uchar> buffer = erosion(src, structure);
  1230. dst = dillation(buffer, structure);
  1231.  
  1232. return dst;
  1233. }
  1234.  
  1235. Mat_<uchar> closing(Mat_<uchar> src, Mat_<uchar> structure)
  1236. {
  1237. int rows = src.rows;
  1238. int cols = src.cols;
  1239. Mat_<uchar> dst(rows,cols);
  1240. Mat_<uchar> buffer = dillation(src, structure);
  1241. dst = erosion(buffer, structure);
  1242.  
  1243. return dst;
  1244. }
  1245.  
  1246. void testOpening()
  1247. {
  1248. char fname[MAX_PATH];
  1249. openFileDlg(fname);
  1250. Mat_<uchar> src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1251. Mat_<uchar> structure(3, 3);
  1252. structure(0, 0) = 255;
  1253. structure(0, 1) = 0;
  1254. structure(0, 2) = 255;
  1255. structure(1, 0) = 0;
  1256. structure(1, 1) = 0;
  1257. structure(1, 2) = 0;
  1258. structure(2, 0) = 255;
  1259. structure(2, 1) = 0;
  1260. structure(2, 2) = 255;
  1261. Mat_<uchar> dst = opening(src, structure);
  1262. imshow("original", src);
  1263. imshow("opened", dst);
  1264. waitKey(0);
  1265. }
  1266.  
  1267. void testClosing()
  1268. {
  1269. char fname[MAX_PATH];
  1270. openFileDlg(fname);
  1271. Mat_<uchar> src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1272. Mat_<uchar> structure(3, 3);
  1273. structure(0, 0) = 255;
  1274. structure(0, 1) = 0;
  1275. structure(0, 2) = 255;
  1276. structure(1, 0) = 0;
  1277. structure(1, 1) = 0;
  1278. structure(1, 2) = 0;
  1279. structure(2, 0) = 255;
  1280. structure(2, 1) = 0;
  1281. structure(2, 2) = 255;
  1282. Mat_<uchar> dst = closing(src, structure);
  1283. imshow("original", src);
  1284. imshow("closed", dst);
  1285. waitKey(0);
  1286. }
  1287.  
  1288. Mat_<uchar> difference(Mat_<uchar> A, Mat_<uchar> B)
  1289. {
  1290. int rows = A.rows;
  1291. int cols = A.cols;
  1292. Mat_<uchar> dst(rows, cols);
  1293. for (int i = 0; i < rows; i++)
  1294. {
  1295. for (int j = 0; j < cols; j++)
  1296. {
  1297. if (A(i, j) == B(i, j))
  1298. {
  1299. dst(i, j) = 255;
  1300. }
  1301. else
  1302. {
  1303. dst(i, j) = A(i, j);
  1304. }
  1305. }
  1306. }
  1307. return dst;
  1308.  
  1309. }
  1310.  
  1311. Mat_<uchar> boundaryExtraction(Mat_<uchar> src, Mat_<uchar> structure)
  1312. {
  1313. Mat_<uchar> eroded = erosion(src, structure);
  1314. Mat_<uchar> boundary = difference(src, eroded);
  1315. return boundary;
  1316.  
  1317. }
  1318.  
  1319. void testBoundaryExtraction()
  1320. {
  1321. char fname[MAX_PATH];
  1322. openFileDlg(fname);
  1323. Mat_<uchar> src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1324. Mat_<uchar> dst(src.rows, src.cols);
  1325. Mat_<uchar> structure(3, 3);
  1326. structure(0, 0) = 0;
  1327. structure(0, 1) = 0;
  1328. structure(0, 2) = 0;
  1329. structure(1, 0) = 0;
  1330. structure(1, 1) = 0;
  1331. structure(1, 2) = 0;
  1332. structure(2, 0) = 0;
  1333. structure(2, 1) = 0;
  1334. structure(2, 2) = 0;
  1335. dst = boundaryExtraction(src, structure);
  1336.  
  1337. imshow("original", src);
  1338. imshow("boundary", dst);
  1339. waitKey(0);
  1340. }
  1341.  
  1342.  
  1343. int main()
  1344. {
  1345. int op;
  1346. do
  1347. {
  1348. system("cls");
  1349. destroyAllWindows();
  1350. printf("Menu:\n");
  1351. printf(" 1 - Open image\n");
  1352. printf(" 2 - Open BMP images from folder\n");
  1353. printf(" 3 - Image negative - diblook style\n");
  1354. printf(" 4 - BGR->HSV\n");
  1355. printf(" 5 - Resize image\n");
  1356. printf(" 6 - Canny edge detection\n");
  1357. printf(" 7 - Edges in a video sequence\n");
  1358. printf(" 8 - Snap frame from live video\n");
  1359. printf(" 9 - Mouse callback demo\n");
  1360. printf(" 10 - Lab2 Copy RGB\n");
  1361. printf(" 11 - Lab2 Convert to grayscale\n");
  1362. printf(" 12 - Lab2 Convert to binary\n");
  1363. printf(" 13 - Lab2 Compute HSV\n");
  1364. printf(" 14 - Lab4 Object properties\n");
  1365. printf(" 15 - Lab 3 show histogram\n");
  1366. printf(" 16 - Lab3 show bins histogram\n");
  1367. printf(" 17 - Lab3 multilevel thresholding\n");
  1368. printf(" 18 - Lab5 breadth first traversal\n");
  1369. printf(" 19- Lab5 label two pass\n");
  1370. printf(" 20- Lab6 border tracing\n");
  1371. printf(" 21 - Lab7 dillation\n");
  1372. printf(" 22 - Lab7 erosion\n");
  1373. printf(" 23 - Lab7 opening\n");
  1374. printf(" 24 - Lab7 closing\n");
  1375. printf(" 25 - Lab7 boundary extraction\n");
  1376. printf(" 0 - Exit\n\n");
  1377. printf("Option: ");
  1378. scanf("%d",&op);
  1379. switch (op)
  1380. {
  1381. case 1:
  1382. testOpenImage();
  1383. break;
  1384. case 2:
  1385. testOpenImagesFld();
  1386. break;
  1387. case 3:
  1388. testParcurgereSimplaDiblookStyle(); //diblook style
  1389. break;
  1390. case 4:
  1391. //testColor2Gray();
  1392. testBGR2HSV();
  1393. break;
  1394. case 5:
  1395. testResize();
  1396. break;
  1397. case 6:
  1398. testCanny();
  1399. break;
  1400. case 7:
  1401. testVideoSequence();
  1402. break;
  1403. case 8:
  1404. testSnap();
  1405. break;
  1406. case 9:
  1407. testMouseClick();
  1408. break;
  1409. case 10:
  1410. copy_RGB();
  1411. break;
  1412. case 11:
  1413. convert_to_grayscale();
  1414. break;
  1415. case 12:
  1416. convert_to_binary();
  1417. break;
  1418. case 13:
  1419. compute_HSV();
  1420. break;
  1421. case 14:
  1422. testMouseClick();
  1423. break;
  1424. case 15:
  1425. test_histogram();
  1426. break;
  1427. case 16:
  1428. test_bins_histogram();
  1429. break;
  1430. case 17:
  1431. testThresholding();
  1432. break;
  1433. case 18:
  1434. test_breadth_first_traversal();
  1435. break;
  1436. case 19:
  1437. test_label_two_pass();
  1438. break;
  1439. case 20:
  1440. testBorderTracing();
  1441. break;
  1442. case 21:
  1443. testDillation();
  1444. break;
  1445. case 22:
  1446. testErosion();
  1447. break;
  1448. case 23:
  1449. testOpening();
  1450. break;
  1451. case 24:
  1452. testClosing();
  1453. break;
  1454. case 25:
  1455. testBoundaryExtraction();
  1456. break;
  1457.  
  1458. }
  1459. }
  1460. while (op!=0);
  1461. return 0;
  1462. }
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!