API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 28th, 2017
51
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.86 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 <math.h>
  7. #include <queue>
  8. #include <vector>
  9. #include <random>
  10.  
  11. void testOpenImage()
  12. {
  13. char fname[MAX_PATH];
  14. while (openFileDlg(fname))
  15. {
  16. Mat src;
  17. src = imread(fname);
  18. imshow("image", src);
  19. waitKey();
  20. }
  21. }
  22.  
  23. void testOpenImagesFld()
  24. {
  25. char folderName[MAX_PATH];
  26. if (openFolderDlg(folderName) == 0)
  27. return;
  28. char fname[MAX_PATH];
  29. FileGetter fg(folderName, "bmp");
  30. while (fg.getNextAbsFile(fname))
  31. {
  32. Mat src;
  33. src = imread(fname);
  34. imshow(fg.getFoundFileName(), src);
  35. if (waitKey() == 27) //ESC pressed
  36. break;
  37. }
  38. }
  39.  
  40.  
  41. void testResize()
  42. {
  43. char fname[MAX_PATH];
  44. while (openFileDlg(fname))
  45. {
  46. Mat src;
  47. src = imread(fname);
  48. Mat dst1, dst2;
  49. //without interpolation
  50. resizeImg(src, dst1, 320, false);
  51. //with interpolation
  52. resizeImg(src, dst2, 320, true);
  53. imshow("input image", src);
  54. imshow("resized image (without interpolation)", dst1);
  55. imshow("resized image (with interpolation)", dst2);
  56. waitKey();
  57. }
  58. }
  59.  
  60.  
  61. void testVideoSequence()
  62. {
  63. VideoCapture cap("Videos/rubic.avi"); // off-line video from file
  64. //VideoCapture cap(0); // live video from web cam
  65. if (!cap.isOpened()) {
  66. printf("Cannot open video capture device.\n");
  67. waitKey(0);
  68. return;
  69. }
  70.  
  71. Mat edges;
  72. Mat frame;
  73. char c;
  74.  
  75. while (cap.read(frame))
  76. {
  77. Mat grayFrame;
  78. cvtColor(frame, grayFrame, CV_BGR2GRAY);
  79. imshow("source", frame);
  80. imshow("gray", grayFrame);
  81. c = cvWaitKey(0); // waits a key press to advance to the next frame
  82. if (c == 27) {
  83. // press ESC to exit
  84. printf("ESC pressed - capture finished\n");
  85. break; //ESC pressed
  86. };
  87. }
  88. }
  89.  
  90.  
  91. void testSnap()
  92. {
  93. VideoCapture cap(0); // open the deafult camera (i.e. the built in web cam)
  94. if (!cap.isOpened()) // openenig the video device failed
  95. {
  96. printf("Cannot open video capture device.\n");
  97. return;
  98. }
  99.  
  100. Mat frame;
  101. char numberStr[256];
  102. char fileName[256];
  103.  
  104. // video resolution
  105. Size capS = Size((int)cap.get(CV_CAP_PROP_FRAME_WIDTH),
  106. (int)cap.get(CV_CAP_PROP_FRAME_HEIGHT));
  107.  
  108. // Display window
  109. const char* WIN_SRC = "Src"; //window for the source frame
  110. namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  111. cvMoveWindow(WIN_SRC, 0, 0);
  112.  
  113. const char* WIN_DST = "Snapped"; //window for showing the snapped frame
  114. namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  115. cvMoveWindow(WIN_DST, capS.width + 10, 0);
  116.  
  117. char c;
  118. int frameNum = -1;
  119. int frameCount = 0;
  120.  
  121. for (;;)
  122. {
  123. cap >> frame; // get a new frame from camera
  124. if (frame.empty())
  125. {
  126. printf("End of the video file\n");
  127. break;
  128. }
  129.  
  130. ++frameNum;
  131.  
  132. imshow(WIN_SRC, frame);
  133.  
  134. c = cvWaitKey(10); // waits a key press to advance to the next frame
  135. if (c == 27) {
  136. // press ESC to exit
  137. printf("ESC pressed - capture finished");
  138. break; //ESC pressed
  139. }
  140. if (c == 115){ //'s' pressed - snapp the image to a file
  141. frameCount++;
  142. fileName[0] = NULL;
  143. sprintf(numberStr, "%d", frameCount);
  144. strcat(fileName, "Images/A");
  145. strcat(fileName, numberStr);
  146. strcat(fileName, ".bmp");
  147. bool bSuccess = imwrite(fileName, frame);
  148. if (!bSuccess)
  149. {
  150. printf("Error writing the snapped image\n");
  151. }
  152. else
  153. imshow(WIN_DST, frame);
  154. }
  155. }
  156.  
  157. }
  158.  
  159. void MyCallBackFunc(int event, int x, int y, int flags, void* param)
  160. {
  161. //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  162. Mat* src = (Mat*)param;
  163. if (event == CV_EVENT_LBUTTONDOWN)
  164. {
  165. printf("Pos(x,y): %d,%d Color(RGB): %d,%d,%d\n",
  166. x, y,
  167. (int)(*src).at<Vec3b>(y, x)[2],
  168. (int)(*src).at<Vec3b>(y, x)[1],
  169. (int)(*src).at<Vec3b>(y, x)[0]);
  170. }
  171. }
  172.  
  173. void testMouseClick()
  174. {
  175. Mat src;
  176. // Read image from file
  177. char fname[MAX_PATH];
  178. while (openFileDlg(fname))
  179. {
  180. src = imread(fname);
  181. //Create a window
  182. namedWindow("My Window", 1);
  183.  
  184. //set the callback function for any mouse event
  185. setMouseCallback("My Window", MyCallBackFunc, &src);
  186.  
  187. //show the image
  188. imshow("My Window", src);
  189.  
  190. // Wait until user press some key
  191. waitKey(0);
  192. }
  193. }
  194.  
  195. /* Histogram display function - display a histogram using bars (simlilar to L3 / PI)
  196. Input:
  197. name - destination (output) window name
  198. hist - pointer to the vector containing the histogram values
  199. hist_cols - no. of bins (elements) in the histogram = histogram image width
  200. hist_height - height of the histogram image
  201. Call example:
  202. showHistogram ("MyHist", hist_dir, 255, 200);
  203. */
  204. void showHistogram(const string& name, int* hist, const int hist_cols, const int hist_height)
  205. {
  206. Mat imgHist(hist_height, hist_cols, CV_8UC3, CV_RGB(255, 255, 255)); // constructs a white image
  207.  
  208. //computes histogram maximum
  209. int max_hist = 0;
  210. for (int i = 0; i<hist_cols; i++)
  211. if (hist[i] > max_hist)
  212. max_hist = hist[i];
  213. double scale = 1.0;
  214. scale = (double)hist_height / max_hist;
  215. int baseline = hist_height - 1;
  216.  
  217. for (int x = 0; x < hist_cols; x++) {
  218. Point p1 = Point(x, baseline);
  219. Point p2 = Point(x, baseline - cvRound(hist[x] * scale));
  220. line(imgHist, p1, p2, CV_RGB(255, 0, 255)); // histogram bins colored in magenta
  221. }
  222.  
  223. imshow(name, imgHist);
  224. }
  225. /******* Lab 1*******/
  226. void negate_image(){
  227. Mat img = imread("Images/cameraman.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  228. for (int i = 0; i < img.rows; i++){
  229. for (int j = 0; j < img.cols; j++){
  230. img.at<uchar>(i, j) = 255 - img.at<uchar>(i, j);
  231.  
  232. }
  233. }
  234. imshow("negative image", img);
  235. waitKey();
  236. }
  237. #define ADDITIVE_CONSTANT 100
  238. void addGrayLevels(){
  239. Mat img = imread("Images/cameraman.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  240. Mat dest = Mat(img.size(), CV_8UC1);
  241. for (int i = 0; i < img.rows; i++){
  242. for (int j = 0; j < img.cols; j++){
  243. dest.at<uchar>(i, j) = (img.at<uchar>(i, j) + ADDITIVE_CONSTANT) % 255;
  244.  
  245. }
  246. }
  247. imshow("src image", img);
  248. imshow("dest image", dest);
  249. waitKey();
  250. }
  251. #define MULTIPLICATIVE_CONSTANT 50
  252. void multiplyGrayLevels(){
  253. Mat img = imread("Images/cameraman.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  254. Mat dest = Mat(img.size(), CV_8UC1);
  255. for (int i = 0; i < img.rows; i++){
  256. for (int j = 0; j < img.cols; j++){
  257. dest.at<uchar>(i, j) = (img.at<uchar>(i, j) * MULTIPLICATIVE_CONSTANT) % 255;
  258.  
  259. }
  260. }
  261. imshow("src image", img);
  262. imshow("dest image", dest);
  263. waitKey();
  264. }
  265.  
  266. //funtion that creates a colored image of 4 squares: white, red, green, yellow
  267. void createColouredImage(){
  268. Vec3b WHITE = { 255, 255, 255 };
  269. Vec3b RED = { 0, 0, 255 };
  270. Vec3b GREEN = { 0, 255, 0 };
  271. Vec3b YELLOW = { 0, 255, 255 };
  272. Mat img = Mat(256, 256, CV_8UC3);
  273. //white square
  274. for (int i = 0; i < img.rows / 2; i++){
  275. for (int j = 0; j < img.cols / 2; j++){
  276. img.at<Vec3b>(i, j) = WHITE;
  277. }
  278. for (int j = img.cols / 2; j < img.cols; j++){
  279. img.at<Vec3b>(i, j) = RED;
  280. }
  281. }
  282. for (int i = img.rows / 2; i < img.rows; i++){
  283. for (int j = 0; j < img.cols / 2; j++){
  284. img.at<Vec3b>(i, j) = GREEN;
  285. }
  286. for (int j = img.cols / 2; j < img.cols; j++){
  287. img.at<Vec3b>(i, j) = YELLOW;
  288. }
  289. }
  290. imshow("coloured image", img);
  291. waitKey();
  292. }
  293. //function that displays only a circle from the given image
  294. int R = 100;
  295. void displayCircle(){
  296. Mat img = imread("Images/cameraman.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  297. Mat dest = Mat(img.size(), CV_8UC1);
  298. int centerI = img.rows / 2;
  299. int centerJ = img.cols / 2;
  300. for (int i = 0; i < img.rows; i++){
  301. for (int j = 0; j < img.cols; j++){
  302. if (((centerI - i)*(centerI - i) + (centerJ - j)*(centerJ - j)) < R*R){
  303. dest.at<uchar>(i, j) = img.at<uchar>(i, j);
  304. }
  305. else{
  306. dest.at<uchar>(i, j) = 0;
  307. }
  308.  
  309. }
  310. }
  311. imshow("src image", img);
  312. imshow("dest image", dest);
  313. waitKey();
  314. }
  315.  
  316. void flip(){
  317. Mat img = imread("Images/cameraman.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  318. Mat dest = Mat(img.size(), CV_8UC1);
  319. for (int i = 0; i < img.rows; i++){
  320. for (int j = 0; j < img.cols; j++){
  321. dest.at<uchar>(i, j) = img.at<uchar>(i, img.cols - j - 1);
  322. }
  323. }
  324. imshow("src image", img);
  325. imshow("dest image", dest);
  326. waitKey();
  327. }
  328. /*LABORATORY 2 WORK*/
  329. void convertToGreyscale(){
  330. char fname[MAX_PATH];
  331. while (openFileDlg(fname))
  332. {
  333. Mat img = imread(fname, CV_LOAD_IMAGE_COLOR);
  334. Mat dest = Mat(img.size(), CV_8UC1);
  335. for (int i = 0; i < img.rows; i++){
  336. for (int j = 0; j < img.cols; j++){
  337. Vec3b pixel = img.at<Vec3b>(i, j);
  338. unsigned char B = pixel[0];
  339. unsigned char G = pixel[1];
  340. unsigned char R = pixel[2];
  341. dest.at<uchar>(i, j) = (B + G + R) / 3;
  342. }
  343. }
  344. imshow("src image", img);
  345. imshow("dest image", dest);
  346. waitKey();
  347. }
  348. }
  349. void displayRedGreenBlueImages(){
  350. char fname[MAX_PATH];
  351. while (openFileDlg(fname))
  352. {
  353. Mat img = imread(fname, CV_LOAD_IMAGE_COLOR);
  354. Mat red = Mat(img.size(), CV_8UC1);
  355. Mat green = Mat(img.size(), CV_8UC1);
  356. Mat blue = Mat(img.size(), CV_8UC1);
  357. for (int i = 0; i < img.rows; i++){
  358. for (int j = 0; j < img.cols; j++){
  359. Vec3b pixel = img.at<Vec3b>(i, j);
  360. unsigned char B = pixel[0];
  361. unsigned char G = pixel[1];
  362. unsigned char R = pixel[2];
  363. red.at<uchar>(i, j) = R;
  364. green.at<uchar>(i, j) = B;
  365. blue.at<uchar>(i, j) = G;
  366. }
  367. }
  368. imshow("src image", img);
  369. imshow("red image", red);
  370. imshow("green image", green);
  371. imshow("blue image", blue);
  372. waitKey();
  373. }
  374. }
  375.  
  376. void treshholding(){
  377.  
  378. uchar threshHoldValue;
  379. printf("Introduce threshhold value\n");
  380. std::cin >> threshHoldValue;
  381. char fname[MAX_PATH];
  382. while (openFileDlg(fname))
  383. {
  384. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  385. Mat dest = Mat(src.size(), CV_8UC1);
  386. for (int i = 0; i < src.rows; i++){
  387. for (int j = 0; j < src.cols; j++){
  388. uchar pixelValue = src.at<uchar>(i, j);
  389. if (pixelValue < threshHoldValue){
  390. dest.at<uchar>(i, j) = 0;//black
  391. }
  392. else{
  393. dest.at<uchar>(i, j) = 255;//white
  394. }
  395. }
  396. }
  397. imshow("src image", src);
  398. imshow("dest image", dest);
  399. waitKey();
  400. }
  401. }
  402. void convertRgbToHSV(unsigned char R, unsigned char G, unsigned char B, unsigned char *H_unsigned_char, unsigned char *S_unsigned_char, unsigned char *V_unsigned_char){
  403. //conversion
  404. float r = (float)R / 255; // r : componenta R normalizata
  405. float g = (float)G / 255; // g : componenta G normalizata
  406. float b = (float)B / 255; // b : componenta B normalizata
  407. // Atentie declarati toate variabilele pe care le folositi de tip float
  408. // Daca ati declarat R de tip uchar, trebuie sa faceti cast: r = (float)R/255 !!!
  409. float M = max(max(r, g), b);
  410. float m = min(min(r, g), b);
  411. float C = M - m;
  412. //value
  413. float V = M;
  414. //saturation
  415. float S;
  416. if (C)
  417. S = C / V;
  418. else // grayscale
  419. S = 0;
  420. //hue
  421. float H;
  422. if (C) {
  423. if (M == r) H = 60 * (g - b) / C;
  424. if (M == g) H = 120 + 60 * (b - r) / C;
  425. if (M == b) H = 240 + 60 * (r - g) / C;
  426. }
  427. else // grayscale
  428. H = 0;
  429. if (H < 0)
  430. H = H + 360;
  431. *H_unsigned_char = (H * 255) / 360;
  432. *S_unsigned_char = S * 255;
  433. *V_unsigned_char = V * 255;
  434. }
  435. void convertToHSV(){
  436. char fname[MAX_PATH];
  437. while (openFileDlg(fname))
  438. {
  439. Mat img = imread(fname, CV_LOAD_IMAGE_COLOR);
  440. Mat hMat = Mat(img.size(), CV_8UC1);
  441. Mat sMat = Mat(img.size(), CV_8UC1);
  442. Mat vMat = Mat(img.size(), CV_8UC1);
  443. for (int i = 0; i < img.rows; i++){
  444. for (int j = 0; j < img.cols; j++){
  445. Vec3b pixel = img.at<Vec3b>(i, j);
  446. unsigned char B = pixel[0];
  447. unsigned char G = pixel[1];
  448. unsigned char R = pixel[2];
  449. unsigned char H;
  450. unsigned char S;
  451. unsigned char V;
  452. convertRgbToHSV(R, G, B, &H, &S, &V);
  453. hMat.at<uchar>(i, j) = H;
  454. sMat.at<uchar>(i, j) = S;
  455. vMat.at<uchar>(i, j) = V;
  456. }
  457. }
  458. imshow("src image", img);
  459. imshow("h image", hMat);
  460. imshow("s image", sMat);
  461. imshow("v image", vMat);
  462. waitKey();
  463. }
  464. }
  465.  
  466. void drawHistogram(){
  467. int noOfBins = 255;
  468. int * h = (int*)malloc(noOfBins * sizeof(int));
  469. for (int i = 0; i < noOfBins; i++){
  470. h[i] = 0;
  471. }
  472. char fname[MAX_PATH];
  473. while (openFileDlg(fname))
  474. {
  475. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  476. Mat dest = Mat(src.size(), CV_8UC1);
  477. for (int i = 0; i < src.rows; i++){
  478. for (int j = 0; j < src.cols; j++){
  479. uchar pixelValue = src.at<uchar>(i, j);
  480. h[pixelValue] ++;
  481. }
  482. }
  483. imshow("src image", src);
  484. showHistogram("histogram", h, noOfBins, 255);
  485. //imshow("dest image", dest);
  486. waitKey();
  487. }
  488. }
  489.  
  490. int * calculateHistogram(Mat src, int noOfBins){
  491. int * h = (int*)malloc(noOfBins * sizeof(int));
  492. for (int i = 0; i < noOfBins; i++){
  493. h[i] = 0;
  494. }
  495. for (int i = 0; i < src.rows; i++){
  496. for (int j = 0; j < src.cols; j++){
  497. uchar pixelValue = src.at<uchar>(i, j);
  498. h[pixelValue] ++;
  499. }
  500. }
  501. return h;
  502. }
  503.  
  504. float * normalizeHistogram(int histogram[], int imageHight, int imageWidth, int noOfBins){
  505. float M = imageHight*imageWidth;
  506. float * f = (float*)malloc(noOfBins * sizeof(float));
  507. for (int i = 0; i < noOfBins; i++){
  508. f[i] = ((float)histogram[i]) / M;
  509. }
  510. return f;
  511. }
  512.  
  513. int* getNearestHistogramMaximums(int maxims[], int noOfMaxims){
  514. int * result = (int*)malloc(255 * sizeof(int));
  515. int prevMiddleIndex = 0;
  516. for (int i = 0; i < noOfMaxims - 1; i++){
  517. int middleIndex = (maxims[i + 1] - maxims[i]) / 2 + maxims[i];
  518. for (int j = prevMiddleIndex; j < middleIndex; j++){
  519. result[j] = prevMiddleIndex;
  520. }
  521. prevMiddleIndex = middleIndex;
  522. }
  523. return result;
  524. }
  525.  
  526. void multilevelThresholding(){
  527.  
  528. char fname[MAX_PATH];
  529. while (openFileDlg(fname))
  530. {
  531. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  532. Mat dest = Mat(src.size(), CV_8UC1);
  533.  
  534. //STEP1: Determine local maximas
  535. int * h = calculateHistogram(src, 255);
  536. float * pdf = normalizeHistogram(h, src.rows, src.cols, 255);
  537. int * localMaxims = (int*)malloc(255 * sizeof(int));
  538. localMaxims[0] = 0;
  539. int localMaxIndex = 1;
  540.  
  541. int WH = 5;
  542. float windowWidth = 2 * WH + 1;
  543. float TH = 0.0003;
  544. for (int k = 0 + WH; k <= 255 - WH; k++){
  545. boolean isBiggerThanAllValues = true;
  546. float v = 0;
  547. //histogram values in range[k-WH,k+WH]
  548. for (int i = k - WH; i <= k + WH; i++){
  549. v += pdf[i];
  550. if (pdf[k] < pdf[i]){
  551. isBiggerThanAllValues = false;
  552. }
  553. }
  554. //compute average value in the interval
  555. v = v / windowWidth;
  556. if (isBiggerThanAllValues&&pdf[k] > v + TH){
  557. localMaxims[localMaxIndex] = k;
  558. localMaxIndex++;
  559. }
  560. }
  561. localMaxims[localMaxIndex] = 255;
  562. localMaxIndex++;
  563.  
  564. //STEP2: Thresholding
  565. int * nearMaxs = getNearestHistogramMaximums(localMaxims, localMaxIndex);
  566. for (int i = 0; i < src.rows; i++){
  567. for (int j = 0; j < src.cols; j++){
  568. uchar pixelValue = src.at<uchar>(i, j);
  569. dest.at<uchar>(i, j) = nearMaxs[pixelValue];
  570. }
  571. }
  572. imshow("src image", src);
  573. imshow("dest image", dest);
  574. waitKey();
  575. }
  576. }
  577.  
  578. uchar addUchar(uchar a, uchar b){
  579. int sum = a + b;
  580. if (sum > 255){
  581. return 255;
  582. }
  583. if (sum < 0){
  584. return 0;
  585. }
  586. return sum;
  587. }
  588. void floydSteinberg(){
  589. char fname[MAX_PATH];
  590. while (openFileDlg(fname))
  591. {
  592. Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  593. Mat dest = Mat(src.size(), CV_8UC1);
  594.  
  595. //STEP1: Determine local maximas
  596. int * h = calculateHistogram(src, 255);
  597. float * pdf = normalizeHistogram(h, src.rows, src.cols, 255);
  598. int * localMaxims = (int*)malloc(255 * sizeof(int));
  599. localMaxims[0] = 0;
  600. int localMaxIndex = 1;
  601.  
  602. int WH = 5;
  603. float windowWidth = 2 * WH + 1;
  604. float TH = 0.0003;
  605. for (int k = 0 + WH; k <= 255 - WH; k++){
  606. boolean isBiggerThanAllValues = true;
  607. float v = 0;
  608. //histogram values in range[k-WH,k+WH]
  609. for (int i = k - WH; i <= k + WH; i++){
  610. v += pdf[i];
  611. if (pdf[k] < pdf[i]){
  612. isBiggerThanAllValues = false;
  613. }
  614. }
  615. //compute average value in the interval
  616. v = v / windowWidth;
  617.  
  618. if (isBiggerThanAllValues&&pdf[k] > v + TH){
  619. localMaxims[localMaxIndex] = k;
  620. std::cout << localMaxims[localMaxIndex] << std::endl;
  621. localMaxIndex++;
  622. }
  623. }
  624. localMaxims[localMaxIndex] = 255;
  625. localMaxIndex++;
  626.  
  627. //STEP2: Thresholding
  628. int * nearMaxs = getNearestHistogramMaximums(localMaxims, localMaxIndex);
  629. for (int i = 0; i < src.rows; i++){
  630. for (int j = 0; j < src.cols; j++){
  631. uchar pixelValue = src.at<uchar>(i, j);
  632. uchar newPixel = nearMaxs[pixelValue];
  633. src.at<uchar>(i, j) = newPixel;
  634. uchar error = pixelValue - newPixel;
  635. if (j + 1 < src.cols){
  636. src.at<uchar>(i, j + 1) = addUchar(src.at<uchar>(i, j + 1), 7 * error / 16);
  637. //src.at<uchar>(i, j+1) += 7*error/16;
  638. if (i + 1 < src.rows){
  639. src.at<uchar>(i + 1, j + 1) = addUchar(src.at<uchar>(i + 1, j + 1), error / 16);
  640. //src.at<uchar>(i+1,j+1) += error / 16;
  641. }
  642. }
  643. if (i + 1 < src.rows){
  644. //src.at<uchar>(i + 1, j) += 5 * error / 16;
  645. src.at<uchar>(i + 1, j) = addUchar(src.at<uchar>(i + 1, j), 5 * error / 16);
  646.  
  647. if (j - 1 >= 0){
  648. //src.at<uchar>(i + 1, j - 1) += 3 * error / 16;
  649. src.at<uchar>(i + 1, j - 1) = addUchar(src.at<uchar>(i + 1, j - 1), 3 * error / 16);
  650. }
  651. }
  652. }
  653. }
  654. imshow("src image", src);
  655. waitKey();
  656. }
  657. }
  658.  
  659. /********* Laboratory 3******************/
  660.  
  661.  
  662. int getArea(Mat src, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel){
  663. int sum = 0;
  664. for (int i = 0; i < src.rows; i++){
  665. for (int j = 0; j < src.cols; j++){
  666. Vec3b pixel = src.at<Vec3b>(i, j);
  667. unsigned char B = pixel[0];
  668. unsigned char G = pixel[1];
  669. unsigned char R = pixel[2];
  670. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  671. sum++;
  672. }
  673. }
  674. }
  675. return sum;
  676. }
  677. int * getCenterOfMass(Mat src, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel, int area){
  678. int * result = (int*)malloc(2 * sizeof(int));
  679. int centerOfMassX = 0;
  680. int centerOfMassY = 0;
  681. for (int i = 0; i < src.rows; i++){
  682. for (int j = 0; j < src.cols; j++){
  683. Vec3b pixel = src.at<Vec3b>(i, j);
  684. unsigned char B = pixel[0];
  685. unsigned char G = pixel[1];
  686. unsigned char R = pixel[2];
  687. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  688. centerOfMassX += i;
  689. centerOfMassY += j;
  690. }
  691. }
  692. }
  693. centerOfMassX = centerOfMassX / area;
  694. centerOfMassY = centerOfMassY / area;
  695. result[0] = centerOfMassX;
  696. result[1] = centerOfMassY;
  697. return result;
  698. }
  699.  
  700. float getElongationAxisAngle(Mat src, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel, int * centerOfmass){
  701. float nominator = 0;
  702. float denominator = 0;
  703.  
  704. for (int i = 0; i < src.rows; i++){
  705. for (int j = 0; j < src.cols; j++){
  706. Vec3b pixel = src.at<Vec3b>(i, j);
  707. unsigned char B = pixel[0];
  708. unsigned char G = pixel[1];
  709. unsigned char R = pixel[2];
  710. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  711. nominator += (i - centerOfmass[0])*(j - centerOfmass[1]);
  712. denominator += (j - centerOfmass[1])*(j - centerOfmass[1]) - (i - centerOfmass[0])*(i - centerOfmass[0]);
  713. }
  714. }
  715. }
  716. nominator *= 2;
  717. if (nominator == 0 && denominator == 0){
  718. return PI / 2.0;
  719. }
  720. float angleRad = atan2(nominator, denominator);
  721. float angleDeg = (angleRad * 180) / PI;
  722. printf("Angle of elongation axis %f\n", angleDeg);
  723. return angleRad;
  724. }
  725. boolean isPointOnPerimeter(Mat src, int i, int j, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel){
  726. Vec3b pixel;
  727. if (i - 1 >= 0){
  728. pixel = src.at<Vec3b>(i - 1, j);
  729. if (pixel[2] != R_chosenPixel || pixel[1] != G_chosenPixel || pixel[0] != B_chosenPixel){
  730. return true;
  731. }
  732. }
  733. if (i + 1 < src.rows){
  734. pixel = src.at<Vec3b>(i + 1, j);
  735. if (pixel[2] != R_chosenPixel || pixel[1] != G_chosenPixel || pixel[0] != B_chosenPixel){
  736. return true;
  737. }
  738. }
  739. if (j - 1 >= 0){
  740. pixel = src.at<Vec3b>(i, j - 1);
  741. if (pixel[2] != R_chosenPixel || pixel[1] != G_chosenPixel || pixel[0] != B_chosenPixel){
  742. return true;
  743. }
  744. }
  745. if (j + 1 < src.cols){
  746. pixel = src.at<Vec3b>(i, j + 1);
  747. if (pixel[2] != R_chosenPixel || pixel[1] != G_chosenPixel || pixel[0] != B_chosenPixel){
  748. return true;
  749. }
  750. }
  751. return false;
  752. }
  753. int getPerimeter(Mat src, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel){
  754. int sum = 0;
  755. for (int i = 0; i < src.rows; i++){
  756. for (int j = 0; j < src.cols; j++){
  757. Vec3b pixel = src.at<Vec3b>(i, j);
  758. unsigned char B = pixel[0];
  759. unsigned char G = pixel[1];
  760. unsigned char R = pixel[2];
  761. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  762. if (isPointOnPerimeter(src, i, j, R, G, B)){
  763. sum++;
  764. }
  765. }
  766. }
  767. }
  768. return sum;
  769. }
  770.  
  771. float getThinessRatio(int area, int perimiter){
  772. return 4 * PI *((float)area) / ((float)(perimiter*perimiter));
  773. }
  774.  
  775. int* getHorizontalProjection(Mat src, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel){
  776. int * h = (int *)malloc(src.rows*sizeof(int));
  777. for (int i = 0; i < src.rows; i++){
  778. int value = 0;
  779. for (int j = 0; j < src.cols; j++){
  780. Vec3b pixel = src.at<Vec3b>(i, j);
  781. unsigned char B = pixel[0];
  782. unsigned char G = pixel[1];
  783. unsigned char R = pixel[2];
  784. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  785. value++;
  786. }
  787. }
  788. h[i] = value;
  789. }
  790. return h;
  791. }
  792.  
  793. int* getVerticalProjection(Mat src, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel){
  794. int * v = (int *)malloc(src.cols*sizeof(int));
  795. for (int i = 0; i < src.cols; i++){
  796. int value = 0;
  797. for (int j = 0; j < src.rows; j++){
  798. Vec3b pixel = src.at<Vec3b>(j, i);
  799. unsigned char B = pixel[0];
  800. unsigned char G = pixel[1];
  801. unsigned char R = pixel[2];
  802. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  803. value++;
  804. }
  805. }
  806. v[i] = value;
  807. }
  808. return v;
  809. }
  810.  
  811. float getAspectRatio(Mat src, unsigned char R_chosenPixel, unsigned char G_chosenPixel, unsigned char B_chosenPixel){
  812. int cMax = 0;
  813. int cMin = src.cols;
  814. int rMax = 0;
  815. int rMin = src.rows;
  816. for (int i = 0; i < src.rows; i++){
  817. for (int j = 0; j < src.cols; j++){
  818. Vec3b pixel = src.at<Vec3b>(i, j);
  819. unsigned char B = pixel[0];
  820. unsigned char G = pixel[1];
  821. unsigned char R = pixel[2];
  822. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  823. if (i < cMin) cMin = i;
  824. if (i > cMax) cMax = i;
  825. if (j < cMin) cMin = j;
  826. if (j > cMax) cMax = j;
  827. }
  828. }
  829. }
  830. float a = cMax - cMin + 1;
  831. float b = rMax - rMin + 1;
  832. return a / b;
  833. }
  834.  
  835. void calculateDetailsForObject(int event, int x, int y, int flags, void* param){
  836. //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  837. Mat* src = (Mat*)param;
  838. Mat dest = (*src).clone();
  839. unsigned char G_chosenPixel;
  840. unsigned char B_chosenPixel;
  841. unsigned char R_chosenPixel;
  842. if (event == CV_EVENT_LBUTTONDOWN)
  843. {
  844.  
  845. B_chosenPixel = (unsigned char)(*src).at<Vec3b>(y, x)[0],
  846. G_chosenPixel = (unsigned char)(*src).at<Vec3b>(y, x)[1],
  847. R_chosenPixel = (unsigned char)(*src).at<Vec3b>(y, x)[2];
  848.  
  849. //calculate area
  850. int area = getArea(*src, R_chosenPixel, G_chosenPixel, B_chosenPixel);
  851. printf("Area %d \n", area);
  852.  
  853. //calculate center of mass
  854. int* center = getCenterOfMass(*src, R_chosenPixel, G_chosenPixel, B_chosenPixel, area);
  855. printf("Center of mass %d %d\n", center[0], center[1]);
  856.  
  857. //calculate elongation axis angle
  858. float angleRad = getElongationAxisAngle(*src, R_chosenPixel, G_chosenPixel, B_chosenPixel, center);
  859.  
  860. //calculate 2 points on elongation axis
  861. int xPoint;
  862. int yPoint;
  863. if (angleRad == PI / 2){
  864. ///vertical line
  865. xPoint = center[0];
  866. yPoint = center[1] + 1;
  867. }
  868. else{
  869. xPoint = center[0] * sin(angleRad);
  870. yPoint = center[1] * cos(angleRad);
  871. }
  872. Point start = Point(center[0], center[1]);
  873. Point end = Point(xPoint, yPoint);
  874. Scalar color = Scalar(0);
  875. line(*src, start, end, color, 1);
  876. //calculate perimeter
  877. int perimiter = getPerimeter(*src, R_chosenPixel, G_chosenPixel, B_chosenPixel);
  878. printf("Perimiter %d \n", perimiter);
  879.  
  880. //calculate thinness ratio
  881. float thRation = getThinessRatio(area, perimiter);
  882. printf("Thiness ratio %f\n", thRation);
  883.  
  884. //draw image
  885. for (int i = 0; i < dest.rows; i++){
  886. for (int j = 0; j < dest.cols; j++){
  887. Vec3b pixel = dest.at<Vec3b>(i, j);
  888. unsigned char B = pixel[0];
  889. unsigned char G = pixel[1];
  890. unsigned char R = pixel[2];
  891. if (R == R_chosenPixel&&B == B_chosenPixel&&G == G_chosenPixel){
  892.  
  893. if (isPointOnPerimeter(*src, i, j, R, G, B)){
  894. dest.at<Vec3b>(i, j) = Vec3b(0, 0, 0);
  895. }
  896. }
  897. }
  898. }
  899. //draw center
  900. dest.at<Vec3b>(center[0], center[1]) = Vec3b(0, 0, 0);
  901.  
  902. //show the image
  903. imshow("clone", dest);
  904. }
  905.  
  906. imshow("My Window", *src);
  907.  
  908. }
  909.  
  910. void displayObjectDetails(){
  911. Mat src;
  912. // Read image from file
  913. char fname[MAX_PATH];
  914. while (openFileDlg(fname))
  915. {
  916. src = imread(fname);
  917. //Create a window
  918. namedWindow("My Window", 1);
  919.  
  920. //set the callback function for any mouse event
  921. setMouseCallback("My Window", calculateDetailsForObject, &src);
  922.  
  923. //the pixel data stored in gloabal variables R,G,B
  924.  
  925.  
  926. // Wait until user press some key
  927. waitKey(0);
  928. }
  929. }
  930.  
  931. Mat Traversare_BFS(Mat src, int * noOfLables){
  932. int label = 0;
  933. Mat labelled = Mat(src.size(), CV_8UC1);
  934.  
  935. for (int i = 0; i < labelled.rows; i++){
  936. for (int j = 0; j < labelled.cols; j++){
  937. labelled.at<uchar>(i, j) = 0;
  938. }
  939. }
  940. for (int i = 1; i < labelled.rows - 1; i++){
  941. for (int j = 1; j < labelled.cols - 1; j++){
  942. if (src.at<uchar>(i, j) == 0 && labelled.at<uchar>(i, j) == 0){
  943. label++;
  944. std::queue<Point> my_queue;
  945. Point p = Point(i, j);
  946. labelled.at<uchar>(i, j) = label;
  947. my_queue.push(p);
  948. while (!my_queue.empty()){
  949. Point q = my_queue.front();
  950. my_queue.pop();
  951. for (int k = q.x - 1; k <= q.x + 1; k++){
  952. for (int l = q.y - 1; l <= q.y + 1; l++){
  953. Point neigh = Point(k, l);
  954. if (src.at<uchar>(neigh.x, neigh.y) == 0 && labelled.at<uchar>(neigh.x, neigh.y) == 0 && k != q.x&&l != q.y){
  955. labelled.at<uchar>(neigh.x, neigh.y) = label;
  956. my_queue.push(neigh);
  957. }
  958. }
  959. }
  960. }
  961. }
  962. }
  963. }
  964. *noOfLables = label;
  965. return labelled;
  966. }
  967.  
  968. void TraversareInLatime(){
  969. char fname[MAX_PATH];
  970. while (openFileDlg(fname))
  971. {
  972. Mat sursa = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  973. Mat destinatie = Mat(sursa.size(), CV_8UC1);
  974. int label = 0;
  975. for (int i = 0; i < destinatie.rows; i++){
  976. for (int j = 0; j < destinatie.cols; j++)
  977. {
  978. destinatie.at<uchar>(i, j) = 0;
  979. }
  980. }
  981. for (int i = 1; i < destinatie.rows - 1; i++)
  982. {
  983. for (int j = 1; j < destinatie.cols - 1; j++)
  984. {
  985. if (sursa.at<uchar>(i, j) == 0 && destinatie.at<uchar>(i, j) == 0)
  986. {
  987. label++;
  988. std::queue<Point> my_queue;
  989. Point p = Point(i, j);
  990. destinatie.at<uchar>(i, j) = label;
  991. my_queue.push(p);
  992. while (!my_queue.empty()){
  993. Point q = my_queue.front();
  994. my_queue.pop();
  995. for (int k = q.x - 1; k <= q.x + 1; k++){
  996. for (int l = q.y - 1; l <= q.y + 1; l++){
  997. Point neigh = Point(k, l);
  998. if (sursa.at<uchar>(neigh.x, neigh.y) == 0 && destinatie.at<uchar>(neigh.x, neigh.y) == 0 && k != q.x&&l != q.y){
  999. destinatie.at<uchar>(neigh.x, neigh.y) = label;
  1000. my_queue.push(neigh);
  1001. }
  1002. }
  1003. }
  1004. }
  1005. }
  1006. }
  1007. }
  1008. imshow("Sursa:", sursa);
  1009. imshow("Destinatie:", destinatie);
  1010. waitKey();
  1011. }
  1012. }
  1013.  
  1014. void TraversareInLatimeCuloareRandom(){
  1015. char fname[MAX_PATH];
  1016.  
  1017. while (openFileDlg(fname))
  1018. {
  1019. int noOfLabels;
  1020. Mat sursa = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1021. Mat destinatia = Mat(sursa.size(), CV_8UC3);
  1022. Mat labelled = Traversare_BFS(sursa, &noOfLabels);
  1023. Vec3b * colors = (Vec3b*)malloc((noOfLabels + 1)*sizeof(Vec3b));
  1024. for (int i = 1; i <= noOfLabels; i++){
  1025. unsigned char B = rand() % 255;
  1026. unsigned char G = rand() % 255;
  1027. unsigned char R = rand() % 255;
  1028. colors[i] = Vec3b(B, G, R);
  1029. }
  1030. for (int i = 0; i < labelled.rows; i++){
  1031. for (int j = 0; j < labelled.cols; j++)
  1032. {
  1033. int colorIndex = labelled.at<uchar>(i, j);
  1034. if (colorIndex == 0){
  1035. destinatia.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
  1036. }
  1037. else{
  1038. destinatia.at<Vec3b>(i, j) = colors[colorIndex];
  1039. }
  1040. }
  1041. }
  1042. imshow("Sursa:", sursa);
  1043. imshow("Destinatie:", destinatia);
  1044. waitKey();
  1045. }
  1046. }
  1047.  
  1048. void ParcurgereBFSCuloare(Mat img)
  1049. {
  1050. int label = 0;
  1051. Scalar colorVector[1000] = { 0 };
  1052. Scalar color;
  1053. for (int i = 1; i < 1000; i++)
  1054. {
  1055. Scalar color(rand() & 255, rand() & 255, rand() & 255);
  1056. colorVector[i] = color;
  1057. }
  1058. colorVector[0] = Scalar(255, 255, 255);
  1059. Mat labels = Mat::zeros(img.size(), CV_16SC1);
  1060. Mat destinatie = Mat::zeros(img.size(), CV_8UC3);
  1061. for (int i = 0; i < img.rows; i++)
  1062. for (int j = 0; j < img.cols; j++)
  1063. {
  1064. if (img.at<uchar>(i, j) == 0 && labels.at<short>(i, j) == 0)
  1065. {
  1066. label++;
  1067. std::queue <Point> que;
  1068. labels.at<short>(i, j) = label;
  1069. que.push({ i, j });
  1070. while (!que.empty())
  1071. {
  1072. Point oldest = que.front();
  1073. uchar neighbors[8];
  1074. int di[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };
  1075. int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
  1076. int x = oldest.x;
  1077. int y = oldest.y;
  1078. for (int k = 0; k < 8; k++)
  1079. {
  1080. int vecin_i = x + di[k];
  1081. int vecin_j = y + dj[k];
  1082. if (vecin_i >= 0 && vecin_j >= 0 && vecin_i<img.rows && vecin_j <img.cols)
  1083. if (img.at<uchar>(vecin_i, vecin_j) == 0 && labels.at<short>(vecin_i, vecin_j) == 0)
  1084. {
  1085. labels.at<short>(vecin_i, vecin_j) = label;
  1086. que.push(Point(vecin_i, vecin_j));
  1087. }
  1088. }
  1089. que.pop();
  1090.  
  1091. }
  1092. }
  1093. }
  1094.  
  1095. for (int i = 1; i < labels.rows - 1; i++)
  1096. for (int j = 1; j < labels.cols - 1; j++)
  1097. {
  1098. Scalar color = colorVector[labels.at<short>(i, j)]; // valabil pt. Met. 1 BFS
  1099. destinatie.at<Vec3b>(i, j)[0] = color[0];
  1100. destinatie.at<Vec3b>(i, j)[1] = color[1];
  1101. destinatie.at<Vec3b>(i, j)[2] = color[2];
  1102. }
  1103.  
  1104. imshow("Sursa:", img);
  1105. imshow("Destinatia:", destinatie);
  1106. waitKey();
  1107.  
  1108. }
  1109. void BFScolor(){
  1110. char fname[MAX_PATH];
  1111. while (openFileDlg(fname)){
  1112. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1113. ParcurgereBFSCuloare(img);
  1114. }
  1115. }
  1116. int minVector(std::vector<int> v){
  1117. int min = MAXINT;
  1118. for (int i = 0; i < v.size(); i++){
  1119. if (v.at(i) < min){
  1120. min = v.at(i);
  1121. }
  1122. }
  1123. return min;
  1124. }
  1125.  
  1126. Mat DouaTreceri(Mat src, int * noOfLables){
  1127. int label = 0;
  1128. std::vector<std::vector<int>> edges;
  1129. Mat labelled = Mat(src.size(), CV_8UC1);
  1130. for (int i = 0; i < labelled.rows; i++){
  1131. for (int j = 0; j < labelled.cols; j++){
  1132. labelled.at<uchar>(i, j) = 0;
  1133. }
  1134. }
  1135. for (int i = 1; i < labelled.rows - 1; i++){
  1136. for (int j = 1; j < labelled.cols - 1; j++){
  1137. if (src.at<uchar>(i, j) == 0 && labelled.at<uchar>(i, j) == 0){
  1138. std::vector<int> L;
  1139. Point Np[4] = { Point(i - 1, j - 1), Point(i - 1, j), Point(i - 1, j + 1), Point(i, j - 1) };
  1140. for (int v = 0; v < 4; v++){
  1141. if (labelled.at<uchar>(Np[v].x, Np[v].y) > 0){
  1142. L.push_back(labelled.at<uchar>(Np[v].x, Np[v].y));
  1143. }
  1144. }
  1145. if (L.size() == 0){
  1146. label++;
  1147. labelled.at<uchar>(i, j) = label;
  1148. }
  1149. else{
  1150. int x = minVector(L);
  1151. labelled.at<uchar>(i, j) = x;
  1152. for (int k = 0; k < L.size(); k++){
  1153. int y = L.at(k);
  1154. if (y != x){
  1155. edges[x].push_back(y);
  1156. edges[y].push_back(x);
  1157. }
  1158. }
  1159. }
  1160. }
  1161. }
  1162. int newLabel = 0;
  1163. int* newLabelled = (int *)malloc((label + 1)*sizeof(int));
  1164. for (int i = 1; i < label; i++){
  1165. if (newLabelled[i] == 0){
  1166. std::queue<int> Q;
  1167. newLabelled[i] = newLabel;
  1168. Q.push(i);
  1169. while (!Q.empty()){
  1170. int x = Q.front();
  1171. Q.pop();
  1172. for (int k = 0; k < edges[x].size(); k++){
  1173. int y = edges[x][k];
  1174. if (newLabelled[y] == 0){
  1175. newLabelled[y] = newLabel;
  1176. Q.push(y);
  1177. }
  1178. }
  1179. }
  1180. }
  1181. }
  1182. for (int i = 0; i < labelled.rows; i++){
  1183. for (int j = 0; j < labelled.cols; j++){
  1184. labelled.at<uchar>(i, j) = newLabelled[labelled.at<uchar>(i, j)];
  1185. }
  1186. }
  1187. *noOfLables = newLabel;
  1188. return labelled;
  1189. }
  1190. }
  1191.  
  1192. void drawLabelsTwo(){
  1193. char fname[MAX_PATH];
  1194. while (openFileDlg(fname))
  1195. {
  1196. Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1197. Mat dest = Mat(img.size(), CV_8UC3);
  1198. int noOfLabels;
  1199. Mat labelled = DouaTreceri(img, &noOfLabels);
  1200.  
  1201. Vec3b * colors = (Vec3b*)malloc((noOfLabels + 1)*sizeof(Vec3b));
  1202. for (int i = 1; i < noOfLabels; i++){
  1203. unsigned char B = rand() % 255;
  1204. unsigned char G = rand() % 255;
  1205. unsigned char R = rand() % 255;
  1206. colors[i] = Vec3b(B, G, R);
  1207. }
  1208. for (int i = 0; i < labelled.rows; i++){
  1209. for (int j = 0; j < labelled.cols; j++)
  1210. {
  1211. int colorIndex = labelled.at<uchar>(i, j);
  1212. if (colorIndex == 0){
  1213. dest.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
  1214. }
  1215. else{
  1216. dest.at<Vec3b>(i, j) = colors[colorIndex];
  1217. }
  1218. }
  1219. }
  1220.  
  1221. imshow("src image", img);
  1222. imshow("dest image", dest);
  1223. waitKey();
  1224. }
  1225. }
  1226. int main()
  1227. {
  1228. int op;
  1229. do
  1230. {
  1231. system("cls");
  1232. destroyAllWindows();
  1233. printf("Menu:\n");
  1234. printf(" 1 - Open image\n");
  1235. printf(" 2 - Open BMP images from folder\n");
  1236. printf(" 3 - Resize image\n");
  1237. printf(" 4 - Process video\n");
  1238. printf(" 5 - Snap frame from live video\n");
  1239. printf(" 6 - Mouse callback demo\n");
  1240. printf(" 7 - Negate image\n");
  1241. printf(" 8 - Change grey factor by an additive factor\n");
  1242. printf(" 9 - Change grey factor by an multiplicative factor\n");
  1243. printf(" 10 - Create colored image\n");
  1244. printf(" 11 - Display Circle\n");
  1245. printf(" 12 - Flip\n");
  1246. printf(" 13 - Display red, green and blue channels\n");
  1247. printf(" 14 - Greyscale\n");
  1248. printf(" 15 - BinaryTreshholding\n");
  1249. printf(" 16 - Convert rgb to hsv\n");
  1250. printf(" 17 - Draw histogram\n");
  1251. printf(" 18 - Multilevel thresholding\n");
  1252. printf(" 19 - Floyd Steinberg\n");
  1253. printf(" 20 - Display object details\n");
  1254. printf(" 21 - BFS\n");
  1255. printf(" 22 - BFS with colors\n");
  1256. //printf(" 23 - Draw labels two pass\n");
  1257. printf(" 0 - Exit\n\n");
  1258. printf("Option: ");
  1259. scanf("%d", &op);
  1260. switch (op)
  1261. {
  1262. case 1:
  1263. testOpenImage();
  1264. break;
  1265. case 2:
  1266. testOpenImagesFld();
  1267. break;
  1268. case 3:
  1269. testResize();
  1270. break;
  1271. case 4:
  1272. testVideoSequence();
  1273. break;
  1274. case 5:
  1275. testSnap();
  1276. break;
  1277. case 6:
  1278. testMouseClick();
  1279. break;
  1280. case 7:
  1281. negate_image();
  1282. break;
  1283. case 8:
  1284. addGrayLevels();
  1285. break;
  1286. case 9:
  1287. multiplyGrayLevels();
  1288. break;
  1289. case 10:
  1290. createColouredImage();
  1291. break;
  1292. case 11:
  1293. displayCircle();
  1294. break;
  1295. case 12:
  1296. flip();
  1297. break;
  1298. case 13:
  1299. displayRedGreenBlueImages();
  1300. break;
  1301. case 14:
  1302. convertToGreyscale();
  1303. break;
  1304. case 15:
  1305. treshholding();
  1306. break;
  1307. case 16:
  1308. convertToHSV();
  1309. break;
  1310. case 17:
  1311. drawHistogram();
  1312. break;
  1313. case 18:
  1314. multilevelThresholding();
  1315. break;
  1316. case 19:
  1317. floydSteinberg();
  1318. break;
  1319. case 20:
  1320. displayObjectDetails();
  1321. break;
  1322. case 21:
  1323. TraversareInLatime();
  1324. break;
  1325. case 22:
  1326. //TraversareInLatimeCuloareRandom();
  1327. BFScolor();
  1328. break;
  1329. case 23:
  1330. drawLabelsTwo();
  1331. break;
  1332. }
  1333. } while (op != 0);
  1334. return 0;
  1335. }
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!