API tools faq
paste
Advertisement
Guest User

Untitled

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