API tools faq
paste
CoMoDoS

PI

CoMoDoS
Apr 26th, 2018
110
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 30.29 KB | None | 0 0
raw download clone embed print report
  1. // OpenCVApplication.cpp : Defines the entry point for the console application.
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include "common.h"
  6. #include <queue>;
  7. using namespace std;
  8.  
  9. #define FG  0  // obiect = negru
  10. #define BG 255 // fond = alb
  11.  
  12. typedef struct {
  13.     int x, y;
  14.     byte c;
  15. } my_point;
  16.  
  17.  
  18. void testOpenImage()
  19. {
  20.     char fname[MAX_PATH];
  21.     while (openFileDlg(fname))
  22.     {
  23.         Mat src;
  24.         src = imread(fname);
  25.         imshow("image", src);
  26.         waitKey();
  27.     }
  28. }
  29.  
  30. void testOpenImagesFld()
  31. {
  32.     char folderName[MAX_PATH];
  33.     if (openFolderDlg(folderName) == 0)
  34.         return;
  35.     char fname[MAX_PATH];
  36.     FileGetter fg(folderName, "bmp");
  37.     while (fg.getNextAbsFile(fname))
  38.     {
  39.         Mat src;
  40.         src = imread(fname);
  41.         imshow(fg.getFoundFileName(), src);
  42.         if (waitKey() == 27) //ESC pressed
  43.             break;
  44.     }
  45. }
  46.  
  47.  
  48. void testResize()
  49. {
  50.     char fname[MAX_PATH];
  51.     while (openFileDlg(fname))
  52.     {
  53.         Mat src;
  54.         src = imread(fname);
  55.         Mat dst1, dst2;
  56.         //without interpolation
  57.         resizeImg(src, dst1, 320, false);
  58.         //with interpolation
  59.         resizeImg(src, dst2, 320, true);
  60.         imshow("input image", src);
  61.         imshow("resized image (without interpolation)", dst1);
  62.         imshow("resized image (with interpolation)", dst2);
  63.         waitKey();
  64.     }
  65. }
  66.  
  67.  
  68. void testVideoSequence()
  69. {
  70.     VideoCapture cap("Videos/rubic.avi"); // off-line video from file
  71.     //VideoCapture cap(0);  // live video from web cam
  72.     if (!cap.isOpened()) {
  73.         printf("Cannot open video capture device.\n");
  74.         waitKey(0);
  75.         return;
  76.     }
  77.  
  78.     Mat edges;
  79.     Mat frame;
  80.     char c;
  81.  
  82.     while (cap.read(frame))
  83.     {
  84.         Mat grayFrame;
  85.         cvtColor(frame, grayFrame, CV_BGR2GRAY);
  86.         imshow("source", frame);
  87.         imshow("gray", grayFrame);
  88.         c = cvWaitKey(0);  // waits a key press to advance to the next frame
  89.         if (c == 27) {
  90.             // press ESC to exit
  91.             printf("ESC pressed - capture finished\n");
  92.             break;  //ESC pressed
  93.         };
  94.     }
  95. }
  96.  
  97.  
  98. void testSnap()
  99. {
  100.     VideoCapture cap(0); // open the deafult camera (i.e. the built in web cam)
  101.     if (!cap.isOpened()) // openenig the video device failed
  102.     {
  103.         printf("Cannot open video capture device.\n");
  104.         return;
  105.     }
  106.  
  107.     Mat frame;
  108.     char numberStr[256];
  109.     char fileName[256];
  110.  
  111.     // video resolution
  112.     Size capS = Size((int)cap.get(CV_CAP_PROP_FRAME_WIDTH),
  113.         (int)cap.get(CV_CAP_PROP_FRAME_HEIGHT));
  114.  
  115.     // Display window
  116.     const char* WIN_SRC = "Src"; //window for the source frame
  117.     namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  118.     cvMoveWindow(WIN_SRC, 0, 0);
  119.  
  120.     const char* WIN_DST = "Snapped"; //window for showing the snapped frame
  121.     namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  122.     cvMoveWindow(WIN_DST, capS.width + 10, 0);
  123.  
  124.     char c;
  125.     int frameNum = -1;
  126.     int frameCount = 0;
  127.  
  128.     for (;;)
  129.     {
  130.         cap >> frame; // get a new frame from camera
  131.         if (frame.empty())
  132.         {
  133.             printf("End of the video file\n");
  134.             break;
  135.         }
  136.  
  137.         ++frameNum;
  138.  
  139.         imshow(WIN_SRC, frame);
  140.  
  141.         c = cvWaitKey(10);  // waits a key press to advance to the next frame
  142.         if (c == 27) {
  143.             // press ESC to exit
  144.             printf("ESC pressed - capture finished");
  145.             break;  //ESC pressed
  146.         }
  147.         if (c == 115){ //'s' pressed - snapp the image to a file
  148.             frameCount++;
  149.             fileName[0] = NULL;
  150.             sprintf(numberStr, "%d", frameCount);
  151.             strcat(fileName, "Images/A");
  152.             strcat(fileName, numberStr);
  153.             strcat(fileName, ".bmp");
  154.             bool bSuccess = imwrite(fileName, frame);
  155.             if (!bSuccess)
  156.             {
  157.                 printf("Error writing the snapped image\n");
  158.             }
  159.             else
  160.                 imshow(WIN_DST, frame);
  161.         }
  162.     }
  163.  
  164. }
  165.  
  166. void negative_img() {
  167.  
  168.     Mat img = imread("Images/kids.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  169.     Mat dst(img.rows, img.cols, CV_8UC1);
  170.  
  171.     for (int i = 0; i < img.rows; i++)
  172.         for (int j = 0; j < img.cols; j++)
  173.             dst.at<uchar>(i, j) = 255 - img.at<uchar>(i, j);
  174.  
  175.     imshow("original", img);
  176.     imshow("negative image", dst);
  177.     waitKey(0);
  178. }
  179.  
  180. void changeColor() {
  181.     Mat img = imread("Images/kids.bmp", CV_LOAD_IMAGE_COLOR);
  182.     Mat dst = img.clone();
  183.  
  184.     for (int i = 0; i < img.rows; i++)
  185.         for (int j = 0; j < img.cols; j++) {
  186.             Vec3b pixel = img.at<Vec3b>(i, j);
  187.             Vec3b np = dst.at<Vec3b>(i, j);
  188.             np[0] = 255 - pixel[0];
  189.             np[1] = 255 - pixel[1];
  190.             np[2] = 255 - pixel[2];
  191.             dst.at<Vec3b>(i, j) = np;
  192.         }
  193.  
  194.     imshow("original", img);
  195.     imshow("negative image", dst);
  196.     waitKey(0);
  197. }
  198.  
  199. void add() {
  200.     Mat img = imread("Images/Lena_24bits_gray.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  201.     Mat dst = img.clone();
  202.  
  203.     for (int i = 0; i < img.rows; i++)
  204.         for (int j = 0; j < img.cols; j++)
  205.             if (img.at<uchar>(i, j) + 50 <= 255)
  206.                 dst.at<uchar>(i, j) = img.at<uchar>(i, j) + 50;
  207.             else
  208.                 dst.at<uchar>(i, j) = 255;
  209.  
  210.     imshow("original", img);
  211.     imshow("negative image", dst);
  212.     waitKey(0);
  213. }
  214.  
  215. void mul() {
  216.     Mat img = imread("Images/Lena_24bits_gray.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  217.     Mat dst = img.clone();
  218.  
  219.     for (int i = 0; i < img.rows; i++)
  220.         for (int j = 0; j < img.cols; j++)
  221.             if (img.at<uchar>(i, j) * 2 <= 255)
  222.                 dst.at<uchar>(i, j) = img.at<uchar>(i, j) * 2;
  223.             else
  224.                 dst.at<uchar>(i, j) = 255;
  225.  
  226.     imshow("original", img);
  227.     imshow("negative image", dst);
  228.     imwrite("C://Users//Student//Downloads//OpenCVApplication-VS2013_2413_basic\ (1)//OpenCVApplication-VS2013_2413_basic//Images//out.bmp", dst);
  229.     waitKey(0);
  230. }
  231.  
  232. void create() {
  233.     Mat n(256, 256, CV_8UC3);
  234.  
  235.     for (int i = 0; i < n.rows; i++)
  236.         for (int j = 0; j < n.cols; j++) {
  237.             Vec3b pixel = n.at<Vec3b>(i, j);
  238.             if (i < 128 && j < 128) {
  239.                 pixel[0] = 255;
  240.                 pixel[1] = 255;
  241.                 pixel[2] = 255;
  242.             }
  243.             if (i < 128 && j >= 128) {
  244.                 pixel[0] = 0;
  245.                 pixel[1] = 0;
  246.                 pixel[2] = 255;
  247.             }
  248.             if (i >= 128 && j < 128) {
  249.                 pixel[0] = 0;
  250.                 pixel[1] = 255;
  251.                 pixel[2] = 0;
  252.             }
  253.             if (i >= 128 && j >= 128) {
  254.                 pixel[0] = 0;
  255.                 pixel[1] = 255;
  256.                 pixel[2] = 255;
  257.             }
  258.             n.at<Vec3b>(i, j) = pixel;
  259.         }
  260.     imshow("my img", n);
  261.     waitKey(0);
  262. }
  263.  
  264. void invert() {
  265.     float val[9] = { 5, 6, 1, 8, 9, 3, 2, 5, 4 };
  266.  
  267.     Mat M(3, 3, CV_32FC1, val);
  268.     std::cout << M << std::endl;
  269.  
  270.     Mat M2 = M.inv();
  271.     std::cout << M2 << std::endl;
  272.  
  273.     system("Pause");
  274. }
  275.  
  276. void changeColor3in1() {
  277.     Mat img = imread("Images/kids.bmp", CV_LOAD_IMAGE_COLOR);
  278.     Mat d1, d2, d3;
  279.     d1 = Mat(img.rows, img.cols, CV_8UC1);
  280.     d2 = Mat(img.rows, img.cols, CV_8UC1);
  281.     d3 = Mat(img.rows, img.cols, CV_8UC1);
  282.  
  283.     for (int i = 0; i < img.rows; i++)
  284.         for (int j = 0; j < img.cols; j++) {
  285.             Vec3b pix = img.at<Vec3b>(i, j);
  286.             d1.at<uchar>(i, j) = pix[0];
  287.             d2.at<uchar>(i, j) = pix[1];
  288.             d3.at<uchar>(i, j) = pix[2];
  289.         }
  290.  
  291.     imshow("original", img);
  292.     imshow("img 1", d1);
  293.     imshow("img 2", d2);
  294.     imshow("img 3", d3);
  295.     waitKey(0);
  296. }
  297.  
  298. void colorToGray() {
  299.     Mat img = imread("Images/kids.bmp", CV_LOAD_IMAGE_COLOR);
  300.     Mat dst = Mat(img.rows, img.cols, CV_8UC1);
  301.     Mat dst2 = Mat(img.rows, img.cols, CV_8UC1);
  302.  
  303.     for (int i = 0; i < img.rows; i++)
  304.         for (int j = 0; j < img.cols; j++) {
  305.             Vec3b pix = img.at<Vec3b>(i, j);
  306.             dst.at<uchar>(i, j) = (pix[0] + pix[1] + pix[2]) / 3;
  307.             dst2.at<uchar>(i, j) = 0.07 * (float)pix[0] + 0.726 * (float)pix[1] + 0.21 * (float)pix[2];
  308.         }
  309.  
  310.     imshow("original", img);
  311.     imshow("dest", dst);
  312.     imshow("dest2", dst2);
  313.     waitKey(0);
  314. }
  315.  
  316. void grayToWB() {
  317.     Mat img = imread("Images/Lena_24bits_gray.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  318.     Mat dst = Mat(img.rows, img.cols, CV_8UC1);
  319.     int prag = 50;
  320.  
  321.     for (int i = 0; i < img.rows; i++)
  322.         for (int j = 0; j < img.cols; j++) {
  323.             if (img.at<uchar>(i, j) >= prag)
  324.                 dst.at<uchar>(i, j) = 0;
  325.             else
  326.                 dst.at<uchar>(i, j) = 255;
  327.         }
  328.  
  329.     imshow("original", img);
  330.     imshow("dest", dst);
  331.     waitKey(0);
  332. }
  333.  
  334. void RGBtoHSV() {
  335.     Mat img = imread("Images/Lena_24bits.bmp", CV_LOAD_IMAGE_COLOR);
  336.  
  337.     Mat h = Mat(img.rows, img.cols, CV_8UC1);
  338.     Mat s = Mat(img.rows, img.cols, CV_8UC1);
  339.     Mat v = Mat(img.rows, img.cols, CV_8UC1);
  340.  
  341.     float r, g, b, M, m, C, H, S, V;
  342.  
  343.     for (int i = 0; i < img.rows; i++)
  344.         for (int j = 0; j < img.cols; j++) {
  345.             Vec3b pix = img.at<Vec3b>(i, j);
  346.             r = (float)pix[2] / 255;
  347.             g = (float)pix[1] / 255;
  348.             b = (float)pix[0] / 255;
  349.  
  350.             M = max(r, g, b);
  351.             m = min(r, g, b);
  352.             C = M - m;
  353.  
  354.             V = M;
  355.  
  356.             if (C)
  357.                 S = C / V;
  358.             else
  359.                 S = 0;
  360.  
  361.             if (C) {
  362.                 if (M == r)
  363.                     H = 60 * (g - b) / C;
  364.                 if (M == g)
  365.                     H = 120 + 60 * (b - r) / C;
  366.                 if (M == b)
  367.                     H = 240 + 60 * (r - g) / C;
  368.             }
  369.             else
  370.                 H = 0;
  371.  
  372.             if (H < 0)
  373.                 H += 360;
  374.  
  375.             H = H * 255 / 360;
  376.             S = S * 255;
  377.             V = V * 255;
  378.  
  379.             h.at<uchar>(i, j) = (uchar)H;
  380.             s.at<uchar>(i, j) = (uchar)S;
  381.             v.at<uchar>(i, j) = (uchar)V;
  382.         }
  383.  
  384.     imshow("original", img);
  385.     imshow("H", h);
  386.     imshow("S", s);
  387.     imshow("V", v);
  388.     waitKey(0);
  389. }
  390.  
  391. int* calculHistograma(Mat img) {
  392.  
  393.     int *hist = (int*)malloc(sizeof(int) * 256);
  394.  
  395.     for (int i = 0; i < 256; i++)
  396.         hist[i] = 0;
  397.  
  398.     for (int i = 0; i < img.rows; i++)
  399.         for (int j = 0; j < img.cols; j++)
  400.             hist[img.at<uchar>(i, j)]++;
  401.  
  402.     return hist;
  403. }
  404.  
  405. /* Histogram display function - display a histogram using bars (simlilar to L3 / PI)
  406. Input:
  407. name - destination (output) window name
  408. hist - pointer to the vector containing the histogram values
  409. hist_cols - no. of bins (elements) in the histogram = histogram image width
  410. hist_height - height of the histogram image
  411. Call example:
  412. showHistogram ("MyHist", hist_dir, 255, 200);
  413. */
  414. void showHistogram(const string& name, int* hist, const int  hist_cols, const int hist_height)
  415. {
  416.     Mat imgHist(hist_height, hist_cols, CV_8UC3, CV_RGB(255, 255, 255)); // constructs a white image
  417.  
  418.     //computes histogram maximum
  419.     int max_hist = 0;
  420.     for (int i = 0; i<hist_cols; i++)
  421.         if (hist[i] > max_hist)
  422.             max_hist = hist[i];
  423.     double scale = 1.0;
  424.     scale = (double)hist_height / max_hist;
  425.     int baseline = hist_height - 1;
  426.  
  427.     for (int x = 0; x < hist_cols; x++) {
  428.         Point p1 = Point(x, baseline);
  429.         Point p2 = Point(x, baseline - cvRound(hist[x] * scale));
  430.         line(imgHist, p1, p2, CV_RGB(255, 0, 255)); // histogram bins colored in magenta
  431.     }
  432.  
  433.     imshow(name, imgHist);
  434. }
  435.  
  436. // lab 4
  437. bool onContour(int r, int g, int b, int i, int j, Mat* src){
  438.     int posi, posj;
  439.     posi = i - 1;
  440.     posj = j - 1;
  441.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  442.         return true;
  443.     posi = i - 1;
  444.     posj = j;
  445.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  446.         return true;
  447.     posi = i - 1;
  448.     posj = j + 1;
  449.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  450.         return true;
  451.     posi = i;
  452.     posj = j - 1;
  453.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  454.         return true;
  455.     posi = i;
  456.     posj = j + 1;
  457.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  458.         return true;
  459.     posi = i + 1;
  460.     posj = j - 1;
  461.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  462.         return true;
  463.     posi = i + 1;
  464.     posj = j;
  465.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  466.         return true;
  467.     posi = i + 1;
  468.     posj = j + 1;
  469.     if ((*src).at<Vec3b>(posi, posj)[0] != b || (*src).at<Vec3b>(posi, posj)[1] != g || (*src).at<Vec3b>(posi, posj)[2] != r)
  470.         return true;
  471.     return false;
  472. }
  473.  
  474. void toateOperatiile(int r, int g, int b, Mat* src) {
  475.     int area = 0, ri = 0, ci = 0, perim = 0, e1 = 0, e2 = 0, e3 = 0;
  476.     int rmax = -1000, rmin = 1000, cmax = -1000, cmin = 1000;
  477.  
  478.     for (int i = 0; i < (*src).rows; i++)
  479.         for (int j = 0; j < (*src).cols; j++)
  480.             if (((*src).at<Vec3b>(i, j).val[0] == b) && ((*src).at<Vec3b>(i, j).val[1] == g) && ((*src).at<Vec3b>(i, j).val[2] == r)) {
  481.                 if (i > rmax)
  482.                     rmax = i;
  483.                 else if (i < rmin)
  484.                     rmin = i;
  485.                 if (j > cmax)
  486.                     cmax = j;
  487.                 else if (j < cmin)
  488.                     cmin = j;
  489.                 ri += i;
  490.                 ci += j;
  491.                 area++;
  492.             }
  493.     ri /= area;
  494.     ci /= area;
  495.  
  496.     for (int i = 0; i < (*src).rows; i++)
  497.         for (int j = 0; j < (*src).cols; j++)
  498.             if (((*src).at<Vec3b>(i, j).val[0] == b) && ((*src).at<Vec3b>(i, j).val[1] == g) && ((*src).at<Vec3b>(i, j).val[2] == r))
  499.                 if (onContour(r, g, b, i, j, src))
  500.                     perim++;
  501.  
  502.     for (int i = 0; i < (*src).rows; i++)
  503.         for (int j = 0; j < (*src).cols; j++)
  504.             if (((*src).at<Vec3b>(i, j).val[0] == b) && ((*src).at<Vec3b>(i, j).val[1] == g) && ((*src).at<Vec3b>(i, j).val[2] == r)) {
  505.                 e1 += (i - ri) * (j - ci);
  506.                 e2 += (j - ci) * (j - ci);
  507.                 e3 += (i - ri) * (i - ri);
  508.             }
  509.  
  510.     float phi = atan2(2 * e1, (e2 - e3)) / 2;
  511.     float thinness = 4 * PI * area / perim * perim;
  512.     float aspectRatio = (cmax - cmin + 1) / (rmax - rmin + 1);
  513.  
  514.     printf("Aria: %d\nCentru de masa: %d, %d\nAxa de alungire: %f\nPerimetru: %d\nFactor de subtiere: %f\nFactor de aspect: %f\n",
  515.         area, ri, ci, phi * 180 / PI, perim, thinness, aspectRatio);
  516. }
  517.  
  518. void MyCallBackFunc(int event, int x, int y, int flags, void* param) {
  519.     //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  520.     Mat* src = (Mat*)param;
  521.     if (event == CV_EVENT_LBUTTONDOWN)
  522.     {
  523.         printf("\nPozitie(x,y): %d, %d\nColor(RGB): %d, %d, %d\n",
  524.             x, y,
  525.             (int)(*src).at<Vec3b>(y, x)[2],
  526.             (int)(*src).at<Vec3b>(y, x)[1],
  527.             (int)(*src).at<Vec3b>(y, x)[0]);
  528.  
  529.         toateOperatiile((*src).at<Vec3b>(y, x)[2], (*src).at<Vec3b>(y, x)[1], (*src).at<Vec3b>(y, x)[0], src);
  530.     }
  531. }
  532.  
  533. void testMouseClick() {
  534.     Mat src;
  535.     // Read image from file
  536.     char fname[MAX_PATH];
  537.     while (openFileDlg(fname))
  538.     {
  539.         src = imread(fname);
  540.         //Create a window
  541.         namedWindow("My Window", 1);
  542.  
  543.         //set the callback function for any mouse event
  544.         setMouseCallback("My Window", MyCallBackFunc, &src);
  545.  
  546.         //show the image
  547.         imshow("My Window", src);
  548.  
  549.         // Wait until user press some key
  550.         waitKey(0);
  551.     }
  552. }
  553.  
  554. //lab5
  555. void drawLabels(){
  556.     char fname[MAX_PATH];
  557.     while (openFileDlg(fname)) {
  558.         Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  559.         Mat dest = Mat(src.size(), CV_8UC3);
  560.         int label = 0;
  561.         Mat tLabels = Mat::zeros(src.size(), CV_8UC1);
  562.  
  563.  
  564.         for (int i = 1; i < tLabels.rows - 1; i++)
  565.             for (int j = 1; j < tLabels.cols - 1; j++)
  566.                 if (src.at<uchar>(i, j) == 0 && tLabels.at<uchar>(i, j) == 0) {
  567.                     label++;
  568.                     std::queue<Point> Q;
  569.                     Point p = Point(i, j);
  570.                     tLabels.at<uchar>(i, j) = label;
  571.                     Q.push(p);
  572.                     while (!Q.empty()) {
  573.                         Point q = Q.front();
  574.                         Q.pop();
  575.                         for (int k = q.x - 1; k <= q.x + 1; k++) //pt fiecare vecin din N8
  576.                             for (int l = q.y - 1; l <= q.y + 1; l++) {
  577.                                 Point vecin = Point(k, l);
  578.                                 if (src.at<uchar>(vecin.x, vecin.y) == 0 && tLabels.at<uchar>(vecin.x, vecin.y) == 0 && k != q.x&&l != q.y) {
  579.                                     tLabels.at<uchar>(vecin.x, vecin.y) = label;
  580.                                     Q.push(vecin);
  581.                                 }
  582.                             }
  583.                     }
  584.                 }
  585.  
  586.         Vec3b * culori = (Vec3b*)malloc((label + 1)*sizeof(Vec3b));
  587.         for (int i = 1; i <= label; i++) {
  588.             unsigned char R = rand() % 255;
  589.             unsigned char G = rand() % 255;
  590.             unsigned char B = rand() % 255;
  591.             culori[i] = Vec3b(B, G, R);
  592.         }
  593.         for (int i = 0; i < tLabels.rows; i++)
  594.             for (int j = 0; j < tLabels.cols; j++) {
  595.                 int pozVec = tLabels.at<uchar>(i, j);
  596.                 if (pozVec == 0)
  597.                     dest.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
  598.                 else
  599.                     dest.at<Vec3b>(i, j) = culori[pozVec];
  600.             }
  601.  
  602.         imshow("src image", src);
  603.         imshow("dest image", dest);
  604.         waitKey(0);
  605.     }
  606. }
  607.  
  608. int maxi1(int x, int y) {
  609.     return x > y ? x : y;
  610. }
  611.  
  612. int mini(int x, int y) {
  613.     return x < y ? x : y;
  614. }
  615.  
  616. void traversalTwoPass() {
  617.  
  618.     char fname[MAX_PATH];
  619.     while (openFileDlg(fname)) {
  620.         Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  621.         imshow("image", src);
  622.  
  623.         Mat dst = Mat(src.size(), CV_8UC3);
  624.  
  625.         int height = src.rows;
  626.         int width = src.cols;
  627.  
  628.         int label = 0;
  629.         vector< vector<int> > labels(height, vector<int>(width));
  630.         vector< vector<int> > edges(100000);//assoc
  631.  
  632.  
  633.         for (int i = 1; i < height - 1; i++)
  634.             for (int j = 1; j <width - 1; j++) {
  635.                 //if not visited
  636.                 if (src.data[i*src.step[0] + j] == 0 && labels[i][j] == 0) {
  637.                     vector<int> L;
  638.  
  639.                     for (int t = maxi1(i - 1, 0); t <= mini(i + 1, height - 1); t++)
  640.                         for (int u = maxi1(j - 1, 0); u <= mini(j + 1, width - 1); u++)
  641.                             if (labels[t][u] > 0)
  642.                                 L.push_back(labels[t][u]);
  643.  
  644.                     if (L.size() == 0) {
  645.                         label++;
  646.                         labels[i][j] = label;
  647.                     }
  648.                     else {
  649.                         int x = L[0];
  650.                         for (int q = 1; q < L.size(); q++)
  651.                             if (L[q] < x)
  652.                                 x = L[q];
  653.  
  654.                         labels[i][j] = x;
  655.  
  656.                         for (int q = 0; q < L.size(); q++) {
  657.                             int y = L[q];
  658.                             if (y != x) {
  659.                                 edges[x].push_back(y);
  660.                                 edges[y].push_back(x);
  661.                             }
  662.                         }
  663.                     }
  664.                 }
  665.             }
  666.  
  667.         int newlabel = 0;
  668.         vector<int> newlabels(label + 1);
  669.  
  670.         for (int i = 1; i <= label; i++)
  671.             if (newlabels[i] == 0) {
  672.                 newlabel++;
  673.                 std::queue<int> q;
  674.                 newlabels[i] = newlabel;
  675.                 q.push(i);
  676.  
  677.                 while (!q.empty()) {
  678.                     int x = q.front();
  679.                     q.pop();
  680.                     for (int t = 0; t < edges[x].size(); t++)
  681.                         if (newlabels[edges[x][t]] == 0) {
  682.                             newlabels[edges[x][t]] = newlabel;
  683.                             q.push(edges[x][t]);
  684.                         }
  685.                 }
  686.             }
  687.  
  688.         //generate colors
  689.         Vec3b color[200000];
  690.         for (int i = 1; i <= newlabel; i++) {
  691.             color[i][0] = rand() % 255;
  692.             color[i][1] = rand() % 255;
  693.             color[i][2] = rand() % 255;
  694.         }
  695.  
  696.         for (int i = 0; i<height; i++)
  697.             for (int j = 0; j < width; j++)
  698.                 if (src.data[i*src.step[0] + j] == 0)
  699.                     dst.at<Vec3b>(i, j) = color[newlabels[labels[i][j]]];
  700.  
  701.         //labels color
  702.         imshow("destinatie", dst);
  703.         waitKey();
  704.     }
  705. }
  706.  
  707. //lab6
  708. FILE *f;
  709. void findContour() {
  710.     int t = 7;
  711.     FILE *f = fopen("output.txt", "w");
  712.     if (f == NULL) {
  713.         printf("Error opening file!\n");
  714.         exit(1);
  715.     }
  716.  
  717.     char fname[MAX_PATH];
  718.     while (openFileDlg(fname)) {
  719.  
  720.         Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  721.         imshow("imagine initiala", src);
  722.  
  723.         Mat dst(src.rows, src.cols, CV_8UC1);
  724.  
  725.         std::vector<my_point> contur;
  726.         int n = 0; // indice curent din vector contur
  727.         int dir = 7;
  728.         int x, y;
  729.         int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  730.         int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  731.         int I = 0, J = 0;
  732.  
  733.         for (int i = 0; i < src.rows; i++)
  734.             for (int j = 0; j < src.cols; j++)
  735.                 dst.at<uchar>(i, j) = 255;
  736.  
  737.  
  738.         // start
  739.  
  740.         bool ok = false;
  741.         for (int i = 0; (i < src.rows) && (!ok); i++)
  742.             for (int j = 0; (j < src.cols) && (!ok); j++)
  743.                 if (src.at<uchar>(i, j) == 0) {
  744.                     dst.at<uchar>(i, j) = 0;
  745.                     contur.push_back(my_point{ i, j, 7 });
  746.                     I = i;
  747.                     J = j;
  748.                     ok = true;
  749.                 }
  750.  
  751.         dst.at<uchar>(I, J) = 0;
  752.  
  753.         bool finished = false;
  754.         int d = 0;
  755.         while (!finished) {
  756.             // directia initiala pt cautarea urmatorului pixel
  757.  
  758.             if (dir % 2 == 0)
  759.                 dir = (dir + 7) % 8;
  760.             else
  761.                 dir = (dir + 6) % 8;
  762.             int l = 0;
  763.             // cauta urmator pixel
  764.             for (int k = 0; k < 8; k++) {
  765.                 d = (dir + k) % 8;
  766.                 x = I + di[d];
  767.                 y = J + dj[d];
  768.                 l++;
  769.                 if (src.at<uchar>(x, y) == 0) {
  770.                     dir = d;
  771.                     dst.at<uchar>(x, y) = 0;
  772.                     //std::cout << x << " " << y << " " << dir << " " << std::endl;
  773.                     fprintf(f, "%d %d %d ", x, y, dir);
  774.                     if (n > 0){
  775.                         t = contur[n].c - contur[n - 1].c;
  776.                         fprintf(f, "%d\n", l);
  777.                     }
  778.                     else fprintf(f, "%d %d\n", contur[n].c, t);
  779.                     contur.push_back(my_point{ x, y, dir });
  780.                     I = x;
  781.                     J = y;
  782.                     n++;
  783.                     break;
  784.                 }
  785.             }
  786.  
  787.             if ((n > 1))
  788.                 if ((contur[0].x == contur[n - 1].x) && (contur[1].x == contur[n].x) &&
  789.                     (contur[0].y == contur[n - 1].y) && (contur[1].y == contur[n].y))
  790.                     finished = true;
  791.         }
  792.         fclose(f);
  793.         imshow("Contur", dst);
  794.         waitKey();
  795.     }
  796. }
  797.  
  798. void reconstruct() {
  799.     char fname[MAX_PATH];
  800.  
  801.     while (openFileDlg(fname)) {
  802.         Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  803.  
  804.         int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  805.         int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  806.  
  807.         FILE* fp = fopen("reconstruct.txt", "r");
  808.         if (!fp)
  809.             printf("Error opening the text file !\n");
  810.  
  811.         int x_start, y_start, nr;
  812.         fscanf(fp, "%d%d%d", &x_start, &y_start, &nr);
  813.         printf("%d, %d, %d\n", x_start, y_start, nr);
  814.  
  815.         src.at<uchar>(x_start, y_start) = 0;
  816.         int k;
  817.         while (nr != 0) {
  818.             fscanf(fp, "%d", &k);
  819.             x_start += di[k];
  820.             y_start += dj[k];
  821.             src.at<uchar>(x_start, y_start) = 0;
  822.             nr--;
  823.         }
  824.  
  825.  
  826.         imshow("input image", src);
  827.         waitKey();
  828.     }
  829. }
  830.  
  831. // lab 7
  832. Mat dilatare(Mat src) {
  833.     Mat dst = src.clone();
  834.     int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  835.     int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  836.  
  837.     for (int i = 1; i < src.rows - 1; i++)
  838.         for (int j = 1; j < src.cols - 1; j++)
  839.             if (src.at<uchar>(i, j) == FG)
  840.                 for (int k = 0; k < 8; k++)
  841.                     dst.at<uchar>(i + di[k], j + dj[k]) = FG;
  842.  
  843.     return dst;
  844. }
  845.  
  846. void testDilatare() {
  847.     char fname[MAX_PATH];
  848.  
  849.     while (openFileDlg(fname)) {
  850.  
  851.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  852.  
  853.         imshow("src", img);
  854.         imshow("dilatare", dilatare(img));
  855.  
  856.         waitKey(0);
  857.     }
  858. }
  859.  
  860. Mat eroziune(Mat src) {
  861.     Mat dst = src.clone();
  862.     int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  863.     int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  864.  
  865.     for (int i = 1; i < src.rows - 1; i++)
  866.         for (int j = 1; j < src.cols - 1; j++)
  867.             if (src.at<uchar>(i, j) == FG)
  868.                 for (int k = 0; k < 8; k++)
  869.                     if (src.at<uchar>(i + di[k], j + dj[k]) == BG) {
  870.                         dst.at<uchar>(i, j) = BG;
  871.                         break;
  872.                     }
  873.     return dst;
  874. }
  875.  
  876. void testEroziune() {
  877.     char fname[MAX_PATH];
  878.  
  879.     while (openFileDlg(fname)) {
  880.  
  881.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  882.  
  883.         imshow("src", img);
  884.         imshow("eroziune", eroziune(img));
  885.  
  886.         waitKey(0);
  887.     }
  888. }
  889.  
  890. Mat deschidere(Mat src) {
  891.     Mat temp = src.clone();
  892.     temp = eroziune(src);
  893.  
  894.     Mat dst = temp.clone();
  895.     dst = dilatare(temp);
  896.  
  897.     imshow("DESCHIDERE - src", src);
  898.     imshow("DESCHIDERE - temp", temp);
  899.     imshow("DESCHIDERE - dst", dst);
  900.  
  901.     return dst;
  902. }
  903.  
  904. void testDeschidere(){
  905.     char fname[MAX_PATH];
  906.  
  907.     while (openFileDlg(fname)) {
  908.  
  909.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  910.  
  911.         deschidere(img);
  912.  
  913.         waitKey(0);
  914.     }
  915. }
  916.  
  917. Mat inchidere(Mat src) {
  918.     Mat temp = src.clone();
  919.     temp = dilatare(src);
  920.  
  921.     Mat dst = temp.clone();
  922.     dst = eroziune(temp);
  923.  
  924.     imshow("INCHIDERE - src", src);
  925.     imshow("INCHIDERE - temp", temp);
  926.     imshow("INCHIDERE - dst", dst);
  927.  
  928.     return dst;
  929. }
  930.  
  931. void testInchidere() {
  932.     char fname[MAX_PATH];
  933.  
  934.     while (openFileDlg(fname)) {
  935.  
  936.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  937.  
  938.         inchidere(img);
  939.  
  940.         waitKey(0);
  941.     }
  942. }
  943.  
  944. // lab 8
  945. void calcule(Mat img){
  946.  
  947.     // nr de pixeli ai imaginii
  948.     int M = img.rows * img.cols;
  949.  
  950.     int* hist = calculHistograma(img);
  951.  
  952.     showHistogram("histogram", hist, 256, 200);
  953.  
  954.     // niv maxim de intensitate
  955.     int L = 255;
  956.  
  957.     // niveluri de gri
  958.     float fdp[256] = {};
  959.  
  960.     for (int g = 0; g <= L; g++)
  961.         fdp[g] = (float)hist[g] / M;
  962.  
  963.     // val medie a niv de intensitate
  964.     float medie = 0.0;
  965.     for (int g = 0; g <= L; g++)
  966.         medie += fdp[g] * g;
  967.  
  968.     // deviatie standard
  969.     float devStd = 0.0;
  970.     for (int g = 0; g <= L; g++)
  971.         devStd += pow(g - medie, 2) * fdp[g];
  972.     devStd = sqrt(devStd);
  973.  
  974.     printf("Valoare medie: %f.\n", medie);
  975.     printf("Deviatie standard: %f.\n", devStd);
  976. }
  977.  
  978. void testHistogramaFDP() {
  979.     char fname[MAX_PATH];
  980.  
  981.     while (openFileDlg(fname)) {
  982.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  983.  
  984.         imshow("src", img);
  985.  
  986.         calcule(img);
  987.  
  988.         waitKey(0);
  989.     }
  990. }
  991.  
  992. void pragBinarizare(Mat img){
  993.  
  994.     // nr de pixeli ai imaginii
  995.     int M = img.rows * img.cols;
  996.  
  997.     int* hist = calculHistograma(img);
  998.  
  999.     showHistogram("histogram", hist, 256, 200);
  1000.  
  1001.     // fdp
  1002.     float fdp[256] = {};
  1003.    
  1004.     for (int g = 0; g < 256; g++)
  1005.         fdp[g] = (float)hist[g] / M;
  1006.  
  1007.     float T;
  1008.     int iMin = 0, iMax = 256;
  1009.  
  1010.     T = (iMax + iMin) / 2.0;
  1011.  
  1012.     float Tn_1;
  1013.  
  1014.     do
  1015.     {
  1016.         int Nmic = 0, Nmare = 0;
  1017.         float medieMica = 0, medieMare = 0;
  1018.  
  1019.         for (int g = 0; g <= T; g++)
  1020.             Nmic += hist[g];
  1021.         for (int g = 255; g > T; g--)
  1022.             Nmare += hist[g];
  1023.  
  1024.         for (int g = 0; g <= T; g++)
  1025.             medieMica += hist[g] * g;
  1026.         for (int g = 255; g > T; g--)
  1027.             medieMare += hist[g] * g;
  1028.  
  1029.         Tn_1 = T;
  1030.         T = (medieMica / Nmic + medieMare / Nmare) / 2.0;
  1031.  
  1032.     } while (abs(Tn_1 - T) > 0.1);
  1033.  
  1034.     printf("Prag de binarizare: %f.\n", T);
  1035.  
  1036.     Mat dest = img.clone();
  1037.     for (int i = 0; i < img.rows; i++)
  1038.         for (int j = 0; j < img.cols; j++)
  1039.             if (img.at<uchar>(i, j) < 165)
  1040.                 dest.at<uchar>(i, j) = 0;
  1041.             else
  1042.                 dest.at<uchar>(i, j) = 255;
  1043.  
  1044.     imshow("Binarizare", dest);
  1045. }
  1046.  
  1047. void testPragBinarizare(){
  1048.     char fname[MAX_PATH];
  1049.  
  1050.     while (openFileDlg(fname)) {
  1051.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1052.  
  1053.         imshow("src", img);
  1054.  
  1055.         pragBinarizare(img);
  1056.  
  1057.         waitKey(0);
  1058.     }
  1059. }
  1060.  
  1061. void calculeHisto(Mat img){
  1062.  
  1063.     imshow("Src", img);
  1064.     showHistogram("src", calculHistograma(img), 256, 200);
  1065.  
  1066.     // negativ
  1067.     Mat neg = img.clone();
  1068.     int L = 255;
  1069.  
  1070.     for (int i = 0; i < img.rows; i++)
  1071.         for (int j = 0; j < img.cols; j++)
  1072.             neg.at<uchar>(i, j) = L - img.at<uchar>(i, j);
  1073.  
  1074.     imshow("Negativ", neg);
  1075.     showHistogram("negativ", calculHistograma(neg), 256, 200);
  1076.  
  1077.     // luminozitate
  1078.     Mat lum = img.clone();
  1079.     int offset = 50;
  1080.  
  1081.     printf("Luminozitate: offset = %d\n", offset);
  1082.  
  1083.     for (int i = 0; i < img.rows; i++)
  1084.         for (int j = 0; j < img.cols; j++) {
  1085.             int aux = img.at<uchar>(i, j) + offset;
  1086.             if (aux > 255)
  1087.                 aux = 255;
  1088.             if (aux < 0)
  1089.                 aux = 0;
  1090.             lum.at<uchar>(i, j) = aux;
  1091.         }
  1092.     imshow("Luminozitate", lum);
  1093.     showHistogram("luminozitate", calculHistograma(lum), 256, 200);
  1094.  
  1095.     // corectia gamma
  1096.     Mat gam = img.clone();
  1097.     float gamma = 2;
  1098.  
  1099.     printf("Corectie gamma: gamma = %f\n", gamma);
  1100.  
  1101.     for (int i = 0; i < img.rows; i++)
  1102.         for (int j = 0; j < img.cols; j++) {
  1103.             float aux = pow((float)img.at<uchar>(i, j) / 255, gamma) * 255;
  1104.             if (aux > 255)
  1105.                 aux = 255;
  1106.             if (aux < 0)
  1107.                 aux = 0;
  1108.             gam.at<uchar>(i, j) = (int)aux;
  1109.         }
  1110.     imshow("Corectia gamma", gam);
  1111.     showHistogram("gamma", calculHistograma(gam), 256, 200);
  1112.  
  1113.     // modificarea contrastului
  1114.     int gmin = 255;
  1115.     int gmax = 0;
  1116.     int gOUTmin = 15, gOUTmax = 200;
  1117.  
  1118.     int* hist = calculHistograma(img);
  1119.  
  1120.     for (int i = 0; i < 255; i++) {
  1121.         if (hist[i] != 0 && i < gmin)
  1122.             gmin = i;
  1123.         if (hist[i] != 0 && i > gmax)
  1124.             gmax = i;
  1125.     }
  1126.  
  1127.     Mat contrast = img.clone();
  1128.  
  1129.     printf("Contrast:\n");
  1130.     printf("G in min = %d\n", gmin);
  1131.     printf("G in max = %d\n", gmax);
  1132.     printf("G out min = %d\n", gOUTmin);
  1133.     printf("G out max = %d\n", gOUTmax);
  1134.  
  1135.     for (int i = 0; i < img.rows; i++)
  1136.         for (int j = 0; j < img.cols; j++) {
  1137.             float aux = gOUTmin + (img.at<uchar>(i, j) - gmin) * (gOUTmax - gOUTmin) / (gmax - gmin);
  1138.             if (aux > 255)
  1139.                 aux = 255;
  1140.             if (aux < 0)
  1141.                 aux = 0;
  1142.             contrast.at<uchar>(i, j) = (int)aux;
  1143.         }
  1144.     imshow("Contrast", contrast);
  1145.     showHistogram("contrast", calculHistograma(contrast), 256, 200);
  1146. }
  1147.  
  1148. void testCalculeHisto(){
  1149.     char fname[MAX_PATH];
  1150.  
  1151.     while (openFileDlg(fname)) {
  1152.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1153.  
  1154.         imshow("src", img);
  1155.  
  1156.         calculeHisto(img);
  1157.  
  1158.         waitKey(0);
  1159.     }
  1160. }
  1161.  
  1162. void egalizareHisto(Mat img){
  1163.  
  1164.     int *hist = calculHistograma(img);
  1165.  
  1166.     showHistogram("histogram SRC", hist, 256, 200);
  1167.  
  1168.     int hc[256] = {};
  1169.     int tab[256] = {};
  1170.     hc[0] = 0;
  1171.  
  1172.     for (int g = 1; g < 256; g++)
  1173.         hc[g] = hc[g - 1] + hist[g];
  1174.  
  1175.     Mat dst = img.clone();
  1176.  
  1177.     int M = img.rows * img.cols;
  1178.  
  1179.     for (int g = 0; g < 256; g++)
  1180.         tab[g] = 255 * hc[g] / M;
  1181.  
  1182.     for (int i = 0; i < img.rows; i++)
  1183.         for (int j = 0; j < img.cols; j++)
  1184.             dst.at<uchar>(i, j) = tab[img.at<uchar>(i, j)];
  1185.  
  1186.     int *histDst = calculHistograma(dst);
  1187.  
  1188.     imshow("dst", dst);
  1189.     showHistogram("histogram DST", histDst, 256, 200);
  1190. }
  1191.  
  1192. void testEgalizareHisto(){
  1193.     char fname[MAX_PATH];
  1194.     while (openFileDlg(fname)) {
  1195.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1196.         imshow("src", img);
  1197.         egalizareHisto(img);
  1198.         waitKey(0);
  1199.     }
  1200. }
  1201.  
  1202. int main() {
  1203.     int op;
  1204.     do
  1205.     {
  1206.         system("cls");
  1207.         destroyAllWindows();
  1208.         printf("Menu:\n");
  1209.         printf(" 1 - Open image\n");
  1210.         printf(" 2 - Open BMP images from folder\n");
  1211.         printf(" 3 - Resize image\n");
  1212.         printf(" 4 - Process video\n");
  1213.         printf(" 5 - Snap frame from live video\n");
  1214.         printf(" 6 - Mouse callback demo\n");
  1215.         printf(" 7 - Negative image\n");
  1216.         printf(" 8 - Change color\n");
  1217.         printf(" 9 - Add\n");
  1218.         printf(" 10 - Mul\n");
  1219.         printf(" 11 - Create\n");
  1220.         printf(" 12 - Invert\n");
  1221.         printf(" 13 - Change 3 in 1\n");
  1222.         printf(" 14 - Color to gray\n");
  1223.         printf(" 15 - Gray to white and black\n");
  1224.         printf(" 16 - RGB to HSV\n");
  1225.         printf(" 17 - L3 - Histogram\n");
  1226.         printf(" 18 - L4 - Trasaturi geometrice\n");
  1227.         printf(" 19 - L5 - Draw labels\n");
  1228.         printf(" 20 - L5 - Traversare 2Pass\n");
  1229.         printf(" 21 - L6 - Contur\n");
  1230.         printf(" 22 - L6 - Reconstruire contur\n");
  1231.         printf(" 23 - L7 - Dilatare\n");
  1232.         printf(" 24 - L7 - Eroziune\n");
  1233.         printf(" 25 - L7 - Deschidere\n");
  1234.         printf(" 26 - L7 - Inchidere\n");
  1235.         printf(" 23 - L7 - Dilatare\n");
  1236.         printf(" 24 - L7 - Eroziune\n");
  1237.         printf(" 25 - L7 - Deschidere\n");
  1238.         printf(" 26 - L7 - Inchidere\n");
  1239.         printf(" 27 - L8 - Histo FDP\n");
  1240.         printf(" 28 - L8 - Binarizare\n");
  1241.         printf(" 29 - L8 - Calcule histo\n");
  1242.         printf(" 30 - L8 - Egalizare histo\n");
  1243.         printf(" 0 - Exit\n\n");
  1244.         printf("Option: ");
  1245.         scanf("%d", &op);
  1246.         switch (op)
  1247.         {
  1248.         case 1:
  1249.             testOpenImage();
  1250.             break;
  1251.         case 2:
  1252.             testOpenImagesFld();
  1253.             break;
  1254.         case 3:
  1255.             testResize();
  1256.             break;
  1257.         case 4:
  1258.             testVideoSequence();
  1259.             break;
  1260.         case 5:
  1261.             testSnap();
  1262.             break;
  1263.         case 6:
  1264.             //testMouseClick();
  1265.             break;
  1266.         case 7:
  1267.             negative_img();
  1268.             break;
  1269.         case 8:
  1270.             changeColor();
  1271.             break;
  1272.         case 9:
  1273.             add();
  1274.             break;
  1275.         case 10:
  1276.             mul();
  1277.             break;
  1278.         case 11:
  1279.             create();
  1280.             break;
  1281.         case 12:
  1282.             invert();
  1283.             break;
  1284.         case 13:
  1285.             changeColor3in1();
  1286.             break;
  1287.         case 14:
  1288.             colorToGray();
  1289.             break;
  1290.         case 15:
  1291.             grayToWB();
  1292.             break;
  1293.         case 16:
  1294.             RGBtoHSV();
  1295.             break;
  1296.         case 17:
  1297.             showHistogram("MyHist", calculHistograma(imread("Images/cameraman.bmp", CV_LOAD_IMAGE_GRAYSCALE)), 255, 200);
  1298.             break;
  1299.         case 18:
  1300.             testMouseClick();
  1301.             break;
  1302.         case 19:
  1303.             drawLabels();
  1304.             break;
  1305.         case 20:
  1306.             traversalTwoPass();
  1307.             break;
  1308.         case 21:
  1309.             findContour();
  1310.             break;
  1311.         case 22:
  1312.             reconstruct();
  1313.             break;
  1314.         case 23:
  1315.             testDilatare();
  1316.             break;
  1317.         case 24:
  1318.             testEroziune();
  1319.             break;
  1320.         case 25:
  1321.             testDeschidere();
  1322.             break;
  1323.         case 26:
  1324.             testInchidere();
  1325.             break;
  1326.         case 27:
  1327.             testHistogramaFDP();
  1328.             break;
  1329.         case 28:
  1330.             testPragBinarizare();
  1331.             break;
  1332.         case 29:
  1333.             testCalculeHisto();
  1334.             break;
  1335.         case 30:
  1336.             testEgalizareHisto();
  1337.             break;
  1338.         }
  1339.     } while (op != 0);
  1340.     return 0;
  1341. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!