API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 24th, 2019
116
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 56.35 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 <vector>
  7. #include <math.h>
  8. #include <queue>
  9. #include <utility>
  10. #include <unordered_map>
  11. #include <random>
  12. #include <time.h>
  13. #include <fstream>
  14.  
  15. using namespace std;
  16.  
  17.  
  18. #define max(a,b)(((a)>(b))?(a):(b))
  19. #define min(a,b)(((a)<(b))?(a):(b))
  20. int n;
  21.  
  22. int histValues[256];
  23. float normalizedHistoValues[256];
  24. int result[256];
  25.  
  26. void testOpenImage()
  27. {
  28. char fname[MAX_PATH];
  29. while (openFileDlg(fname))
  30. {
  31. Mat src;
  32. src = imread(fname);
  33. imshow("image", src);
  34. waitKey(0);
  35. }
  36. }
  37.  
  38. void testOpenImagesFld()
  39. {
  40. char folderName[MAX_PATH];
  41. if (openFolderDlg(folderName) == 0)
  42. return;
  43. char fname[MAX_PATH];
  44. FileGetter fg(folderName, "bmp");
  45. while (fg.getNextAbsFile(fname))
  46. {
  47. Mat src;
  48. src = imread(fname);
  49. imshow(fg.getFoundFileName(), src);
  50. if (waitKey(0) == 27) //ESC pressed
  51. break;
  52. }
  53. }
  54.  
  55. void testImageOpenAndSave()
  56. {
  57. Mat src, dst;
  58.  
  59. src = imread("Images/Lena_24bits.bmp", CV_LOAD_IMAGE_COLOR); // Read the image
  60.  
  61. if (!src.data) // Check for invalid input
  62. {
  63. printf("Could not open or find the image\n");
  64. return;
  65. }
  66.  
  67. // Get the image resolution
  68. Size src_size = Size(src.cols, src.rows);
  69.  
  70. // Display window
  71. const char* WIN_SRC = "Src"; //window for the source image
  72. namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  73. cvMoveWindow(WIN_SRC, 0, 0);
  74.  
  75. const char* WIN_DST = "Dst"; //window for the destination (processed) image
  76. namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  77. cvMoveWindow(WIN_DST, src_size.width + 10, 0);
  78.  
  79. cvtColor(src, dst, CV_BGR2GRAY); //converts the source image to a grayscale one
  80.  
  81. imwrite("Images/Lena_24bits_gray.bmp", dst); //writes the destination to file
  82.  
  83. imshow(WIN_SRC, src);
  84. imshow(WIN_DST, dst);
  85.  
  86. printf("Press any key to continue ...\n");
  87. waitKey(0);
  88. }
  89.  
  90. void testNegativeImage()
  91. {
  92. char fname[MAX_PATH];
  93. while (openFileDlg(fname))
  94. {
  95. double t = (double)getTickCount(); // Get the current time [s]
  96.  
  97. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  98. int height = src.rows;
  99. int width = src.cols;
  100. Mat dst = Mat(height, width, CV_8UC1);
  101. // Asa se acceseaaza pixelii individuali pt. o imagine cu 8 biti/pixel
  102. // Varianta ineficienta (lenta)
  103. for (int i = 0; i < height; i++)
  104. {
  105. for (int j = 0; j < width; j++)
  106. {
  107. uchar val = src.at<uchar>(i, j);
  108. uchar neg = MAX_PATH - val;
  109. dst.at<uchar>(i, j) = neg;
  110. }
  111. }
  112.  
  113. // Get the current time again and compute the time difference [s]
  114. t = ((double)getTickCount() - t) / getTickFrequency();
  115. // Print (in the console window) the processing time in [ms]
  116. printf("Time = %.3f [ms]\n", t * 1000);
  117.  
  118. imshow("input image", src);
  119. imshow("negative image", dst);
  120. waitKey(0);
  121. }
  122. }
  123.  
  124. void testParcurgereSimplaDiblookStyle()
  125. {
  126. char fname[MAX_PATH];
  127. while (openFileDlg(fname))
  128. {
  129. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  130. int height = src.rows;
  131. int width = src.cols;
  132. Mat dst = src.clone();
  133.  
  134. double t = (double)getTickCount(); // Get the current time [s]
  135.  
  136. // the fastest approach using the “diblook style”
  137. uchar *lpSrc = src.data;
  138. uchar *lpDst = dst.data;
  139. int w = (int)src.step; // no dword alignment is done !!!
  140. for (int i = 0; i < height; i++)
  141. for (int j = 0; j < width; j++) {
  142. uchar val = lpSrc[i*w + j];
  143. lpDst[i*w + j] = 255 - val;
  144. }
  145.  
  146. // Get the current time again and compute the time difference [s]
  147. t = ((double)getTickCount() - t) / getTickFrequency();
  148. // Print (in the console window) the processing time in [ms]
  149. printf("Time = %.3f [ms]\n", t * 1000);
  150.  
  151. imshow("input image", src);
  152. imshow("negative image", dst);
  153. waitKey(0);
  154. }
  155. }
  156.  
  157. void testColor2Gray()
  158. {
  159. char fname[MAX_PATH];
  160. while (openFileDlg(fname))
  161. {
  162. Mat src = imread(fname);
  163.  
  164. int height = src.rows;
  165. int width = src.cols;
  166.  
  167. Mat dst = Mat(height, width, CV_8UC1);
  168.  
  169. // Asa se acceseaaza pixelii individuali pt. o imagine RGB 24 biti/pixel
  170. // Varianta ineficienta (lenta)
  171. for (int i = 0; i < height; i++)
  172. {
  173. for (int j = 0; j < width; j++)
  174. {
  175. Vec3b v3 = src.at<Vec3b>(i, j);
  176. uchar b = v3[0];
  177. uchar g = v3[1];
  178. uchar r = v3[2];
  179. dst.at<uchar>(i, j) = (r + g + b) / 3;
  180. }
  181. }
  182.  
  183. imshow("input image", src);
  184. imshow("gray image", dst);
  185. waitKey(0);
  186. }
  187. }
  188.  
  189. void testBGR2HSV()
  190. {
  191. char fname[MAX_PATH];
  192. while (openFileDlg(fname))
  193. {
  194. Mat src = imread(fname);
  195. int height = src.rows;
  196. int width = src.cols;
  197.  
  198. // Componentele d eculoare ale modelului HSV
  199. Mat H = Mat(height, width, CV_8UC1);
  200. Mat S = Mat(height, width, CV_8UC1);
  201. Mat V = Mat(height, width, CV_8UC1);
  202.  
  203. // definire pointeri la matricele (8 biti/pixeli) folosite la afisarea componentelor individuale H,S,V
  204. uchar* lpH = H.data;
  205. uchar* lpS = S.data;
  206. uchar* lpV = V.data;
  207.  
  208. Mat hsvImg;
  209. cvtColor(src, hsvImg, CV_BGR2HSV);
  210.  
  211. // definire pointer la matricea (24 biti/pixeli) a imaginii HSV
  212. uchar* hsvDataPtr = hsvImg.data;
  213.  
  214. for (int i = 0; i < height; i++)
  215. {
  216. for (int j = 0; j < width; j++)
  217. {
  218. int hi = i * width * 3 + j * 3;
  219. int gi = i * width + j;
  220.  
  221. lpH[gi] = hsvDataPtr[hi] * 510 / 360; // lpH = 0 .. 255
  222. lpS[gi] = hsvDataPtr[hi + 1]; // lpS = 0 .. 255
  223. lpV[gi] = hsvDataPtr[hi + 2]; // lpV = 0 .. 255
  224. }
  225. }
  226.  
  227. imshow("input image", src);
  228. imshow("H", H);
  229. imshow("S", S);
  230. imshow("V", V);
  231.  
  232. waitKey(0);
  233. }
  234. }
  235.  
  236. void testResize()
  237. {
  238. char fname[MAX_PATH];
  239. while (openFileDlg(fname))
  240. {
  241. Mat src;
  242. src = imread(fname);
  243. Mat dst1, dst2;
  244. //without interpolation
  245. resizeImg(src, dst1, 320, false);
  246. //with interpolation
  247. resizeImg(src, dst2, 320, true);
  248. imshow("input image", src);
  249. imshow("resized image (without interpolation)", dst1);
  250. imshow("resized image (with interpolation)", dst2);
  251. waitKey(0);
  252. }
  253. }
  254.  
  255. void testCanny()
  256. {
  257. char fname[MAX_PATH];
  258. while (openFileDlg(fname))
  259. {
  260. Mat src, dst, gauss;
  261. src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  262. double k = 0.4;
  263. int pH = 50;
  264. int pL = (int)k*pH;
  265. GaussianBlur(src, gauss, Size(5, 5), 0.8, 0.8);
  266. Canny(gauss, dst, pL, pH, 3);
  267. imshow("input image", src);
  268. imshow("canny", dst);
  269. waitKey(0);
  270. }
  271. }
  272.  
  273. void testVideoSequence()
  274. {
  275. VideoCapture cap("Videos/rubic.avi"); // off-line video from file
  276. //VideoCapture cap(0); // live video from web cam
  277. if (!cap.isOpened()) {
  278. printf("Cannot open video capture device.\n");
  279. waitKey(0);
  280. return;
  281. }
  282.  
  283. Mat edges;
  284. Mat frame;
  285. char c;
  286.  
  287. while (cap.read(frame))
  288. {
  289. Mat grayFrame;
  290. cvtColor(frame, grayFrame, CV_BGR2GRAY);
  291. Canny(grayFrame, edges, 40, 100, 3);
  292. imshow("source", frame);
  293. imshow("gray", grayFrame);
  294. imshow("edges", edges);
  295. c = cvWaitKey(0); // waits a key press to advance to the next frame
  296. if (c == 27) {
  297. // press ESC to exit
  298. printf("ESC pressed - capture finished\n");
  299. break; //ESC pressed
  300. };
  301. }
  302. }
  303.  
  304.  
  305.  
  306. void testSnap()
  307. {
  308. VideoCapture cap(0); // open the deafult camera (i.e. the built in web cam)
  309. if (!cap.isOpened()) // openenig the video device failed
  310. {
  311. printf("Cannot open video capture device.\n");
  312. return;
  313. }
  314.  
  315. Mat frame;
  316. char numberStr[256];
  317. char fileName[256];
  318.  
  319. // video resolution
  320. Size capS = Size((int)cap.get(CV_CAP_PROP_FRAME_WIDTH),
  321. (int)cap.get(CV_CAP_PROP_FRAME_HEIGHT));
  322.  
  323. // Display window
  324. const char* WIN_SRC = "Src"; //window for the source frame
  325. namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  326. cvMoveWindow(WIN_SRC, 0, 0);
  327.  
  328. const char* WIN_DST = "Snapped"; //window for showing the snapped frame
  329. namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  330. cvMoveWindow(WIN_DST, capS.width + 10, 0);
  331.  
  332. char c;
  333. int frameNum = -1;
  334. int frameCount = 0;
  335.  
  336. for (;;)
  337. {
  338. cap >> frame; // get a new frame from camera
  339. if (frame.empty())
  340. {
  341. printf("End of the video file\n");
  342. break;
  343. }
  344.  
  345. ++frameNum;
  346.  
  347. imshow(WIN_SRC, frame);
  348.  
  349. c = cvWaitKey(10); // waits a key press to advance to the next frame
  350. if (c == 27) {
  351. // press ESC to exit
  352. printf("ESC pressed - capture finished");
  353. break; //ESC pressed
  354. }
  355. if (c == 115) { //'s' pressed - snapp the image to a file
  356. frameCount++;
  357. fileName[0] = NULL;
  358. sprintf(numberStr, "%d", frameCount);
  359. strcat(fileName, "Images/A");
  360. strcat(fileName, numberStr);
  361. strcat(fileName, ".bmp");
  362. bool bSuccess = imwrite(fileName, frame);
  363. if (!bSuccess)
  364. {
  365. printf("Error writing the snapped image\n");
  366. }
  367. else
  368. imshow(WIN_DST, frame);
  369. }
  370. }
  371.  
  372. }
  373.  
  374. void MyCallBackFunc(int event, int x, int y, int flags, void* param)
  375. {
  376.  
  377. Mat* src = (Mat*)param;
  378. if (event == CV_EVENT_LBUTTONDOWN)
  379. {
  380. printf("Pos(x,y): %d,%d Color(RGB): %d,%d,%d\n",
  381. x, y,
  382. (int)(*src).at<Vec3b>(y, x)[2],
  383. (int)(*src).at<Vec3b>(y, x)[1],
  384. (int)(*src).at<Vec3b>(y, x)[0]);
  385. }
  386. }
  387.  
  388. void testMouseClick()
  389. {
  390. Mat src;
  391. // Read image from file
  392. char fname[MAX_PATH];
  393. while (openFileDlg(fname))
  394. {
  395. src = imread(fname);
  396. //Create a window
  397. namedWindow("My Window", 1);
  398.  
  399. //set the callback function for any mouse event
  400. setMouseCallback("My Window", MyCallBackFunc, &src);
  401.  
  402. //show the image
  403. imshow("My Window", src);
  404.  
  405. // Wait until user press some key
  406. waitKey(0);
  407. }
  408. }
  409.  
  410. /* Histogram display function - display a histogram using bars (simlilar to L3 / PI)
  411. Input:
  412. name - destination (output) window name
  413. hist - pointer to the vector containing the histogram values
  414. hist_cols - no. of bins (elements) in the histogram = histogram image width
  415. hist_height - height of the histogram image
  416. Call example:
  417. showHistogram ("MyHist", hist_dir, 255, 200);
  418. */
  419. void showHistogram(const std::string& name, int* hist, const int hist_cols, const int hist_height)
  420. {
  421. Mat imgHist(hist_height, hist_cols, CV_8UC3, CV_RGB(255, 255, 255)); // constructs a white image
  422.  
  423. //computes histogram maximum
  424. int max_hist = 0;
  425. for (int i = 0; i < hist_cols; i++)
  426. if (hist[i] > max_hist)
  427. max_hist = hist[i];
  428. double scale = 1.0;
  429. scale = (double)hist_height / max_hist;
  430. int baseline = hist_height - 1;
  431.  
  432. for (int x = 0; x < hist_cols; x++) {
  433. Point p1 = Point(x, baseline);
  434. Point p2 = Point(x, baseline - cvRound(hist[x] * scale));
  435. line(imgHist, p1, p2, CV_RGB(255, 0, 255)); // histogram bins colored in magenta
  436. }
  437.  
  438. imshow(name, imgHist);
  439. }
  440. void testNegativFrumos()
  441. {
  442. char fname[MAX_PATH];
  443. while (openFileDlg(fname))
  444. {
  445. double t = (double)getTickCount(); // Get the current time [s]
  446.  
  447. Mat src = imread(fname, 1);
  448. int height = src.rows;
  449. int width = src.cols;
  450. Mat dst = Mat(height, width, CV_8UC3);
  451. // Asa se acceseaaza pixelii individuali pt. o imagine cu 8 biti/pixel
  452. // Varianta ineficienta (lenta)
  453. for (int i = 0; i < height; i++)
  454. {
  455. for (int j = 0; j < width; j++)
  456. {
  457. Vec3b pixel = src.at< Vec3b>(i, j);
  458. uchar B = pixel[0];
  459. uchar R = pixel[1];
  460. uchar G = pixel[2];
  461.  
  462. dst.at<Vec3b>(i, j)[0] = 255 - B;
  463. dst.at<Vec3b>(i, j)[1] = 255 - R;
  464. dst.at<Vec3b>(i, j)[2] = 255 - G;
  465. }
  466. }
  467.  
  468. // Get the current time again and compute the time difference [s]
  469. t = ((double)getTickCount() - t) / getTickFrequency();
  470. // Print (in the console window) the processing time in [ms]
  471. printf("Time = %.3f [ms]\n", t * 1000);
  472.  
  473. imshow("input image", src);
  474. imshow("negative image", dst);
  475. waitKey(0);
  476. }
  477. }
  478.  
  479.  
  480.  
  481. void testGrayScaleAdditiveFactor() {
  482. char fname[MAX_PATH];
  483. int factor;
  484. printf("Factor: ");
  485. scanf("%d", &factor);
  486. while (openFileDlg(fname))
  487. {
  488. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  489. int height = src.rows;
  490. int width = src.cols;
  491. Mat dst = Mat(height, width, CV_8UC1);
  492. for (int i = 0; i < height; i++)
  493. {
  494. for (int j = 0; j < width; j++)
  495. {
  496. uchar val = src.at<uchar>(i, j);
  497. int newVal = max(min(val + factor, 255), 0);
  498. dst.at<uchar>(i, j) = (uchar)newVal;
  499. }
  500. }
  501. imshow("input image", src);
  502. imshow("Additive factor image", dst);
  503. waitKey(0);
  504. }
  505. }
  506.  
  507.  
  508. void testGrayScaleMultiplyFactor() {
  509. char fname[MAX_PATH];
  510. int factor;
  511. printf("Factor: ");
  512. scanf("%d", &factor);
  513. while (openFileDlg(fname))
  514. {
  515. //double t = (double)getTickCount(); // Get the current time [s]
  516. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  517. int height = src.rows;
  518. int width = src.cols;
  519. Mat dst = Mat(height, width, CV_8UC1);
  520. for (int i = 0; i < height; i++)
  521. {
  522. for (int j = 0; j < width; j++)
  523. {
  524. uchar val = src.at<uchar>(i, j);
  525. int newVal = max(min(val * factor, 255), 0);
  526. dst.at<uchar>(i, j) = (uchar)newVal;
  527. }
  528. }
  529. //t = ((double)getTickCount() - t) / getTickFrequency();
  530. imshow("input image", src);
  531. imshow("Multiply factor image", dst);
  532. imwrite("D:\\30236\\Teo\\OpenCVApplication-VS2013_OCV2413_basic\\Images\\imaginea_noastra.bmp", dst); //writes the destination to file
  533. waitKey(0);
  534. }
  535. }
  536.  
  537. void Patrate_colorate() {
  538. int rows = 256;
  539. int cols = 256;
  540. int half_row = rows / 2;
  541. int half_col = cols / 2;
  542. Mat src(rows, cols, CV_8UC3);
  543. for (int i = 0; i < rows; i++) {
  544. for (int j = 0; j < cols; j++) {
  545. if (i <= half_row) {
  546. if (j <= half_col) {
  547. //ALB
  548. src.at<Vec3b>(i, j)[0] = 255;
  549. src.at<Vec3b>(i, j)[1] = 255;
  550. src.at<Vec3b>(i, j)[2] = 255;
  551. }
  552. else {
  553. //ROSU
  554. src.at<Vec3b>(i, j)[0] = 0;
  555. src.at<Vec3b>(i, j)[1] = 0;
  556. src.at<Vec3b>(i, j)[2] = 255;
  557. }
  558. }
  559. else {
  560. if (j <= half_col) {
  561. //VERDE
  562. src.at<Vec3b>(i, j)[0] = 0;
  563. src.at<Vec3b>(i, j)[1] = 255;
  564. src.at<Vec3b>(i, j)[2] = 0;
  565. }
  566. else {
  567. //GALBEN
  568. src.at<Vec3b>(i, j)[0] = 0;
  569. src.at<Vec3b>(i, j)[1] = 255;
  570. src.at<Vec3b>(i, j)[2] = 255;
  571. }
  572. }
  573. }
  574. }
  575. imshow("Patrate colorate", src);
  576. imwrite("D:\\30236\\Teo\\OpenCVApplication-VS2013_OCV2413_basic\\Images\\patrateleeeeeeeeeeee.bmp", src); //writes the destination to file
  577. waitKey(0);
  578. }
  579.  
  580.  
  581. void matricica_inv() {
  582. float vals[9];
  583. for (int i = 0; i < 9; i++) {
  584.  
  585. scanf("%f", &vals[i]);
  586.  
  587. }
  588. Mat M(3, 3, CV_32FC1, vals); //stocare date de tip float
  589. Mat inv = M.inv();
  590. std::cout << inv << std::endl;
  591.  
  592. }
  593.  
  594. void split_windows() {
  595. char fname[MAX_PATH];
  596.  
  597. while (openFileDlg(fname))
  598. {
  599.  
  600. Mat img = imread(fname, CV_LOAD_IMAGE_COLOR);
  601. imshow("original image", img);
  602. Mat imR(img.rows, img.cols, CV_8UC1), imG(img.rows, img.cols, CV_8UC1), imB(img.rows, img.cols, CV_8UC1);
  603. for (int i = 0; i < img.rows; i++)
  604. {
  605. for (int j = 0; j < img.cols; j++)
  606. {
  607. imR.at<uchar>(i, j) = img.at<Vec3b>(i, j)[2];
  608. imG.at<uchar>(i, j) = img.at<Vec3b>(i, j)[1];
  609. imB.at<uchar>(i, j) = img.at<Vec3b>(i, j)[0];
  610. }
  611. }
  612. imshow("R", imR);
  613. imshow("G", imG);
  614. imshow("B", imB);
  615. waitKey(0);
  616. }
  617. }
  618. void color_to_grayscale() {
  619. char fname[10000];
  620.  
  621. while (openFileDlg(fname))
  622. {
  623.  
  624. Mat img = imread(fname, CV_LOAD_IMAGE_COLOR);
  625. imshow("original image", img);
  626. Mat imgr(img.rows, img.cols, CV_8UC1);
  627. for (int i = 0; i < img.rows; i++)
  628. {
  629. for (int j = 0; j < img.cols; j++)
  630. {
  631. imgr.at<uchar>(i, j) = (img.at<Vec3b>(i, j)[2] + img.at<Vec3b>(i, j)[1] + img.at<Vec3b>(i, j)[0]) / 3;
  632. }
  633. }
  634. imshow("grayscale", imgr);
  635. waitKey(0);
  636. }
  637. }
  638. void grayscale_to_black_white() {
  639. char fname[10000];
  640. int prag;
  641. printf("Prag: ");
  642. scanf("%d", &prag);
  643.  
  644. while (openFileDlg(fname))
  645. {
  646.  
  647. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  648. imshow("original image", img);
  649. Mat imgr(img.rows, img.cols, CV_8UC1);
  650. for (int i = 0; i < img.rows; i++)
  651. {
  652. for (int j = 0; j < img.cols; j++)
  653. {
  654. if (img.at<uchar>(i, j) > prag) {
  655. imgr.at<uchar>(i, j) = 255;
  656. }
  657. else {
  658. imgr.at<uchar>(i, j) = 0;
  659. }
  660. }
  661. }
  662. imshow("black and white", imgr);
  663. waitKey(0);
  664. }
  665. }
  666. void rgb_to_hsv() {
  667. char fname[10000];
  668. float r, g, b, M, m, C, H, S, V;
  669. while (openFileDlg(fname))
  670. {
  671.  
  672. Mat img = imread(fname, CV_LOAD_IMAGE_COLOR);
  673. imshow("original image", img);
  674. Mat imH(img.rows, img.cols, CV_8UC1), imS(img.rows, img.cols, CV_8UC1), imV(img.rows, img.cols, CV_8UC1);
  675. for (int i = 0; i < img.rows; i++)
  676. {
  677. for (int j = 0; j < img.cols; j++)
  678. {
  679. r = (float)img.at<Vec3b>(i, j)[2] / 255;
  680. g = (float)img.at<Vec3b>(i, j)[1] / 255;
  681. b = (float)img.at<Vec3b>(i, j)[0] / 255;
  682.  
  683. M = max(max(r, g), b);
  684. m = min(min(r, g), b);
  685. C = M - m;
  686.  
  687. V = M;
  688.  
  689. if (V != 0)
  690. S = C / V;
  691. else
  692. S = 0;
  693.  
  694. if (C != 0) {
  695. if (M == r) {
  696. H = 60 * (g - b) / C;
  697. }
  698. if (M == g) {
  699. H = 120 * (b - r) / C;
  700. }
  701. if (M == b) {
  702. H = 240 * (r - g) / C;
  703. }
  704. }
  705. else {
  706. H = 0;
  707. }
  708. if (H < 0) {
  709. H = H + 360;
  710. }
  711.  
  712. imH.at<uchar>(i, j) = H * 255 / 360;
  713. imS.at<uchar>(i, j) = S * 255;
  714. imV.at<uchar>(i, j) = V * 255;
  715. }
  716. }
  717. imshow("H", imH);
  718. imshow("S", imS);
  719. imshow("V", imV);
  720. waitKey(0);
  721. }
  722. }
  723.  
  724. bool isInside(Mat src, int i, int j) {
  725.  
  726. int height = src.rows;
  727. int width = src.cols;
  728.  
  729. if ((i > width) || (i < 0)) {
  730. return false;
  731. }
  732.  
  733. if ((j > height) || (j < 0)) {
  734. return false;
  735. }
  736. return true;
  737.  
  738. }
  739.  
  740. void testIsInside() {
  741.  
  742.  
  743. int i, j;
  744.  
  745. char fname[MAX_PATH];
  746.  
  747. while (openFileDlg(fname))
  748. {
  749. Mat src = imread(fname, CV_LOAD_IMAGE_COLOR);
  750.  
  751. printf("i: ");
  752. scanf("%d", &i);
  753.  
  754.  
  755. printf("j: ");
  756. scanf("%d", &j);
  757.  
  758.  
  759. if (isInside(src, i, j))
  760. printf("Is inside\n");
  761. else printf("Is outside\n");
  762. }
  763.  
  764. }
  765.  
  766. void histogram() {
  767.  
  768. char fname[10000];
  769.  
  770. while (openFileDlg(fname))
  771. {
  772.  
  773. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  774. imshow("original image", img);
  775.  
  776. for (int i = 0; i < img.rows; i++)
  777. {
  778. for (int j = 0; j < img.cols; j++)
  779. {
  780. histValues[img.at<uchar>(i, j)]++;
  781. }
  782. }
  783. showHistogram("MyHist", histValues, 256, 500);
  784. for (int i = 0; i < 256; i++)
  785. {
  786. histValues[i] = 0;
  787. }
  788. }
  789.  
  790. }
  791.  
  792.  
  793. void normalizeHistogram(int* histogram, int size) {
  794.  
  795. for (int i = 0; i < 256; i++)
  796. normalizedHistoValues[i] = (float)histValues[i] / size;
  797.  
  798. }
  799.  
  800. void histo(Mat img, int m, int* &hist) {
  801. hist = new int[m] {};
  802. for (int i = 0; i < img.rows; i++)
  803. for (int j = 0; j < img.cols; j++) {
  804. int bin = (float)img.at<uchar>(i, j) / 256 * m;
  805. hist[bin]++;
  806. }
  807.  
  808.  
  809. }
  810.  
  811. void praguri_multiple() {
  812. int WH = 5;
  813. float TH = 0.0003;
  814. float v;
  815. int dimension = 1;
  816. boolean ok;
  817. char fname[10000];
  818.  
  819. while (openFileDlg(fname))
  820. {
  821.  
  822. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  823. imshow("original image", img);
  824.  
  825. for (int i = 0; i < img.rows; i++)
  826. {
  827. for (int j = 0; j < img.cols; j++)
  828. {
  829. histValues[img.at<uchar>(i, j)]++;
  830. }
  831. }
  832. normalizeHistogram(histValues, img.rows*img.cols);
  833.  
  834. for (int k = 0 + WH; k < 255 - WH; k++) {
  835. v = 0;
  836. ok = true;
  837. for (int i = k - WH; i < k + WH; i++) {
  838. v += normalizedHistoValues[i];
  839. if (normalizedHistoValues[k] < normalizedHistoValues[i]) {
  840. ok = false;
  841. }
  842. }
  843. v = v / (2 * WH + 1);
  844. if (normalizedHistoValues[k] > v + TH && ok) {
  845. result[dimension++] = k;
  846.  
  847. }
  848. }
  849. result[0] = 0;
  850. result[dimension] = 255;
  851. dimension++;
  852. for (int i = 0; i < dimension; i++) {
  853. std::cout << result[i] << "\n" << std::endl;
  854. }
  855.  
  856. for (int i = 0; i < img.rows; i++)
  857. {
  858. for (int j = 0; j < img.cols; j++)
  859. {
  860. int maxx = -1;
  861. for (int k = 0; k < dimension - 1; k++) {
  862. if (img.at<uchar>(i, j) > result[k] && img.at<uchar>(i, j) < result[k + 1]) {
  863. if (img.at<uchar>(i, j) - result[k] < result[k + 1] - img.at<uchar>(i, j)) {
  864. img.at<uchar>(i, j) = result[k];
  865. }
  866. else {
  867. img.at<uchar>(i, j) = result[k + 1];
  868. }
  869. }
  870. }
  871.  
  872. }
  873. }
  874. imshow("praguri_multiple", img);
  875. }
  876. }
  877. uchar limit_value(int value) {
  878. if (value < 0) {
  879. return 0;
  880. }
  881. else if (value > 255) {
  882. return 255;
  883. }
  884. else {
  885. return value;
  886. }
  887. }
  888. void floyd_steinberg() {
  889. int WH = 5;
  890. float TH = 0.0003;
  891. float miu;
  892. int dimension = 1;
  893. boolean ok;
  894. char fname[10000];
  895.  
  896. while (openFileDlg(fname))
  897. {
  898.  
  899. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  900. imshow("original image", img);
  901.  
  902. for (int i = 0; i < img.rows; i++)
  903. {
  904. for (int j = 0; j < img.cols; j++)
  905. {
  906. histValues[img.at<uchar>(i, j)]++;
  907. }
  908. }
  909. normalizeHistogram(histValues, img.rows*img.cols);
  910.  
  911. for (int k = 0 + WH; k < 255 - WH; k++) {
  912. miu = 0;
  913. ok = true;
  914. for (int i = k - WH; i < k + WH; i++) {
  915. miu += normalizedHistoValues[i];
  916. if (normalizedHistoValues[k] < normalizedHistoValues[i])ok = false;
  917. }
  918. miu = miu / (2 * WH + 1);
  919. if (normalizedHistoValues[k] > miu + TH && ok) {
  920. result[dimension++] = k;
  921.  
  922. }
  923. }
  924. result[0] = 0;
  925. result[dimension] = 255;
  926. dimension++;
  927. for (int i = 0; i < dimension; i++) {
  928. std::cout << result[i] << "\n" << std::endl;
  929. }
  930.  
  931. for (int i = 0; i < img.rows - 1; i++)
  932. {
  933. for (int j = 0; j < img.cols - 1; j++)
  934. {
  935. int oldValue = img.at<uchar>(i, j);
  936. int newValue;
  937. float error;
  938. for (int k = 0; k < dimension - 1; k++) {
  939. if (img.at<uchar>(i, j) > result[k] && img.at<uchar>(i, j) < result[k + 1]) {
  940. if (img.at<uchar>(i, j) - result[k] < result[k + 1] - img.at<uchar>(i, j))newValue = result[k];
  941. else newValue = result[k + 1];
  942. }
  943. }
  944. error = oldValue - newValue;
  945.  
  946. img.at<uchar>(i, j) = newValue;
  947. img.at<uchar>(i, j + 1) = img.at<uchar>(i, j + 1) + limit_value((int)(7 * error / 16));
  948. img.at<uchar>(i + 1, j - 1) = img.at<uchar>(i + 1, j - 1) + limit_value((int)(3 * error / 16));
  949. img.at<uchar>(i + 1, j) = img.at<uchar>(i + 1, j) + limit_value((int)(5 * error / 16));
  950. img.at<uchar>(i + 1, j + 1) = img.at<uchar>(i + 1, j + 1) + limit_value((int)(error / 16));
  951.  
  952. }
  953. }
  954. imshow("floyd image", img);
  955.  
  956.  
  957. }
  958. }
  959.  
  960. void onMouse(int event, int x, int y, int flags, void* param)
  961. {
  962. if (event == EVENT_MOUSEMOVE)
  963. {
  964. printf("Mouse move over the window - position (", x, ", ", y, ")");
  965. }
  966. else if (event == EVENT_LBUTTONDOWN)
  967. {
  968. printf("Left button of the mouse is clicked - position (", x, ", ", y, ")");
  969. }
  970. else if (event == EVENT_RBUTTONDOWN)
  971. {
  972. printf("Right button of the mouse is clicked - position (", x, ", ", y, ")");
  973. }
  974. else if (event == EVENT_MBUTTONDOWN)
  975. {
  976. printf("Middle button of the mouse is clicked - position (", x, ", ", y, ")");
  977. }
  978. else if (event == EVENT_LBUTTONUP)
  979. {
  980. printf("Left button of the mouse is released - position (", x, ", ", y, ")");
  981. }
  982. else if (event == EVENT_RBUTTONUP)
  983. {
  984. printf("Right button of the mouse is released - position (", x, ", ", y, ")");
  985. }
  986. else if (event == EVENT_MBUTTONUP)
  987. {
  988. printf("Middle button of the mouse is released - position (", x, ", ", y, ")");
  989. }
  990. else if (event == EVENT_LBUTTONDBLCLK)
  991. {
  992. printf("Middle button of the mouse is double click - position (", x, ", ", y, ")");
  993. }
  994. else if (event == EVENT_RBUTTONDBLCLK)
  995. {
  996. printf("Middle button of the mouse is double click - position (", x, ", ", y, ")");
  997. }
  998. else if (event == EVENT_MBUTTONDBLCLK)
  999. {
  1000. printf("Middle button of the mouse is double click - position (", x, ", ", y, ")");
  1001. }
  1002.  
  1003. }
  1004.  
  1005. void calcAria(int event, int x, int y, int flags, void* param)
  1006. {
  1007.  
  1008. Mat* src = (Mat*)param;
  1009. if (event == CV_EVENT_LBUTTONDOWN)
  1010. {
  1011. int b = (int)(*src).at<Vec3b>(y, x)[0];
  1012. int g = (int)(*src).at<Vec3b>(y, x)[1];
  1013. int r = (int)(*src).at<Vec3b>(y, x)[2];
  1014. int aria = 0;
  1015. for (int i = 0; i < (*src).rows; i++) {
  1016. for (int j = 0; j < (*src).cols; j++) {
  1017. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1018. aria++;
  1019. }
  1020. }
  1021. }
  1022. printf("%d\n", aria);
  1023. }
  1024. }
  1025.  
  1026. void computeAria() {
  1027. Mat src;
  1028. // Read image from file
  1029. char fname[MAX_PATH];
  1030. while (openFileDlg(fname))
  1031. {
  1032. src = imread(fname);
  1033. //Create a window
  1034. namedWindow("My Window", 1);
  1035.  
  1036. //set the callback function for any mouse event
  1037. setMouseCallback("My Window", calcAria, &src);
  1038.  
  1039. //show the image
  1040. imshow("My Window", src);
  1041.  
  1042. // Wait until user press some key
  1043. waitKey(0);
  1044. }
  1045. }
  1046.  
  1047. void calcCentruDeMasa(int event, int x, int y, int flags, void* param)
  1048. {
  1049.  
  1050. Mat* src = (Mat*)param;
  1051. if (event == CV_EVENT_LBUTTONDOWN)
  1052. {
  1053. int b = (int)(*src).at<Vec3b>(y, x)[0];
  1054. int g = (int)(*src).at<Vec3b>(y, x)[1];
  1055. int r = (int)(*src).at<Vec3b>(y, x)[2];
  1056. int aria = 0;
  1057.  
  1058. for (int i = 0; i < (*src).rows; i++) {
  1059. for (int j = 0; j < (*src).cols; j++) {
  1060. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1061. aria++;
  1062. }
  1063. }
  1064. }
  1065. int col = 0, row = 0;
  1066. for (int i = 0; i < (*src).rows; i++) {
  1067. for (int j = 0; j < (*src).cols; j++) {
  1068. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1069. row += i;
  1070. col += j;
  1071. }
  1072. }
  1073. }
  1074.  
  1075. printf("r = %f , c = %f\n", ((float)1 / aria)*row, ((float)1 / aria)*col);
  1076.  
  1077. }
  1078. }
  1079.  
  1080.  
  1081.  
  1082. void computeCentrulDeMasa() {
  1083. Mat src;
  1084. // Read image from file
  1085. char fname[MAX_PATH];
  1086. while (openFileDlg(fname))
  1087. {
  1088. src = imread(fname);
  1089. //Create a window
  1090. namedWindow("My Window", 1);
  1091.  
  1092. //set the callback function for any mouse event
  1093. setMouseCallback("My Window", calcCentruDeMasa, &src);
  1094.  
  1095. //show the image
  1096. imshow("My Window", src);
  1097.  
  1098. // Wait until user press some key
  1099. waitKey(0);
  1100. }
  1101. }
  1102.  
  1103. void ElongationCallBack(int event, int x, int y, int flags, void* param)
  1104. {
  1105. Mat* src = (Mat*)param;
  1106. Mat src1 = *src;
  1107. Vec3b label = 0;
  1108. if (event == CV_EVENT_LBUTTONDOWN)
  1109. {
  1110.  
  1111. label = src1.at<Vec3b>(y, x);
  1112. int area = 0;
  1113. int aux_rows = 0;
  1114. int aux_cols = 0;
  1115. for (int i = 0; i < src1.rows; i++) {
  1116. for (int j = 0; j < src1.cols; j++) {
  1117. if (src1.at<Vec3b>(i, j) == label) {
  1118. area++;
  1119. aux_rows += i;
  1120. aux_cols += j;
  1121. }
  1122.  
  1123. }
  1124.  
  1125. }
  1126. int massX = aux_rows / area;
  1127. int massY = aux_cols / area;
  1128. float tan = 0.0;
  1129. int sum_cols = 0;
  1130. int sum_rows = 0;
  1131. for (int i = 0; i < src1.rows; i++) {
  1132. for (int j = 0; j < src1.cols; j++) {
  1133. if (src1.at<Vec3b>(i, j) == label) {
  1134. tan += (i - massX)*(j - massY);
  1135. sum_cols += (j - massY) ^ 2;
  1136. sum_rows += (i - massX) ^ 2;
  1137. }
  1138.  
  1139. }
  1140.  
  1141. }
  1142. float alfa = atan2(2 * tan, (sum_cols - sum_rows));
  1143. float angle = (alfa * 90) / PI;
  1144. printf("Angle is is %f\n", angle);
  1145. }
  1146.  
  1147. }
  1148.  
  1149. void computeElongation()
  1150. {
  1151. char fname[MAX_PATH];
  1152. while (openFileDlg(fname))
  1153. {
  1154. Mat src;
  1155. src = imread(fname, CV_LOAD_IMAGE_COLOR);
  1156. //Create a window
  1157. namedWindow("My Window", 1);
  1158.  
  1159. //set the callback function for any mouse event
  1160. setMouseCallback("My Window", ElongationCallBack, &src);
  1161.  
  1162. //show the image
  1163. imshow("My Window", src);
  1164.  
  1165. waitKey();
  1166. }
  1167.  
  1168. }
  1169.  
  1170. void computePerimeterCallback(int event, int x, int y, int flags, void* param) {
  1171. Mat* src = (Mat*)param;
  1172. Mat src1 = *src;
  1173. Vec3b label = 0;
  1174. if (event == CV_EVENT_LBUTTONDOWN)
  1175. {
  1176.  
  1177. label = src1.at<Vec3b>(y, x);
  1178. int perimeter = 0;
  1179. for (int i = 0; i < src1.rows; i++) {
  1180. for (int j = 0; j < src1.cols; j++) {
  1181. if (src1.at<Vec3b>(i, j) == label)
  1182. if (src1.at<Vec3b>(i - 1, j) != label | src1.at<Vec3b>(i - 1, j - 1) != label | src1.at<Vec3b>(i - 1, j + 1) != label | src1.at<Vec3b>(i, j + 1) != label
  1183. | src1.at<Vec3b>(i + 1, j - 1) != label | src1.at<Vec3b>(i + 1, j) != label | src1.at<Vec3b>(i + 1, j + 1) != label | src1.at<Vec3b>(i, j - 1) != label)
  1184. {
  1185. perimeter++;
  1186. }
  1187.  
  1188. }
  1189.  
  1190. }
  1191.  
  1192. printf("Perimeter is %d\n", perimeter);
  1193. }
  1194. }
  1195.  
  1196.  
  1197. void computePerimeter() {
  1198. Mat src;
  1199. // Read image from file
  1200. char fname[MAX_PATH];
  1201. while (openFileDlg(fname))
  1202. {
  1203. src = imread(fname);
  1204. //Create a window
  1205. namedWindow("My Window", 1);
  1206.  
  1207. //set the callback function for any mouse event
  1208. setMouseCallback("My Window", computePerimeterCallback, &src);
  1209.  
  1210. //show the image
  1211. imshow("My Window", src);
  1212.  
  1213. // Wait until user press some key
  1214. waitKey(0);
  1215. }
  1216. }
  1217.  
  1218. void computeFactorDesubtiereCallback(int event, int x, int y, int flags, void* param) {
  1219. Mat* src = (Mat*)param;
  1220. Mat src1 = *src;
  1221. Vec3b label = 0;
  1222. if (event == CV_EVENT_LBUTTONDOWN)
  1223. {
  1224.  
  1225. label = src1.at<Vec3b>(y, x);
  1226. int aria = 0;
  1227. for (int i = 0; i < (*src).rows; i++) {
  1228. for (int j = 0; j < (*src).cols; j++) {
  1229. if (label == src1.at<Vec3b>(i, j)) {
  1230. aria++;
  1231. }
  1232. }
  1233. }
  1234. int perimeter = 0;
  1235. for (int i = 0; i < src1.rows; i++) {
  1236. for (int j = 0; j < src1.cols; j++) {
  1237. if (src1.at<Vec3b>(i, j) == label)
  1238. if (src1.at<Vec3b>(i - 1, j) != label | src1.at<Vec3b>(i - 1, j - 1) != label | src1.at<Vec3b>(i - 1, j + 1) != label | src1.at<Vec3b>(i, j + 1) != label
  1239. | src1.at<Vec3b>(i + 1, j - 1) != label | src1.at<Vec3b>(i + 1, j) != label | src1.at<Vec3b>(i + 1, j + 1) != label | src1.at<Vec3b>(i, j - 1) != label)
  1240. {
  1241. perimeter++;
  1242. }
  1243.  
  1244. }
  1245.  
  1246. }
  1247.  
  1248. printf("Factorul de subtiere este %f\n", 4 * PI*((float)aria / (perimeter*perimeter)));
  1249. }
  1250. }
  1251.  
  1252. void computeFactorDeSubtiere() {
  1253. Mat src;
  1254. // Read image from file
  1255. char fname[MAX_PATH];
  1256. while (openFileDlg(fname))
  1257. {
  1258. src = imread(fname);
  1259. //Create a window
  1260. namedWindow("My Window", 1);
  1261.  
  1262. //set the callback function for any mouse event
  1263. setMouseCallback("My Window", computeFactorDesubtiereCallback, &src);
  1264.  
  1265. //show the image
  1266. imshow("My Window", src);
  1267.  
  1268. // Wait until user press some key
  1269. waitKey(0);
  1270. }
  1271. }
  1272.  
  1273. void computeFactorDeAspectCallback(int event, int x, int y, int flags, void* param)
  1274. {
  1275. Mat* src = (Mat*)param;
  1276. Mat src1 = *src;
  1277. Vec3b label = 0;
  1278. int cMax = -255;
  1279. int cMin = 255;
  1280. int rMax = -255;
  1281. int rMin = 255;
  1282.  
  1283. if (event == CV_EVENT_LBUTTONDOWN)
  1284. {
  1285. int b = (int)(*src).at<Vec3b>(y, x)[0];
  1286. int g = (int)(*src).at<Vec3b>(y, x)[1];
  1287. int r = (int)(*src).at<Vec3b>(y, x)[2];
  1288.  
  1289. for (int i = 0; i < (*src).rows; i++) {
  1290. for (int j = 0; j < (*src).cols; j++) {
  1291. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1292. if (i < cMin)
  1293. {
  1294. rMin = i;
  1295. }
  1296. if (i > cMax)
  1297. {
  1298. rMax = i;
  1299. }
  1300. if (j < cMin)
  1301. {
  1302. cMin = j;
  1303. }
  1304. if (j > cMax)
  1305. {
  1306. cMax = j;
  1307. }
  1308. }
  1309. }
  1310. }
  1311.  
  1312. float x = cMax - cMin + 1;
  1313. float y = rMax - rMin + 1;
  1314. printf("%f", x / y);
  1315. }
  1316. }
  1317. void computeFactorulDeAspect() {
  1318. Mat src;
  1319. // Read image from file
  1320. char fname[MAX_PATH];
  1321. while (openFileDlg(fname))
  1322. {
  1323. src = imread(fname);
  1324. //Create a window
  1325. namedWindow("My Window", 1);
  1326.  
  1327. //set the callback function for any mouse event
  1328. setMouseCallback("My Window", computeFactorDeAspectCallback, &src);
  1329.  
  1330. //show the image
  1331. imshow("My Window", src);
  1332.  
  1333. // Wait until user press some key
  1334. waitKey(0);
  1335. }
  1336. }
  1337.  
  1338. void drawContour() {
  1339. Mat src1;
  1340. char fname[MAX_PATH];
  1341. while (openFileDlg(fname))
  1342. {
  1343. src1 = imread(fname);
  1344. Vec3b label = src1.at<Vec3b>(0, 0);
  1345. Mat src(src1.rows, src1.cols, CV_8UC3);
  1346.  
  1347. for (int i = 0; i < src1.rows; i++)
  1348. for (int j = 0; j < src1.cols; j++) {
  1349. src.at<Vec3b>(i, j) = label;
  1350. if (src1.at<Vec3b>(i, j) != label) {
  1351. if (src1.at<Vec3b>(i - 1, j) == label | src1.at<Vec3b>(i - 1, j - 1) == label | src1.at<Vec3b>(i - 1, j + 1) == label | src1.at<Vec3b>(i, j + 1) == label
  1352. | src1.at<Vec3b>(i + 1, j - 1) == label | src1.at<Vec3b>(i + 1, j) == label | src1.at<Vec3b>(i + 1, j + 1) == label | src1.at<Vec3b>(i, j - 1) == label)
  1353. {
  1354. src.at<Vec3b>(i, j) = src1.at<Vec3b>(i, j);
  1355. }
  1356. }
  1357. }
  1358. imshow("nume", src);
  1359. waitKey(0);
  1360. }
  1361. }
  1362. void thAria() {
  1363. Mat src1;
  1364. // Read image from file
  1365. char fname[MAX_PATH];
  1366. while (openFileDlg(fname))
  1367. {
  1368. int th;
  1369. printf("th= ");
  1370. scanf("%d", &th);
  1371. src1 = imread(fname);
  1372. Vec3b label = src1.at<Vec3b>(0, 0);
  1373. Mat src(src1.rows, src1.cols, CV_8UC3);
  1374. int aria[255 + 1000 * 3];
  1375. for (int i = 0; i < 1000; i++)
  1376. aria[i] = 0;
  1377. for (int i = 0; i < (src1).rows; i++) {
  1378. for (int j = 0; j < src1.cols; j++) {
  1379. aria[src1.at<Vec3b>(i, j)[0] + src1.at<Vec3b>(i, j)[1] + src1.at<Vec3b>(i, j)[2]]++;
  1380. }
  1381. }
  1382. for (int i = 0; i < (src1).rows; i++) {
  1383. for (int j = 0; j < src1.cols; j++) {
  1384. if (aria[src1.at<Vec3b>(i, j)[0] + src1.at<Vec3b>(i, j)[1] + src1.at<Vec3b>(i, j)[2]] < th) {
  1385. src.at<Vec3b>(i, j) = src1.at<Vec3b>(i, j);
  1386. }
  1387. }
  1388. }
  1389.  
  1390.  
  1391. imshow("nume", src);
  1392. waitKey(0);
  1393. }
  1394. }
  1395.  
  1396. void imagineSeparata(int event, int x, int y, int flags, void* param) {
  1397. Mat* src = (Mat*)param;
  1398. Vec3b selectedPixel = (Vec3b)(*src).at<Vec3b>(y, x);
  1399.  
  1400.  
  1401. Mat src1 = *src;
  1402. Vec3b label = 0;
  1403.  
  1404.  
  1405. if (event == CV_EVENT_LBUTTONDOWN)
  1406. {
  1407.  
  1408. int rN, cN;
  1409.  
  1410. label = src1.at<Vec3b>(y, x);
  1411. int area = 0;
  1412. int aux_rows = 0;
  1413. int aux_cols = 0;
  1414. for (int i = 0; i < src1.rows; i++) {
  1415. for (int j = 0; j < src1.cols; j++) {
  1416. if (src1.at<Vec3b>(i, j) == label) {
  1417. area++;
  1418. aux_rows += i;
  1419. aux_cols += j;
  1420. }
  1421.  
  1422. }
  1423.  
  1424. }
  1425. int massX = aux_rows / area;
  1426. int massY = aux_cols / area;
  1427. float tan = 0.0;
  1428. int sum_cols = 0;
  1429. int sum_rows = 0;
  1430. for (int i = 0; i < src1.rows; i++) {
  1431. for (int j = 0; j < src1.cols; j++) {
  1432. if (src1.at<Vec3b>(i, j) == label) {
  1433. tan += (i - massX)*(j - massY);
  1434. sum_cols += (j - massY) ^ 2;
  1435. sum_rows += (i - massX) ^ 2;
  1436. }
  1437.  
  1438. }
  1439.  
  1440. }
  1441. float alfa = atan2(2 * tan, (sum_cols - sum_rows));
  1442. float angle = (alfa * 90) / PI;
  1443.  
  1444. int b = (int)(*src).at<Vec3b>(y, x)[0];
  1445. int g = (int)(*src).at<Vec3b>(y, x)[1];
  1446. int r = (int)(*src).at<Vec3b>(y, x)[2];
  1447. int aria = 0;
  1448.  
  1449. for (int i = 0; i < (*src).rows; i++) {
  1450. for (int j = 0; j < (*src).cols; j++) {
  1451. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1452. aria++;
  1453. }
  1454. }
  1455. }
  1456. int col = 0, row = 0;
  1457. for (int i = 0; i < (*src).rows; i++) {
  1458. for (int j = 0; j < (*src).cols; j++) {
  1459. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1460. row += i;
  1461. col += j;
  1462. }
  1463. }
  1464. }
  1465.  
  1466. rN = ((float)1 / aria)*row;
  1467. cN = ((float)1 / aria)*col;
  1468.  
  1469. if (selectedPixel == Vec3b(255, 255, 255)) {
  1470. return;
  1471. }
  1472. Mat img((*src).rows, (*src).cols, CV_8UC3, Scalar(255, 255, 255));
  1473. Vec3b pixelNegru = Vec3b(0, 0, 0);
  1474. for (int i = 1; i < src->rows - 1; i++) {
  1475. for (int j = 1; j < src->cols - 1; j++) {
  1476. if (selectedPixel == (Vec3b)(*src).at<Vec3b>(i, j)) {
  1477. if (selectedPixel != (Vec3b)(*src).at<Vec3b>(i, j - 1) ||
  1478. selectedPixel != (Vec3b)(*src).at<Vec3b>(i, j + 1) ||
  1479. selectedPixel != (Vec3b)(*src).at<Vec3b>(i - 1, j - 1) ||
  1480. selectedPixel != (Vec3b)(*src).at<Vec3b>(i - 1, j + 1) ||
  1481. selectedPixel != (Vec3b)(*src).at<Vec3b>(i - 1, j) ||
  1482. selectedPixel != (Vec3b)(*src).at<Vec3b>(i + 1, j - 1) ||
  1483. selectedPixel != (Vec3b)(*src).at<Vec3b>(i + 1, j + 1) ||
  1484. selectedPixel != (Vec3b)(*src).at<Vec3b>(i + 1, j))
  1485. {
  1486.  
  1487. img.at<Vec3b>(i, j) = pixelNegru;
  1488. }
  1489. }
  1490. if (i == rN && j == cN) {
  1491. img.at<Vec3b>(i, j) = pixelNegru;
  1492. img.at<Vec3b>(i, j - 1) = pixelNegru;
  1493. img.at<Vec3b>(i, j + 1) = pixelNegru;
  1494. img.at<Vec3b>(i - 1, j) = pixelNegru;
  1495. img.at<Vec3b>(i - 1, j - 1) = pixelNegru;
  1496. img.at<Vec3b>(i - 1, j + 1) = pixelNegru;
  1497. img.at<Vec3b>(i + 1, j) = pixelNegru;
  1498. img.at<Vec3b>(i + 1, j - 1) = pixelNegru;
  1499. img.at<Vec3b>(i + 1, j + 1) = pixelNegru;
  1500. }
  1501. }
  1502. }
  1503. Point startPoint(cN, rN);
  1504. Point endPoint(cN + 100 * cos(angle * 180 / CV_PI), rN + 100 * sin(angle * 180 / CV_PI));
  1505. line(img, startPoint, endPoint, Scalar(0, 0, 0), 1);
  1506. imshow("Desen", img);
  1507.  
  1508. // punctul c
  1509. int cmax = -1;
  1510. int cmin = 100000;
  1511. int rmax = -1;
  1512. int rmin = 100000;
  1513. for (int i = 1; i < src->rows - 1; i++) {
  1514. for (int j = 1; j < src->cols - 1; j++) {
  1515. if (selectedPixel == (Vec3b)(*src).at<Vec3b>(i, j)) {
  1516. if (cmax < j) cmax = j;
  1517. if (cmin > j) cmin = j;
  1518. if (rmax < i) rmax = i;
  1519. if (rmin > i) rmin = i;
  1520. }
  1521. }
  1522. }
  1523. int inaltimeP = rmax - rmin;
  1524. int latimeP = cmax - cmin;
  1525. int himg = 2 * inaltimeP + 300;
  1526. int wimg = 2 * latimeP + 300;
  1527. Mat proiectie(himg, wimg, CV_8UC1);
  1528.  
  1529. for (int i = 0; i < src->rows; i++) {
  1530. for (int j = 0; j < src->cols; j++) {
  1531. if (selectedPixel == (Vec3b)(*src).at<Vec3b>(i, j)) {
  1532. proiectie.at<uchar>(himg - (i - rmin + inaltimeP + 200), j - cmin + latimeP + 200) = 0;
  1533. }
  1534. }
  1535. }
  1536.  
  1537. for (int i = 50; i < himg - 50; i++) {
  1538. proiectie.at<uchar>(i, 50) = 0;
  1539. }
  1540. for (int i = 50; i < wimg - 50; i++) {
  1541. proiectie.at<uchar>(himg - 50, i) = 0;
  1542. }
  1543.  
  1544.  
  1545. //imshow("Proiectie", proiectie);
  1546. }
  1547. }
  1548.  
  1549. void computeImagineSeparata() {
  1550. Mat src;
  1551. // Read image from file
  1552. char fname[MAX_PATH];
  1553. while (openFileDlg(fname))
  1554. {
  1555. src = imread(fname);
  1556. //Create a window
  1557. namedWindow("My Window", 1);
  1558.  
  1559. //set the callback function for any mouse event
  1560. setMouseCallback("My Window", imagineSeparata, &src);
  1561.  
  1562. //show the image
  1563. imshow("My Window", src);
  1564.  
  1565. // Wait until user press some key
  1566. waitKey(0);
  1567. }
  1568. }
  1569.  
  1570.  
  1571. void computeHorizontalProjection(int event, int x, int y, int flags, void* param)
  1572. {
  1573.  
  1574. Mat* src = (Mat*)param;
  1575. if (event == CV_EVENT_LBUTTONDOWN)
  1576. {
  1577. int b = (int)(*src).at<Vec3b>(y, x)[0];
  1578. int g = (int)(*src).at<Vec3b>(y, x)[1];
  1579. int r = (int)(*src).at<Vec3b>(y, x)[2];
  1580. int * h = (int *)malloc((*src).rows * sizeof(int));
  1581. int value = 0;
  1582.  
  1583. for (int i = 0; i < (*src).rows; i++) {
  1584. for (int j = 0; j < (*src).cols; j++) {
  1585. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1586. value++;
  1587. }
  1588. }
  1589.  
  1590.  
  1591. h[i] = value;
  1592. }
  1593.  
  1594.  
  1595. printf("%d\n", h);
  1596. }
  1597. }
  1598. void computeHorizontalProjectionCallback() {
  1599. Mat src;
  1600. // Read image from file
  1601. char fname[MAX_PATH];
  1602. while (openFileDlg(fname))
  1603. {
  1604. src = imread(fname);
  1605. //Create a window
  1606. namedWindow("My Window", 1);
  1607.  
  1608. //set the callback function for any mouse event
  1609. setMouseCallback("My Window", computeHorizontalProjection, &src);
  1610.  
  1611. //show the image
  1612. imshow("My Window", src);
  1613.  
  1614. // Wait until user press some key
  1615. waitKey(0);
  1616. }
  1617. }
  1618.  
  1619. void computeVerticalProjection(int event, int x, int y, int flags, void* param)
  1620. {
  1621.  
  1622. Mat* src = (Mat*)param;
  1623. if (event == CV_EVENT_LBUTTONDOWN)
  1624. {
  1625. int b = (int)(*src).at<Vec3b>(y, x)[0];
  1626. int g = (int)(*src).at<Vec3b>(y, x)[1];
  1627. int r = (int)(*src).at<Vec3b>(y, x)[2];
  1628. int * h = (int *)malloc((*src).cols * sizeof(int));
  1629. int value = 0;
  1630.  
  1631. for (int i = 0; i < (*src).rows; i++) {
  1632. for (int j = 0; j < (*src).cols; j++) {
  1633. if ((int)(*src).at<Vec3b>(i, j)[0] == b && (int)(*src).at<Vec3b>(i, j)[1] == g && (int)(*src).at<Vec3b>(y, x)[2] == r) {
  1634. value++;
  1635. }
  1636. }
  1637.  
  1638.  
  1639. h[i] = value;
  1640. }
  1641.  
  1642.  
  1643. printf("%d\n", h);
  1644. }
  1645. }
  1646. void computeVerticalProjectionCallback() {
  1647. Mat src;
  1648. // Read image from file
  1649. char fname[MAX_PATH];
  1650. while (openFileDlg(fname))
  1651. {
  1652. src = imread(fname);
  1653. //Create a window
  1654. namedWindow("My Window", 1);
  1655.  
  1656. //set the callback function for any mouse event
  1657. setMouseCallback("My Window", computeHorizontalProjection, &src);
  1658.  
  1659. //show the image
  1660. imshow("My Window", src);
  1661.  
  1662. // Wait until user press some key
  1663. waitKey(0);
  1664. }
  1665. }
  1666.  
  1667. void Bfs() {
  1668. char fname[MAX_PATH];
  1669.  
  1670. Mat src;
  1671. while (openFileDlg(fname)) {
  1672. src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1673. waitKey();
  1674.  
  1675. int label = 0;
  1676. Mat labels = Mat::zeros(src.rows, src.cols, CV_32SC1);
  1677. Mat destinatie = Mat::zeros(src.rows, src.cols, CV_8UC3);
  1678.  
  1679. int di[8] = { -1, 0, 1, 0, 1, -1, 1, -1 };
  1680. int dj[8] = { 0, -1, 0, 1, 1, 1, -1, -1 };
  1681. int ni = 0;
  1682. int nj = 0;
  1683.  
  1684. for (int i = 0; i < src.rows; i++) {
  1685. for (int j = 0; j < src.cols; j++) {
  1686. if (src.at<uchar>(i, j) == 0 && labels.at<int>(i, j) == 0) {
  1687. label++;
  1688. std::queue<Point2i> Q;
  1689. labels.at<int>(i, j) = label;
  1690. Q.push({ i, j });
  1691. while (!Q.empty()) {
  1692. Point2i p = Q.front();
  1693. Q.pop();
  1694. for (int k = 0; k < 8; k++) {
  1695. ni = p.x + di[k];
  1696. nj = p.y + dj[k];
  1697. if (!(ni < 0 || ni >= src.rows || nj < 0 || nj >= src.cols)
  1698. && labels.at<int>(ni, nj) == 0 && src.at<uchar>(ni, nj) == 0) {
  1699. labels.at<int>(ni, nj) = label;
  1700. Q.push({ ni, nj });
  1701.  
  1702. }
  1703. }
  1704. }
  1705. }
  1706. }
  1707. }
  1708.  
  1709.  
  1710. std::vector<Vec3b> culori = std::vector<Vec3b>(label);
  1711.  
  1712. std::default_random_engine gen;
  1713. std::uniform_int_distribution<int> d(0, 255);
  1714. for (int i = 0; i < label; i++) {
  1715. uchar r = d(gen);
  1716. uchar g = d(gen);
  1717. uchar b = d(gen);
  1718. culori.at(i) = Vec3b(r, g, b);
  1719. }
  1720.  
  1721. for (int i = 0; i < src.rows; i++) {
  1722. for (int j = 0; j < src.cols; j++) {
  1723. if (labels.at<int>(i, j) > 0) {
  1724. destinatie.at<Vec3b>(i, j) = culori.at(labels.at<int>(i, j) - 1);
  1725. }
  1726. else {
  1727. destinatie.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
  1728. }
  1729. }
  1730. }
  1731.  
  1732.  
  1733. imshow("imagine", destinatie);
  1734. waitKey(0);
  1735. }
  1736. }
  1737.  
  1738.  
  1739. void douaTreceri() {
  1740. char fname[MAX_PATH];
  1741. openFileDlg(fname);
  1742. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1743.  
  1744. waitKey();
  1745. Mat labels = Mat::zeros(src.rows, src.cols, CV_32SC1);
  1746. Mat dstP = Mat::zeros(src.rows, src.cols, CV_8UC3);
  1747. Mat dstF = Mat::zeros(src.rows, src.cols, CV_8UC3);
  1748.  
  1749. int di[8] = { -1, 0, 1, 0, 1, -1, 1, -1 };
  1750. int dj[8] = { 0, -1, 0, 1, 1, 1, -1, -1 };
  1751. int label = 1;
  1752.  
  1753. for (int i = 0; i < src.rows; i++) {
  1754. for (int j = 0; j < src.cols; j++) {
  1755. if (src.at<uchar>(i, j) != 255) {
  1756. labels.at<int>(i, j) = label;
  1757. label++;
  1758. }
  1759. else
  1760. labels.at<int>(i, j) = 0;
  1761. }
  1762. }
  1763.  
  1764. for (int i = 0; i < src.rows; i++) {
  1765. for (int j = 0; j < src.cols; j++) {
  1766. if (labels.at<int>(i, j) != 0) {
  1767. int smallest = labels.at<int>(i, j);
  1768. for (int k = 0; k < 8; k++) {
  1769. if (smallest > labels.at<int>(i + di[k], j + dj[k]) && labels.at<int>(i + di[k], j + dj[k]) != 0) {
  1770. smallest = labels.at<int>(i + di[k], j + dj[k]);
  1771. }
  1772. }
  1773. labels.at<int>(i, j) = smallest;
  1774. }
  1775. }
  1776. }
  1777.  
  1778. std::vector<Vec3b> culori = std::vector<Vec3b>(label);
  1779. std::default_random_engine gen;
  1780. std::uniform_int_distribution<int> d(0, 255);
  1781. for (int i = 0; i < label; i++) {
  1782. uchar r = d(gen);
  1783. uchar g = d(gen);
  1784. uchar b = d(gen);
  1785. culori.at(i) = Vec3b(r, g, b);
  1786. }
  1787.  
  1788. for (int i = 0; i < src.rows; i++) {
  1789. for (int j = 0; j < src.cols; j++) {
  1790. if (labels.at<int>(i, j) > 0) {
  1791. dstP.at<Vec3b>(i, j) = culori.at(labels.at<int>(i, j) - 1);
  1792. }
  1793. else {
  1794. dstP.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
  1795. }
  1796. }
  1797. }
  1798. for (int i = src.rows - 1; i >= 0; i--) {
  1799. for (int j = src.cols - 1; j >= 0; j--) {
  1800. if (labels.at<int>(i, j) != 0) {
  1801. int smallest = labels.at<int>(i, j);
  1802. for (int k = 0; k < 8; k++) {
  1803. if (smallest > labels.at<int>(i + di[k], j + dj[k]) && labels.at<int>(i + di[k], j + dj[k]) != 0) {
  1804. smallest = labels.at<int>(i + di[k], j + dj[k]);
  1805. }
  1806. }
  1807. labels.at<int>(i, j) = smallest;
  1808. }
  1809. }
  1810. }
  1811.  
  1812. for (int i = 0; i < label; i++) {
  1813. uchar r = d(gen);
  1814. uchar g = d(gen);
  1815. uchar b = d(gen);
  1816. culori.at(i) = Vec3b(r, g, b);
  1817. }
  1818.  
  1819. for (int i = 0; i < src.rows; i++) {
  1820. for (int j = 0; j < src.cols; j++) {
  1821. if (labels.at<int>(i, j) > 0) {
  1822. dstF.at<Vec3b>(i, j) = culori.at(labels.at<int>(i, j) - 1);
  1823. }
  1824. else {
  1825. dstF.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
  1826. }
  1827. }
  1828. }
  1829. imshow("Partial", dstP);
  1830. imshow("Final", dstF);
  1831. waitKey(0);
  1832.  
  1833. }
  1834.  
  1835.  
  1836. void contur(Mat img) {
  1837. int difX[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  1838. int difY[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  1839. int dir = 7;
  1840. vector<pair<int, int>> P;
  1841. vector<int> dirs;
  1842. for (int i = 0; i < img.rows; i++) {
  1843. for (int j = 0; j < img.cols; j++) {
  1844. if (img.at<uchar>(i, j) == 0) {
  1845. P.push_back(make_pair(i, j));
  1846. goto exit_label;
  1847. }
  1848. }
  1849. }
  1850. exit_label:
  1851. while (1) {
  1852. dir % 2 == 0 ? dir = (dir + 7) % 8 : dir = (dir + 6) % 8;
  1853. for (int i = 0; i < 8; i++) {
  1854. int ndir = (dir + i) % 8;
  1855. int nx = difX[ndir] + P[P.size() - 1].first;
  1856. int ny = difY[ndir] + P[P.size() - 1].second;
  1857. if (nx >= 0 && ny >= 0 && nx <= img.rows && ny <= img.cols) {
  1858. if (img.at<uchar>(nx, ny) == 0) {
  1859. dir = ndir;
  1860. P.push_back(make_pair(nx, ny));
  1861. dirs.push_back(ndir);
  1862. break;
  1863. }
  1864. }
  1865. }
  1866. if (P[P.size() - 1] == P[0]) {
  1867. break;
  1868. }
  1869. }
  1870.  
  1871. Mat newImg(img.rows, img.cols, CV_8UC1, Scalar(255));
  1872. for (auto& it : P) {
  1873. newImg.at<uchar>(it.first, it.second) = 0;
  1874. }
  1875. for (auto& it : dirs) {
  1876. cout << it << " ";
  1877. }
  1878. vector<int> derivata;
  1879. cout << "\n\n\n";
  1880. for (int i = 1; i < dirs.size(); i++) {
  1881. derivata.push_back(((dirs[i - 1] - dirs[i]) % 8 + 8) % 8);
  1882. cout << derivata[i - 1]<<" ";
  1883. }
  1884.  
  1885. imshow("contur", newImg);
  1886. waitKey(0);
  1887. }
  1888.  
  1889. void reconstruct() {
  1890. char fname[MAX_PATH];
  1891. openFileDlg(fname);
  1892. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1893. int difX[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  1894. int difY[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  1895. ifstream f("reconstruct.txt");
  1896. int x, y, n;
  1897. f >> x >> y >> n;
  1898. img.at<uchar>(x, y) = 0;
  1899. int dir;
  1900. for (int i = 0; i < n; i++) {
  1901. f >> dir;
  1902. int nx = x + difX[dir];
  1903. int ny = y + difY[dir];
  1904. if (nx >= 0 && ny >= 0 && nx < img.rows && ny < img.cols) {
  1905. img.at<uchar>(nx, ny) = 0;
  1906. }
  1907. x = nx;
  1908. y = ny;
  1909. }
  1910.  
  1911. imshow("rec", img);
  1912. waitKey(0);
  1913. }
  1914.  
  1915. Mat dilatare(Mat img, int n) {
  1916.  
  1917. Mat aux = img.clone();
  1918. int di[4] = { 0, -1, 0, 1 };
  1919. int dj[4] = { 1, 0, -1, 0 };
  1920.  
  1921. for (int i = 1; i < img.rows - 1; i++)
  1922. for (int j = 1; j < img.cols - 1; j++)
  1923. if (img.at<uchar>(i, j) == 0)
  1924. {
  1925. for (int k = 0; k < 4; k++)
  1926. aux.at<uchar>(i + di[k], j + dj[k]) = 0;
  1927. }
  1928.  
  1929. if (n == 1)
  1930. return aux;
  1931. else
  1932. return dilatare(aux, n - 1);
  1933. }
  1934.  
  1935. Mat erodare(Mat img, int n) {
  1936. Mat aux = Mat(img.rows, img.cols, CV_8UC1, Scalar(255));
  1937.  
  1938. int di[4] = { 0, -1, 0, 1 };
  1939. int dj[4] = { 1, 0, -1, 0 };
  1940.  
  1941. for (int i = 1; i < img.rows - 1; i++)
  1942. for (int j = 1; j < img.cols - 1; j++)
  1943.  
  1944. if (img.at<uchar>(i, j) == 0)
  1945. {
  1946. bool ok = true;
  1947. for (int k = 0; k < 4; k++)
  1948. if (img.at<uchar>(i + di[k], j + dj[k]) != 0)
  1949. {
  1950. ok = false;
  1951. break;
  1952. }
  1953.  
  1954.  
  1955. if (ok)
  1956. aux.at<uchar>(i, j) = 0;
  1957. }
  1958.  
  1959. if (n == 1)
  1960. return aux;
  1961. else
  1962. return erodare(aux, n - 1);
  1963. }
  1964.  
  1965. Mat deschidere(Mat img) {
  1966. Mat aux = erodare(img, 1);
  1967. return dilatare(aux, 1);
  1968. }
  1969.  
  1970. Mat inchidere(Mat img) {
  1971. Mat aux = dilatare(img, 1);
  1972. return erodare(aux, 1);
  1973. }
  1974.  
  1975. void conturMorfologic() {
  1976. char fname[MAX_PATH];
  1977. openFileDlg(fname);
  1978. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1979. imshow("Imagine initiala", img);
  1980.  
  1981. Mat aux = erodare(img, 1);
  1982. Mat rez = Mat(img.rows, img.cols, CV_8UC1, Scalar(255));
  1983.  
  1984. for (int i = 1; i < img.rows - 1; i++)
  1985. for (int j = 1; j < img.cols - 1; j++)
  1986. if (img.at<uchar>(i, j) == 0 && aux.at<uchar>(i, j) != 0)
  1987. rez.at<uchar>(i, j) = 0;
  1988.  
  1989. imshow("Contur", rez);
  1990. waitKey(0);
  1991. }
  1992.  
  1993. void umplere() {
  1994. char fname[MAX_PATH];
  1995. openFileDlg(fname);
  1996. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1997. Mat rez = Mat(img.rows, img.cols, CV_8UC1, Scalar(255));
  1998. rez.at<uchar>(img.rows / 2, img.cols / 2) = 0;
  1999.  
  2000. Mat aux; bool ready;
  2001. int di[4] = { 0, -1, 0, 1 };
  2002. int dj[4] = { 1, 0, -1, 0 };
  2003.  
  2004. do {
  2005. rez.copyTo(aux);
  2006.  
  2007. ready = true;
  2008. for (int i = 1; i < rez.rows - 1; i++)
  2009. for (int j = 1; j < rez.cols - 1; j++)
  2010. if (rez.at<uchar>(i, j) == 0)
  2011. {
  2012. for (int k = 0; k < 4; k++)
  2013. if (aux.at<uchar>(i + di[k], j + dj[k]) != 0 && img.at<uchar>(i + di[k], j + dj[k]) != 0) {
  2014. aux.at<uchar>(i + di[k], j + dj[k]) = 0;
  2015. ready = false;
  2016. }
  2017.  
  2018. }
  2019. aux.copyTo(rez);
  2020.  
  2021. } while (!ready);
  2022.  
  2023. for (int i = 1; i < img.rows - 1; i++)
  2024. for (int j = 1; j < img.cols - 1; j++)
  2025. if (img.at<uchar>(i, j) == 0)
  2026. rez.at<uchar>(i, j) = 0;
  2027.  
  2028. imshow("Normal image", img);
  2029. imshow("Umplere", rez);
  2030. waitKey(0);
  2031. }
  2032.  
  2033. /////////lab 8 ////////
  2034.  
  2035.  
  2036. int * histo(Mat &img) {
  2037. //char fname[MAX_PATH];
  2038. //openFileDlg(fname);
  2039. //Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2040.  
  2041. int *h = new int[256]();
  2042.  
  2043. for (int i = 0; i < img.rows; i++)
  2044. for (int j = 0; j < img.cols; j++) {
  2045. uchar g = img.at<uchar>(i, j);
  2046. h[g]++;
  2047. }
  2048.  
  2049. showHistogram("histo", h, 256, 500);
  2050. return h;
  2051. waitKey(0);
  2052. }
  2053.  
  2054. void medie() {
  2055. char fname[MAX_PATH];
  2056. openFileDlg(fname);
  2057. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2058. int *a = histo(img);
  2059.  
  2060. float p[256] = { 0 };
  2061.  
  2062. int M = img.rows*img.cols;
  2063. for (int g = 0; g < 256; g++) {
  2064. p[g] = ((float)a[g] / M);
  2065. }
  2066.  
  2067. float medie = 0;
  2068.  
  2069. for (int g = 0; g < 256; g++) {
  2070. medie += g * p[g];
  2071. }
  2072.  
  2073. printf("Medie=%.2f \n", medie);
  2074.  
  2075.  
  2076. float var = 0;
  2077.  
  2078.  
  2079.  
  2080. for (int g = 0; g < 256; g++) {
  2081. var += (g - medie)*(g - medie)*p[g];
  2082. }
  2083.  
  2084. float sigma = sqrt(var);
  2085. printf("Deviatie=%.2f \n", sigma);
  2086.  
  2087.  
  2088. getchar();
  2089. getchar();
  2090. getchar();
  2091. }
  2092.  
  2093.  
  2094. float calc_sum(int *hist, int min, int max) {
  2095. float sum = 0;
  2096. int number = 0;
  2097. for (int i = min; i < max; i++) {
  2098. sum += i * hist[i];
  2099. number += hist[i];
  2100. }
  2101. return sum / number;
  2102. }
  2103.  
  2104.  
  2105. void binarizare() {
  2106. char fname[MAX_PATH];
  2107. openFileDlg(fname);
  2108. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2109. int *a = histo(img);
  2110.  
  2111. int imax = 0;
  2112. int imin = 255;
  2113.  
  2114. for (int i = 0; i < 256; i++) {
  2115. if (a[i] != 0) {
  2116. imin = i;
  2117. break;
  2118. }
  2119.  
  2120. }
  2121.  
  2122. for (int i = 255; i > 0; i--) {
  2123. if (a[i] != 0) {
  2124. imax = i;
  2125. break;
  2126. }
  2127.  
  2128. }
  2129.  
  2130.  
  2131. float t1 = (imax + imin) / 2;
  2132. float t2 = 0.0;
  2133.  
  2134. while (t1 - t2 >= 5) {
  2135. int ug1 = calc_sum(a, 0, t1);
  2136. int ug2 = calc_sum(a, t1, 256);
  2137.  
  2138. t1 = t2;
  2139.  
  2140. t2 = (ug1 + ug2) / 2;
  2141.  
  2142. }
  2143.  
  2144.  
  2145.  
  2146. Mat dst = Mat(img.rows, img.cols, CV_8UC1);
  2147.  
  2148. for (int i = 0; i < img.rows; i++)
  2149. {
  2150. for (int j = 0; j < img.cols; j++)
  2151. {
  2152. if (img.at<uchar>(i, j) < t2) {
  2153. dst.at<uchar>(i, j) = 0;
  2154. }
  2155. else {
  2156. dst.at<uchar>(i, j) = 255;
  2157. }
  2158. }
  2159. }
  2160.  
  2161.  
  2162.  
  2163.  
  2164. imshow("dst", dst);
  2165. imshow("img", img);
  2166. waitKey(0);
  2167.  
  2168. }
  2169.  
  2170. void latire_ingustare() {
  2171.  
  2172. char fname[MAX_PATH];
  2173. openFileDlg(fname);
  2174. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2175. int *a = histo(img);
  2176.  
  2177. Mat cont = img.clone();
  2178. int goutmin, goutmax;
  2179. printf("Introduceti goutmin si g outmax: ");
  2180. scanf("%d %d", &goutmin, &goutmax);
  2181.  
  2182.  
  2183. int imax = 0;
  2184. int imin = 255;
  2185.  
  2186. for (int i = 0; i < 256; i++) {
  2187. if (a[i] != 0) {
  2188. imin = i;
  2189. break;
  2190. }
  2191.  
  2192. }
  2193.  
  2194. for (int i = 255; i > 0; i--) {
  2195. if (a[i] != 0) {
  2196. imax = i;
  2197. break;
  2198. }
  2199.  
  2200. }
  2201.  
  2202. Mat contrast = img.clone();
  2203.  
  2204. float factor = (imax - imin);
  2205. for (int i = 0; i < img.rows; i++)
  2206. for (int j = 0; j < img.cols; j++) {
  2207. float aux = goutmin + (img.at<uchar>(i, j) - imin)*(goutmax - goutmin) / factor;
  2208. contrast.at<uchar>(i, j) = (int)aux;
  2209. }
  2210. imshow("src", img);
  2211. imshow("Contrast", contrast);
  2212. waitKey(0);
  2213.  
  2214. }
  2215.  
  2216.  
  2217. void corectie_gama() {
  2218.  
  2219. char fname[MAX_PATH];
  2220. openFileDlg(fname);
  2221. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2222. int *a = histo(img);
  2223.  
  2224. Mat gama = img.clone();
  2225. float gamma;
  2226. printf("introduceti gamma: ");
  2227. scanf("%f", &gamma);
  2228.  
  2229. for (int i = 0; i < img.rows; i++)
  2230. for (int j = 0; j < img.cols; j++) {
  2231. float aux = pow((float)img.at<uchar>(i, j) / 255, gamma) * 255;
  2232. gama.at<uchar>(i, j) = (int)aux;
  2233. }
  2234.  
  2235. imshow("img", img);
  2236. imshow("gama", gama);
  2237. waitKey(0);
  2238.  
  2239. }
  2240.  
  2241. void modificare_luminozitate() {
  2242. char fname[MAX_PATH];
  2243. openFileDlg(fname);
  2244. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2245. int *a = histo(img);
  2246.  
  2247. Mat lumino = img.clone();
  2248. float luminozitate;
  2249. printf("introduceti luminozitate: ");
  2250. scanf("%f", &luminozitate);
  2251.  
  2252. for (int i = 0; i < img.rows; i++)
  2253. for (int j = 0; j < img.cols; j++) {
  2254. float aux = img.at<uchar>(i, j) + luminozitate;
  2255. if (aux > 255) {
  2256. aux = 255;
  2257. }
  2258. lumino.at<uchar>(i, j) = (int)aux;
  2259. }
  2260.  
  2261. imshow("img", img);
  2262. imshow("gama", lumino);
  2263. waitKey(0);
  2264. }
  2265.  
  2266. int main()
  2267. {
  2268. int op;
  2269. do
  2270. {
  2271. system("cls");
  2272. destroyAllWindows();
  2273. printf("Menu:\n");
  2274. printf(" 1 - Open image\n");
  2275. printf(" 2 - Open BMP images from folder\n");
  2276. printf(" 3 - Image negative - diblook style\n");
  2277. printf(" 4 - BGR->HSV\n");
  2278. printf(" 5 - Resize image\n");
  2279. printf(" 6 - Canny edge detection\n");
  2280. printf(" 7 - Edges in a video sequence\n");
  2281. printf(" 8 - Snap frame from live video\n");
  2282. printf(" 9 - Mouse callback demo\n");
  2283. printf(" 0 - Exit\n");
  2284. printf(" 10 - teo\n");
  2285. printf(" 11 - ale\n");
  2286. printf(" 12 - multi\n");
  2287. printf(" 13 - color\n");
  2288. printf(" 14 - INV\n");
  2289. printf(" 15 - Split windows\n");
  2290. printf(" 16 - Color to grayscale\n");
  2291. printf(" 17 - Grayscale to black white\n");
  2292. printf(" 18 - RGB->HSV\n");
  2293. printf(" 19 - isInside\n");
  2294. printf(" 20 - histogram\n");
  2295. printf(" 21 - praguri_multiple\n");
  2296. printf(" 22 - floyd_steinberg\n");
  2297. printf(" 24 - aria\n");
  2298. printf(" 25 - centru de masa\n");
  2299. printf(" 26 - axa de alungire\n");
  2300. printf(" 27 - perimetru\n");
  2301. printf(" 28 - factorul de subtiere al obiectului\n");
  2302. printf(" 29 - imagine Separata\n");
  2303. printf(" 30 - aria+phi\n");
  2304. printf(" 31 - proiectie orizontala\n");
  2305. printf(" 32 - proiectie verticala\n");
  2306. printf(" 33 - BFS\n");
  2307. printf(" 34 - douatreceri\n");
  2308. printf(" 35 - urmarire a conturului\n");
  2309. printf(" 36 - reconstruct\n");
  2310.  
  2311. printf(" 37 - dilatare\n");
  2312. printf(" 38 - erodare\n");
  2313. printf(" 39 - deschidere\n");
  2314. printf(" 40 - inchidere\n");
  2315. printf(" 41 - contur\n");
  2316. printf(" 42 - umplere\n");
  2317. printf(" 44 - medie\n");
  2318. printf(" 45 - contrast\n");
  2319. printf(" 46 - gama\n");
  2320. printf(" 47 - luminozitate\n");
  2321. printf(" 0 - Exit\n");
  2322. printf("Option: ");
  2323. scanf("%d", &op);
  2324. Mat img;
  2325. switch (op)
  2326. {
  2327. case 1:
  2328. testOpenImage();
  2329. break;
  2330. case 2:
  2331. testOpenImagesFld();
  2332. break;
  2333. case 3:
  2334. testParcurgereSimplaDiblookStyle(); //diblook style
  2335. break;
  2336. case 4:
  2337. //testColor2Gray();
  2338. testBGR2HSV();
  2339. break;
  2340. case 5:
  2341. testResize();
  2342. break;
  2343. case 6:
  2344. testCanny();
  2345. break;
  2346. case 7:
  2347. testVideoSequence();
  2348. break;
  2349. case 8:
  2350. testSnap();
  2351. break;
  2352. case 9:
  2353. testMouseClick();
  2354. break;
  2355. case 10:
  2356. testNegativFrumos();
  2357. break;
  2358. case 11:
  2359. testGrayScaleAdditiveFactor();
  2360. break;
  2361. case 12:
  2362. testGrayScaleMultiplyFactor();
  2363. break;
  2364. case 13:
  2365. Patrate_colorate();
  2366. break;
  2367. case 14:
  2368. matricica_inv();
  2369. break;
  2370. case 15:
  2371. split_windows();
  2372. break;
  2373. case 16:
  2374. color_to_grayscale();
  2375. break;
  2376. case 17:
  2377. grayscale_to_black_white();
  2378. break;
  2379. case 18:
  2380. rgb_to_hsv();
  2381. break;
  2382. case 19:
  2383. testIsInside();
  2384. break;
  2385. case 20:
  2386. histogram();
  2387. break;
  2388. case 21:
  2389. praguri_multiple();
  2390. break;
  2391. case 22:
  2392. floyd_steinberg();
  2393. break;
  2394. case 23:
  2395. testIsInside();
  2396. break;
  2397. case 24:
  2398. computeAria();
  2399. break;
  2400. case 25:
  2401. computeCentrulDeMasa();
  2402. break;
  2403. case 26:
  2404. computeElongation();
  2405. break;
  2406. case 27:
  2407. computePerimeter();
  2408. break;
  2409. case 28:
  2410. computeFactorDeSubtiere();
  2411. break;
  2412. case 29:
  2413. computeImagineSeparata();
  2414. break;
  2415. case 30:
  2416. thAria();
  2417. break;
  2418. case 31:
  2419. computeHorizontalProjectionCallback();
  2420. break;
  2421. case 32:
  2422. computeVerticalProjectionCallback();
  2423. break;
  2424. case 33:
  2425. Bfs();
  2426. case 34:
  2427. douaTreceri();
  2428. case 35:
  2429. img = imread("Images/oval_vert.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  2430. contur(img);
  2431. break;
  2432. case 36:
  2433. //img = imread("Images/oval_vert.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  2434. reconstruct();
  2435. break;
  2436. case 37:
  2437. printf("n= ");
  2438. scanf("%d", &n);
  2439.  
  2440. char fname[MAX_PATH];
  2441. openFileDlg(fname);
  2442. img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2443.  
  2444.  
  2445. imshow("Imagine normala", img);
  2446.  
  2447. imshow("Imagine dilatata", dilatare(img, n));
  2448. waitKey(0);
  2449. break;
  2450. case 38:
  2451. printf("n= ");
  2452. scanf("%d", &n);
  2453.  
  2454. //char fname[MAX_PATH];
  2455. openFileDlg(fname);
  2456. img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2457.  
  2458. //img = imread("imagini_op_morfologice_lab7/Imagini_Op_Morfologice/3_Open/cel4thr3_bw.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  2459. imshow("Imagine normala", img);
  2460.  
  2461. imshow("Imagine erodata", erodare(img, n));
  2462. waitKey(0);
  2463. break;
  2464. case 39:
  2465. openFileDlg(fname);
  2466. img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2467. imshow("Imagine normala", img);
  2468.  
  2469. imshow("Deschidere", deschidere(img));
  2470. waitKey(0);
  2471. break;
  2472. case 40:
  2473. openFileDlg(fname);
  2474. img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2475. imshow("Imagine normala", img);
  2476.  
  2477. imshow("Inchidere", inchidere(img));
  2478. waitKey(0);
  2479. break;
  2480. case 41:
  2481. conturMorfologic();
  2482. case 42:
  2483. umplere();
  2484. case 43:
  2485. binarizare();
  2486. case 44:
  2487. medie();
  2488. case 45:
  2489. latire_ingustare();
  2490. case 46:
  2491. corectie_gama();
  2492. case 47:
  2493. modificare_luminozitate();
  2494.  
  2495.  
  2496.  
  2497. }
  2498. } while (op != 0);
  2499. return 0;
  2500. }
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!