SHARE
TWEET

Untitled

a guest May 20th, 2019 77 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. #include <stdio.h>
  8. #include <string>
  9.  
  10. #define WEAK 128
  11. #define STRONG 255
  12.  
  13.  
  14.  
  15. void testOpenImage()
  16. {
  17.     char fname[MAX_PATH];
  18.     while(openFileDlg(fname))
  19.     {
  20.         Mat src;
  21.         src = imread(fname);
  22.         imshow("image",src);
  23.         waitKey();
  24.     }
  25. }
  26.  
  27. void testOpenImagesFld()
  28. {
  29.     char folderName[MAX_PATH];
  30.     if (openFolderDlg(folderName)==0)
  31.         return;
  32.     char fname[MAX_PATH];
  33.     FileGetter fg(folderName,"bmp");
  34.     while(fg.getNextAbsFile(fname))
  35.     {
  36.         Mat src;
  37.         src = imread(fname);
  38.         imshow(fg.getFoundFileName(),src);
  39.         if (waitKey()==27) //ESC pressed
  40.             break;
  41.     }
  42. }
  43.  
  44. void testImageOpenAndSave()
  45. {
  46.     Mat src, dst;
  47.  
  48.     src = imread("Images/Lena_24bits.bmp", CV_LOAD_IMAGE_COLOR);    // Read the image
  49.  
  50.     if (!src.data)  // Check for invalid input
  51.     {
  52.         printf("Could not open or find the image\n");
  53.         return;
  54.     }
  55.  
  56.     // Get the image resolution
  57.     Size src_size = Size(src.cols, src.rows);
  58.  
  59.     // Display window
  60.     const char* WIN_SRC = "Src"; //window for the source image
  61.     namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  62.     cvMoveWindow(WIN_SRC, 0, 0);
  63.  
  64.     const char* WIN_DST = "Dst"; //window for the destination (processed) image
  65.     namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  66.     cvMoveWindow(WIN_DST, src_size.width + 10, 0);
  67.  
  68.     cvtColor(src, dst, CV_BGR2GRAY); //converts the source image to a grayscale one
  69.  
  70.     imwrite("Images/Lena_24bits_gray.bmp", dst); //writes the destination to file
  71.  
  72.     imshow(WIN_SRC, src);
  73.     imshow(WIN_DST, dst);
  74.  
  75.     printf("Press any key to continue ...\n");
  76.     waitKey(0);
  77. }
  78.  
  79. void testNegativeImage()
  80. {
  81.     char fname[MAX_PATH];
  82.     while(openFileDlg(fname))
  83.     {
  84.         double t = (double)getTickCount(); // Get the current time [s]
  85.        
  86.         Mat src = imread(fname,CV_LOAD_IMAGE_GRAYSCALE);
  87.         int height = src.rows;
  88.         int width = src.cols;
  89.         Mat dst = Mat(height,width,CV_8UC1);
  90.         // Asa se acceseaaza pixelii individuali pt. o imagine cu 8 biti/pixel
  91.         // Varianta ineficienta (lenta)
  92.         for (int i=0; i<height; i++)
  93.         {
  94.             for (int j=0; j<width; j++)
  95.             {
  96.                 uchar val = src.at<uchar>(i,j);
  97.                 uchar neg = MAX_PATH-val;
  98.                 dst.at<uchar>(i,j) = neg;
  99.             }
  100.         }
  101.  
  102.         // Get the current time again and compute the time difference [s]
  103.         t = ((double)getTickCount() - t) / getTickFrequency();
  104.         // Print (in the console window) the processing time in [ms]
  105.         printf("Time = %.3f [ms]\n", t * 1000);
  106.  
  107.         imshow("input image",src);
  108.         imshow("negative image",dst);
  109.         waitKey();
  110.     }
  111. }
  112.  
  113. void testParcurgereSimplaDiblookStyle()
  114. {
  115.     char fname[MAX_PATH];
  116.     while (openFileDlg(fname))
  117.     {
  118.         Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  119.         int height = src.rows;
  120.         int width = src.cols;
  121.         Mat dst = src.clone();
  122.  
  123.         double t = (double)getTickCount(); // Get the current time [s]
  124.  
  125.         // the fastest approach using the “diblook style”
  126.         uchar *lpSrc = src.data;
  127.         uchar *lpDst = dst.data;
  128.         int w = (int) src.step; // no dword alignment is done !!!
  129.         for (int i = 0; i<height; i++)
  130.             for (int j = 0; j < width; j++) {
  131.                 uchar val = lpSrc[i*w + j];
  132.                 lpDst[i*w + j] = 255 - val;
  133.             }
  134.  
  135.         // Get the current time again and compute the time difference [s]
  136.         t = ((double)getTickCount() - t) / getTickFrequency();
  137.         // Print (in the console window) the processing time in [ms]
  138.         printf("Time = %.3f [ms]\n", t * 1000);
  139.  
  140.         imshow("input image",src);
  141.         imshow("negative image",dst);
  142.         waitKey();
  143.     }
  144. }
  145.  
  146. void testColor2Gray()
  147. {
  148.     char fname[MAX_PATH];
  149.     while(openFileDlg(fname))
  150.     {
  151.         Mat src = imread(fname);
  152.  
  153.         int height = src.rows;
  154.         int width = src.cols;
  155.  
  156.         Mat dst = Mat(height,width,CV_8UC1);
  157.  
  158.         // Asa se acceseaaza pixelii individuali pt. o imagine RGB 24 biti/pixel
  159.         // Varianta ineficienta (lenta)
  160.         for (int i=0; i<height; i++)
  161.         {
  162.             for (int j=0; j<width; j++)
  163.             {
  164.                 Vec3b v3 = src.at<Vec3b>(i,j);
  165.                 uchar b = v3[0];
  166.                 uchar g = v3[1];
  167.                 uchar r = v3[2];
  168.                 dst.at<uchar>(i,j) = (r+g+b)/3;
  169.             }
  170.         }
  171.        
  172.         imshow("input image",src);
  173.         imshow("gray image",dst);
  174.         waitKey();
  175.     }
  176. }
  177.  
  178. void testBGR2HSV()
  179. {
  180.     char fname[MAX_PATH];
  181.     while (openFileDlg(fname))
  182.     {
  183.         Mat src = imread(fname);
  184.         int height = src.rows;
  185.         int width = src.cols;
  186.  
  187.         // Componentele d eculoare ale modelului HSV
  188.         Mat H = Mat(height, width, CV_8UC1);
  189.         Mat S = Mat(height, width, CV_8UC1);
  190.         Mat V = Mat(height, width, CV_8UC1);
  191.  
  192.         // definire pointeri la matricele (8 biti/pixeli) folosite la afisarea componentelor individuale H,S,V
  193.         uchar* lpH = H.data;
  194.         uchar* lpS = S.data;
  195.         uchar* lpV = V.data;
  196.  
  197.         Mat hsvImg;
  198.         cvtColor(src, hsvImg, CV_BGR2HSV);
  199.  
  200.         // definire pointer la matricea (24 biti/pixeli) a imaginii HSV
  201.         uchar* hsvDataPtr = hsvImg.data;
  202.  
  203.         for (int i = 0; i<height; i++)
  204.         {
  205.             for (int j = 0; j<width; j++)
  206.             {
  207.                 int hi = i*width * 3 + j * 3;
  208.                 int gi = i*width + j;
  209.  
  210.                 lpH[gi] = hsvDataPtr[hi] * 510 / 360;       // lpH = 0 .. 255
  211.                 lpS[gi] = hsvDataPtr[hi + 1];           // lpS = 0 .. 255
  212.                 lpV[gi] = hsvDataPtr[hi + 2];           // lpV = 0 .. 255
  213.             }
  214.         }
  215.  
  216.         imshow("input image", src);
  217.         imshow("H", H);
  218.         imshow("S", S);
  219.         imshow("V", V);
  220.  
  221.         waitKey();
  222.     }
  223. }
  224.  
  225. void testResize()
  226. {
  227.     char fname[MAX_PATH];
  228.     while(openFileDlg(fname))
  229.     {
  230.         Mat src;
  231.         src = imread(fname);
  232.         Mat dst1,dst2;
  233.         //without interpolation
  234.         resizeImg(src,dst1,320,false);
  235.         //with interpolation
  236.         resizeImg(src,dst2,320,true);
  237.         imshow("input image",src);
  238.         imshow("resized image (without interpolation)",dst1);
  239.         imshow("resized image (with interpolation)",dst2);
  240.         waitKey();
  241.     }
  242. }
  243.  
  244. void testCanny()
  245. {
  246.     char fname[MAX_PATH];
  247.     while(openFileDlg(fname))
  248.     {
  249.         Mat src,dst,gauss;
  250.         src = imread(fname,CV_LOAD_IMAGE_GRAYSCALE);
  251.         double k = 0.4;
  252.         int pH = 50;
  253.         int pL = (int) k*pH;
  254.         GaussianBlur(src, gauss, Size(5, 5), 0.8, 0.8);
  255.         Canny(gauss,dst,pL,pH,3);
  256.         imshow("input image",src);
  257.         imshow("canny",dst);
  258.         waitKey();
  259.     }
  260. }
  261.  
  262. void testVideoSequence()
  263. {
  264.     VideoCapture cap("Videos/rubic.avi"); // off-line video from file
  265.     //VideoCapture cap(0);  // live video from web cam
  266.     if (!cap.isOpened()) {
  267.         printf("Cannot open video capture device.\n");
  268.         waitKey(0);
  269.         return;
  270.     }
  271.        
  272.     Mat edges;
  273.     Mat frame;
  274.     char c;
  275.  
  276.     while (cap.read(frame))
  277.     {
  278.         Mat grayFrame;
  279.         cvtColor(frame, grayFrame, CV_BGR2GRAY);
  280.         Canny(grayFrame,edges,40,100,3);
  281.         imshow("source", frame);
  282.         imshow("gray", grayFrame);
  283.         imshow("edges", edges);
  284.         c = cvWaitKey(0);  // waits a key press to advance to the next frame
  285.         if (c == 27) {
  286.             // press ESC to exit
  287.             printf("ESC pressed - capture finished\n");
  288.             break;  //ESC pressed
  289.         };
  290.     }
  291. }
  292.  
  293.  
  294. void testSnap()
  295. {
  296.     VideoCapture cap(0); // open the deafult camera (i.e. the built in web cam)
  297.     if (!cap.isOpened()) // openenig the video device failed
  298.     {
  299.         printf("Cannot open video capture device.\n");
  300.         return;
  301.     }
  302.  
  303.     Mat frame;
  304.     char numberStr[256];
  305.     char fileName[256];
  306.    
  307.     // video resolution
  308.     Size capS = Size((int)cap.get(CV_CAP_PROP_FRAME_WIDTH),
  309.         (int)cap.get(CV_CAP_PROP_FRAME_HEIGHT));
  310.  
  311.     // Display window
  312.     const char* WIN_SRC = "Src"; //window for the source frame
  313.     namedWindow(WIN_SRC, CV_WINDOW_AUTOSIZE);
  314.     cvMoveWindow(WIN_SRC, 0, 0);
  315.  
  316.     const char* WIN_DST = "Snapped"; //window for showing the snapped frame
  317.     namedWindow(WIN_DST, CV_WINDOW_AUTOSIZE);
  318.     cvMoveWindow(WIN_DST, capS.width + 10, 0);
  319.  
  320.     char c;
  321.     int frameNum = -1;
  322.     int frameCount = 0;
  323.  
  324.     for (;;)
  325.     {
  326.         cap >> frame; // get a new frame from camera
  327.         if (frame.empty())
  328.         {
  329.             printf("End of the video file\n");
  330.             break;
  331.         }
  332.  
  333.         ++frameNum;
  334.        
  335.         imshow(WIN_SRC, frame);
  336.  
  337.         c = cvWaitKey(10);  // waits a key press to advance to the next frame
  338.         if (c == 27) {
  339.             // press ESC to exit
  340.             printf("ESC pressed - capture finished");
  341.             break;  //ESC pressed
  342.         }
  343.         if (c == 115){ //'s' pressed - snapp the image to a file
  344.             frameCount++;
  345.             fileName[0] = NULL;
  346.             sprintf(numberStr, "%d", frameCount);
  347.             strcat(fileName, "Images/A");
  348.             strcat(fileName, numberStr);
  349.             strcat(fileName, ".bmp");
  350.             bool bSuccess = imwrite(fileName, frame);
  351.             if (!bSuccess)
  352.             {
  353.                 printf("Error writing the snapped image\n");
  354.             }
  355.             else
  356.                 imshow(WIN_DST, frame);
  357.         }
  358.     }
  359.  
  360. }
  361.  
  362. void MyCallBackFunc(int event, int x, int y, int flags, void* param)
  363. {
  364.     //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  365.     Mat* src = (Mat*)param;
  366.     if (event == CV_EVENT_LBUTTONDOWN)
  367.         {
  368.             /*printf("Pos(x,y): %d,%d  Color(RGB): %d,%d,%d\n",
  369.                 x, y,
  370.                 (int)(*src).at<Vec3b>(y, x)[2],
  371.                 (int)(*src).at<Vec3b>(y, x)[1],
  372.                 (int)(*src).at<Vec3b>(y, x)[0]);*/
  373.         }
  374. }
  375.  
  376. void testMouseClick()
  377. {
  378.     Mat src;
  379.     // Read image from file
  380.     char fname[MAX_PATH];
  381.     while (openFileDlg(fname))
  382.     {
  383.         src = imread(fname);
  384.         //Create a window
  385.         namedWindow("My Window", 1);
  386.  
  387.         //set the callback function for any mouse event
  388.         setMouseCallback("My Window", MyCallBackFunc, &src);
  389.  
  390.         //show the image
  391.         imshow("My Window", src);
  392.  
  393.         // Wait until user press some key
  394.         waitKey(0);
  395.     }
  396. }
  397.  
  398. /* Histogram display function - display a histogram using bars (simlilar to L3 / PI)
  399. Input:
  400. name - destination (output) window name
  401. hist - pointer to the vector containing the histogram values
  402. hist_cols - no. of bins (elements) in the histogram = histogram image width
  403. hist_height - height of the histogram image
  404. Call example:
  405. showHistogram ("MyHist", hist_dir, 255, 200);
  406. */
  407. void showHistogram(const std::string& name, int* hist, const int  hist_cols, const int hist_height)
  408. {
  409.     Mat imgHist(hist_height, hist_cols, CV_8UC3, CV_RGB(255, 255, 255)); // constructs a white image
  410.  
  411.     //computes histogram maximum
  412.     int max_hist = 0;
  413.     for (int i = 0; i<hist_cols; i++)
  414.     if (hist[i] > max_hist)
  415.         max_hist = hist[i];
  416.     double scale = 1.0;
  417.     scale = (double)hist_height / max_hist;
  418.     int baseline = hist_height - 1;
  419.  
  420.     for (int x = 0; x < hist_cols; x++) {
  421.         Point p1 = Point(x, baseline);
  422.         Point p2 = Point(x, baseline - cvRound(hist[x] * scale));
  423.         line(imgHist, p1, p2, CV_RGB(255, 0, 255)); // histogram bins colored in magenta
  424.     }
  425.  
  426.     imshow(name, imgHist);
  427. }
  428.  
  429. //************* lab 1 **************
  430.  
  431. void negative_image()
  432. {
  433.     Mat img = imread("Images/cameraman.bmp",CV_LOAD_IMAGE_GRAYSCALE);
  434.  
  435.     for (int i = 0; i<img.rows; i++) {
  436.        
  437.         for (int j = 0; j<img.cols; j++) {
  438.            
  439.             img.at<uchar>(i, j) = 255 - img.at<uchar>(i, j);
  440.         }
  441.     }
  442.  
  443.     imshow("negative image", img);
  444.     waitKey(0);
  445.  
  446. }
  447.  
  448. //Implementaţi o funcţie care schimbă nivelele de gri cu un factor aditiv
  449. void changeGray(int factor)
  450. {
  451.     char fname[MAX_PATH];
  452.     while (openFileDlg(fname))
  453.     {
  454.         Mat src;
  455.        
  456.         src = imread(fname,CV_LOAD_IMAGE_GRAYSCALE);
  457.         Mat img(src.rows, src.cols, CV_8UC1);
  458.  
  459.         for (int i = 0; i < src.rows; i++)
  460.         {
  461.             for (int j = 0; j < src.cols; j++)
  462.             {
  463.                
  464.                 if (src.at<uchar>(i, j) + factor > 255)
  465.                 {
  466.                     img.at<uchar>(i, j) = 255;
  467.                 }
  468.                 else {
  469.                     img.at<uchar>(i, j) =src.at<uchar>(i,j)+ factor;
  470.                 }
  471.             }
  472.         }
  473.         imshow("Imagine", src);
  474.         imshow("Imagine schimbata", img);
  475.         waitKey(0);
  476.     }
  477. }
  478.  
  479. //Implementaţi o funcţie care schimbă nivelele de gri cu un factor multiplicativ. Salvaţi
  480. //imaginea rezultat.
  481.  
  482. void changeGrayMulti(int factor)
  483. {
  484.     char fname[MAX_PATH];
  485.     while (openFileDlg(fname))
  486.     {
  487.         Mat src;
  488.         src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  489.  
  490.         Mat img(src.rows, src.cols, CV_8UC1);
  491.  
  492.         for (int i = 0; i < src.rows; i++)
  493.         {
  494.             for (int j = 0; j < src.cols; j++)
  495.             {
  496.  
  497.                 if (src.at<uchar>(i, j) * factor > 255)
  498.                 {
  499.                     img.at<uchar>(i, j) = 255;
  500.                 }
  501.                 else {
  502.                     img.at<uchar>(i,j)=src.at<uchar>(i, j) * factor;
  503.                 }
  504.             }
  505.         }
  506.         imshow("Imagine", src);
  507.         imshow("Imagine schimbata", img);
  508.         waitKey(0);
  509.         imwrite("Imagine.png", img);
  510.     }
  511. }
  512.  
  513.  
  514.  
  515. /*Creaţi o imagine color de dimensiune 256 x 256. Împărţiţi imaginea în 4 sectoare pătrate,
  516. şi coloraţi aceste sectoare, din stânga-sus până în dreapta-jos, astfel: alb, roşu, verde,
  517. galben.*/
  518.  
  519. void patruSectoare()
  520. {
  521.     Mat img(256, 256, CV_8UC3);
  522.  
  523.     for (int i = 0; i < img.rows; i++)
  524.     {
  525.         for (int j = 0; j < img.cols; j++)
  526.         {
  527.  
  528.             if (i < img.rows/2 && j < img.cols/2)
  529.             {
  530.                 img.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
  531.             }
  532.  
  533.             if (i<img.rows/2 && j>img.cols/2)
  534.             {
  535.                 img.at<Vec3b>(i, j) = Vec3b(0, 0, 255);
  536.             }
  537.  
  538.             if (i>img.rows/2 && j<img.cols/2)
  539.             {
  540.                 img.at<Vec3b>(i, j) = Vec3b(0, 255,0);
  541.             }
  542.  
  543.             if (i>img.rows/2 && j>img.cols/2)
  544.             {
  545.                 img.at<Vec3b>(i, j) = Vec3b(0, 255, 255);
  546.             }
  547.  
  548.         }
  549.     }
  550.  
  551.     imshow("Imagine", img);
  552.     waitKey(0);
  553.  
  554. }
  555.  
  556. void inv()
  557. {
  558.    
  559.  
  560. }
  561.  
  562. //***************** LAB 2 *************************
  563. void copiazaCanale()
  564. {
  565.  
  566.     char fname[MAX_PATH];
  567.     while (openFileDlg(fname))
  568.     {
  569.         Mat src;
  570.  
  571.         src = imread(fname,CV_LOAD_IMAGE_COLOR);
  572.         Mat img1(src.rows, src.cols, CV_8UC1);
  573.         Mat img2(src.rows, src.cols, CV_8UC1);
  574.         Mat img3(src.rows, src.cols, CV_8UC1);
  575.  
  576.         for (int i = 0; i < src.rows; i++)
  577.         {
  578.             for (int j = 0; j < src.cols; j++)
  579.             {
  580.                 img1.at<uchar>(i, j) = src.at<Vec3b>(i, j)[2];
  581.                 img2.at<uchar>(i, j) = src.at<Vec3b>(i, j)[1];
  582.                 img3.at<uchar>(i, j) = src.at<Vec3b>(i, j)[0];
  583.             }
  584.         }
  585.  
  586.         imshow("Imagine", src);
  587.         imshow("Imagine1", img1);
  588.         imshow("Imagine2", img2);
  589.         imshow("Imagine3", img3);
  590.         waitKey(0);
  591.  
  592.     }
  593.  
  594. }
  595.  
  596. void colorToGray()
  597. {
  598.     char fname[MAX_PATH];
  599.     while (openFileDlg(fname))
  600.     {
  601.         Mat src;
  602.  
  603.         src = imread(fname, CV_LOAD_IMAGE_COLOR);
  604.         Mat an(src.rows, src.cols, CV_8UC1);
  605.         for (int i = 0; i < src.rows; i++)
  606.         {
  607.             for (int j = 0; j < src.cols; j++)
  608.             {
  609.                 an.at<uchar>(i, j) = (src.at<Vec3b>(i, j)[0] + src.at<Vec3b>(i, j)[1] + src.at<Vec3b>(i, j)[2]) / 3;
  610.             }
  611.         }
  612.  
  613.         imshow("Imagine", src);
  614.         imshow("GreyScale", an);
  615.         waitKey(0);
  616.  
  617.     }
  618. }
  619.  
  620. void grayToALb()
  621. {
  622.     char fname[MAX_PATH];
  623.     while (openFileDlg(fname))
  624.     {
  625.         Mat src;
  626.  
  627.         src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  628.         int prag;
  629.         std::cout << " Prag: " << std::endl;
  630.         std::cin >> prag;
  631.            
  632.         Mat an(src.rows, src.cols, CV_8UC1);
  633.         for (int i = 0; i < src.rows; i++)
  634.         {
  635.             for (int j = 0; j < src.cols; j++)
  636.             {
  637.                 if (src.at<uchar>(i, j) < prag)
  638.                 {
  639.                     an.at<uchar>(i, j) = 0;
  640.                 }
  641.  
  642.                 if (src.at<uchar>(i, j) >= prag)
  643.                 {
  644.                     an.at<uchar>(i, j) = 255;
  645.                 }
  646.  
  647.             }
  648.         }
  649.  
  650.         imshow("Imagine", src);
  651.         imshow("Alb-Negru", an);
  652.     }
  653. }
  654.  
  655.  
  656. void convertHSV()
  657. {
  658.     float r, g, b, R, G, B, m, M,C, H, S, V;
  659.     char fname[MAX_PATH];
  660.     while (openFileDlg(fname))
  661.     {
  662.         Mat src;
  663.  
  664.         src = imread(fname, CV_LOAD_IMAGE_COLOR);
  665.         Mat img1(src.rows, src.cols, CV_8UC1);
  666.         Mat img2(src.rows, src.cols, CV_8UC1);
  667.         Mat img3(src.rows, src.cols, CV_8UC1);
  668.  
  669.         for (int i = 0; i < src.rows; i++)
  670.         {
  671.             for (int j = 0; j < src.cols; j++)
  672.             {
  673.                 R = (float)src.at<Vec3b>(i, j)[2];
  674.                 r = R / 255;
  675.  
  676.                 B = (float)src.at<Vec3b>(i, j)[0];
  677.                 b = B / 255;
  678.  
  679.                 G = (float)src.at<Vec3b>(i, j)[1];
  680.                 g = G / 255;
  681.  
  682.                 M = max(r, g, b);
  683.                 m = min(r, g, b);
  684.                 C = M - m;
  685.  
  686.                 V = M;
  687.                 if (V != 0) S = C / V;
  688.                 else S = 0;
  689.  
  690.                 if (C != 0){
  691.                     if (M == r) H = 60 * (g - b) / C;
  692.                     if (M == g) H = 120 + 60 * (b - r) / C;
  693.                     if (M == b) H = 240 + 60 * (r - g) / C;
  694.                 }
  695.                 else H = 0;
  696.                 if (H < 0) H = H + 360;
  697.  
  698.                 img1.at<uchar>(i, j) = H * 255 / 360;
  699.                 img2.at<uchar>(i, j) = S * 255;
  700.                 img3.at<uchar>(i, j) = V * 255;
  701.             }
  702.         }
  703.  
  704.         imshow("Imagine", src);
  705.         imshow("Hue", img1);
  706.         imshow("Saturation", img2);
  707.         imshow("Value", img3);
  708.         waitKey(0);
  709.     }
  710.  
  711. }
  712.  
  713. void isInside(Mat img, int i,int j)
  714. {
  715.     if (img.rows > i && i >= 0)
  716.    
  717.         if (img.cols > j && j >= 0)
  718.        
  719.             std::cout << "SE AFLA IN INTERIOR";
  720.    
  721.     getchar();
  722.     getchar();
  723. }
  724.  
  725.  
  726. //***************** LAB 3 *************
  727.  
  728. void DrawCross(Mat& img, Point p, int size, Scalar color, int thickness)
  729. {
  730.     line(img, Point(p.x - size / 2, p.y), Point(p.x + size / 2, p.y), color, thickness, 8);
  731.     line(img, Point(p.x, p.y - size / 2), Point(p.x, p.y + size / 2), color, thickness, 8);
  732. }
  733.  
  734.  
  735. void proprietati(int event, int x, int y, int flags, void* param)
  736. {
  737.     //More examples: http://opencvexamples.blogspot.com/2014/01/detect-mouse-clicks-and-moves-on-image.html
  738.     Mat* src = (Mat*)param;
  739.     Vec3b culoare;
  740.     int aria = 0;
  741.     int ri = 0;
  742.     int ci = 0;
  743.     int perim = 0;
  744.     float phi = 0;
  745.     int factor = 0;
  746.     int a = 0, a1 = 0, a2 = 0;
  747.     int rmax = 0,cmax=0;
  748.     int rmin = (*src).rows;
  749.     int cmin = (*src).cols;
  750.  
  751.     Mat img1((*src).rows, (*src).cols, CV_8UC3);
  752.    
  753.     for (int i = 0; i < (*src).rows; i++)
  754.     {
  755.         for (int j = 0; j < (*src).cols; j++)
  756.         {
  757.             img1.at<Vec3b>(i, j) = (*src).at<Vec3b>(i, j);
  758.         }
  759.     }
  760.  
  761.  
  762.     if (event == CV_EVENT_LBUTTONDOWN)
  763.     {
  764.        
  765.         culoare = (*src).at<Vec3b>(y, x);
  766.    
  767.  
  768.         for (int i = 0; i < (*src).rows; i++)
  769.         {
  770.             for (int j = 0; j < (*src).cols; j++)
  771.             {
  772.                 if ((*src).at<Vec3b>(i,j) == culoare)
  773.                 {
  774.                     if (i >= rmax)
  775.                     {
  776.                         rmax = i;
  777.                     }
  778.                     else if (i <= rmin)
  779.                     {
  780.                         rmin = i;
  781.                     }
  782.                     if (j>=cmax)
  783.                     {
  784.                         cmax = j;
  785.                     }
  786.                     else if (j <= cmin)
  787.                     {
  788.                         cmin = j;
  789.                     }
  790.                     aria++;
  791.                     ri += i;
  792.                     ci += j;
  793.                 }
  794.             }
  795.         }
  796.         ri =  ri/aria;
  797.         ci =  ci/ aria;
  798.  
  799.         for (int i = 0; i < (*src).rows; i++)
  800.         {
  801.             for (int j = 0; j < (*src).cols; j++)
  802.             {
  803.                 if ((*src).at<Vec3b>(i, j) == culoare)
  804.                 {
  805.                     a += (i - ri)*(j - ci);
  806.                     a1 += (j - ci)*(j - ci);
  807.                     a2 += (i - ri)*(i - ri);
  808.                 }
  809.             }
  810.         }
  811.        
  812.      phi = atan2(2*a, (a1 - a2))/2;
  813.  
  814.      for (int i = 0; i < (*src).rows; i++)
  815.      {
  816.          for (int j = 0; j < (*src).cols; j++)
  817.          {
  818.              if ((*src).at<Vec3b>(i, j) == culoare)
  819.              {
  820.                  if ((*src).at<Vec3b>(i - 1, j - 1) != culoare || (*src).at<Vec3b>(i - 1, j) != culoare
  821.                      || (*src).at<Vec3b>(i - 1, j + 1) != culoare || (*src).at<Vec3b>(i, j - 1) != culoare
  822.                      || (*src).at<Vec3b>(i, j + 1) != culoare || (*src).at<Vec3b>(i + 1, j) != culoare
  823.                      || (*src).at<Vec3b>(i + 1, j - 1) != culoare || (*src).at<Vec3b>(i + 1, j + 1) != culoare){
  824.                      perim++;
  825.                      img1.at<Vec3b>(i, j) = Vec3b(0, 0, 0);
  826.  
  827.                  }
  828.              }
  829.          }
  830.  
  831.  
  832.      }
  833.  
  834.  
  835.  
  836.      float factor = 4 *PI*aria / (perim*perim);
  837.      float aspect = (cmax - cmin + 1) / (rmax - rmin + 1);
  838.  
  839.      DrawCross(img1, Point(ci, ri), 20, Scalar(255, 255, 255), 2);
  840.  
  841.      int delta = 30; // arbitrary value
  842.      Point P1, P2;
  843.      P1.x = ci - delta;
  844.      P1.y = ri - (int)(delta*tan(phi)); // teta is the elongation angle in radians
  845.      P2.x = ci + delta;
  846.      P2.y = ri + (int)(delta*tan(phi));
  847.      line(img1, P1, P2, Scalar(0, 0, 0), 1, 8);
  848.  
  849.  
  850.     std::cout << "Aria este : " << aria << std::endl;
  851.     std::cout << " Centrul de masa este:  " << ri << " + " << ci << std::endl;
  852.     std::cout << "Axa de alungire : " << phi*180/PI<< std::endl;
  853.     std::cout << "Perimetru este : " << perim << std::endl;
  854.     std::cout << "Subtiere : " << factor<< std::endl;
  855.     std::cout << " Aspect ratio : " << aspect<< std::endl;
  856.  
  857.  
  858.     /*Mat dest((*src).rows, (*src).cols, CV_8UC3);
  859.     int x_vec[500] = {0};
  860.     int y_vec[500] = {0};
  861.     for (int i = 0; i < (*src).rows; i++) {
  862.         int value = 0;
  863.         for (int j = 0; j < (*src).cols; j++) {
  864.  
  865.             if ((*src).at<Vec3b>(i, j) == culoare) {
  866.                 value++;
  867.             }
  868.         }
  869.         x_vec[i] = value;
  870.     }
  871.  
  872.  
  873.     for (int i = 0; i < (*src).cols; i++) {
  874.         int value = 0;
  875.         for (int j = 0; j < (*src).rows; j++) {
  876.             if ((*src).at<Vec3b>( j,i) == culoare) {
  877.                 value++;
  878.             }
  879.         }
  880.         y_vec[i] = value;
  881.     }
  882.  
  883.  
  884.        
  885.         h[i] = value; k < dest.cols; k++) {
  886.         line(dest, Point(k, 0), Point(k, y_vec[k]), 5);
  887.     }
  888.     for (int k = 0; k < dest.rows; k++) {
  889.         line(dest, Point(k, 0), Point(k, x_vec[k]), 5);
  890.     }*/
  891.  
  892.  
  893.     Mat dst2 = (*src).clone();
  894.     Mat proj = Mat((*src).size(), CV_8UC3);
  895.  
  896.     int horizontalProj[1000] = { 0 };
  897.     int verticalProj[1000] = { 0 };
  898.  
  899.  
  900.     for (int i = 0; i < dst2.rows; i++) {
  901.         for (int j = 0; j < dst2.cols; j++) {
  902.             if (dst2.at<Vec3b>(i, j)==culoare) {
  903.                 horizontalProj[j]++;
  904.                 verticalProj[i]++;
  905.             }
  906.         }
  907.     }
  908.  
  909.     for (int j = 0; j < dst2.cols; j++) {
  910.         line(proj, Point(j, 0), Point(j, horizontalProj[j]), Scalar(255, 255, 255), 3);
  911.     }
  912.  
  913.     for (int i = 0; i < dst2.rows; i++) {
  914.         line(proj, Point(0, i), Point(verticalProj[i], i), Scalar(255, 255, 255), 3);
  915.     }
  916.  
  917.  
  918.     imshow("Proiectii", proj);
  919.  
  920.    
  921.  
  922.  
  923.  
  924.     imshow("Perimetru", img1);
  925.  
  926.  
  927.  
  928.  
  929.  
  930.  
  931.    
  932.     }
  933.  
  934.    
  935.     //imshow("1", img1);
  936.     //waitKey(0);
  937. }
  938.  
  939. void testMouseClickProprietati()
  940. {
  941.     Mat src;
  942.     // Read image from file
  943.    
  944.     src = imread("Obiecte multiple\\trasaturi_geom.bmp",CV_LOAD_IMAGE_COLOR);
  945.         //Create a window
  946.         namedWindow("My Window", 1);
  947.  
  948.         //set the callback function for any mouse event
  949.         setMouseCallback("My Window", proprietati, &src);
  950.  
  951.         //show the image
  952.         imshow("My Window", src);
  953.  
  954.         // Wait until user press some key
  955.         waitKey(0);
  956. }
  957.  
  958. /////////////////// LAB 5 ////////////////////
  959.  
  960. void traversare()
  961. {
  962.     Mat src = imread("Images/labeling2.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  963.     Mat labels = Mat::zeros(src.rows, src.cols, CV_16SC1);
  964.     Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
  965.  
  966.     int di[8] = {-1, 0, 1, 0 ,1,-1,1,-1};
  967.     int dj[8] = { 0, -1, 0, 1 ,1,1,-1,-1};
  968.    
  969.  
  970.    
  971.  
  972.     int label = 0;
  973.  
  974.     for (int i = 0; i < src.rows; i++)
  975.     {
  976.         for (int j = 0; j < src.cols; j++)
  977.         {
  978.             if (src.at<uchar>(i, j) == 0 && labels.at<short>(i, j) == 0)
  979.             {   std::queue<Point2i> Q;
  980.                 label++;
  981.                 Q.push({i, j});
  982.                 labels.at<short>(i, j) = label;
  983.                 while (!Q.empty())
  984.                 {
  985.                     Point q = Q.front();
  986.                     Q.pop();
  987.                     for (int k = 0; k < 8; k++)
  988.                     {
  989.                         if ( src.at<uchar>(q.x + di[k], q.y + dj[k]) == 0 && labels.at<short>(q.x + di[k], q.y + dj[k]) == 0)
  990.                         {
  991.                             labels.at<short>(q.x + di[k], q.y + dj[k]) = label;
  992.                             Q.push({ q.x + di[k], q.y + dj[k] });
  993.                         }
  994.                     }
  995.                 }
  996.             }
  997.         }
  998.     }
  999.  
  1000.     Scalar colorLUT[1000] = { 0 };
  1001.     Scalar color;
  1002.     for (int i = 1; i < 1000; i++)
  1003.     {
  1004.         Scalar color(rand() & 255, rand() & 255, rand() & 255);
  1005.         colorLUT[i] = color;
  1006.     }
  1007.     colorLUT[0] = Scalar(255, 255, 255);
  1008.     for (int i = 1; i < dst.rows - 1; i++)
  1009.         for (int j = 1; j < dst.cols - 1; j++)
  1010.         {
  1011.             Scalar color = colorLUT[labels.at<short>(i, j)]; // valabil pt. Met. 1 BFS
  1012.             dst.at<Vec3b>(i, j)[0] = color[0];
  1013.             dst.at<Vec3b>(i, j)[1] = color[1];
  1014.             dst.at<Vec3b>(i, j)[2] = color[2];
  1015.         }
  1016.  
  1017.     imshow("img", dst);
  1018.     waitKey(0);
  1019.  
  1020.  
  1021.  
  1022.  
  1023. }
  1024.  
  1025. void alg2()
  1026. {
  1027.     Mat src = imread("Images/labeling2.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  1028.     Mat labels = Mat::zeros(src.rows, src.cols, CV_16SC1);
  1029.     Mat dstP = Mat::zeros(src.rows, src.cols, CV_8UC3);
  1030.     Mat dstF = Mat::zeros(src.rows, src.cols, CV_8UC3);
  1031.  
  1032.     int di[4] = { -1,-1,-1,0  };
  1033.     int dj[4] = { -1,0,1,-1 };
  1034.  
  1035.     int label = 0;
  1036.  
  1037.     std::vector<std::vector<int>> edges;
  1038.    
  1039.     for (int i = 0; i < src.rows; i++)
  1040.     {
  1041.         for (int j = 0; j < src.cols; j++)
  1042.         {
  1043.             if (src.at<uchar>(i, j) == 0 && labels.at<short>(i, j) == 0)
  1044.             {
  1045.                 std::vector<int> L;
  1046.                 for (int k = 0; k < 4; k++)
  1047.                 {
  1048.                     if (labels.at<short>(i + di[k], j + dj[k]) > 0)
  1049.                     {
  1050.                         L.push_back(labels.at<short>(i + di[k], j + dj[k]));
  1051.                     }
  1052.                 }
  1053.                 if (L.size() == 0)
  1054.                 {
  1055.                     label++;
  1056.                     labels.at<short>(i, j) = label;
  1057.                 }
  1058.                 else
  1059.                 {
  1060.                     int x = *min_element(L.begin(), L.end());
  1061.                     labels.at<short>(i, j) = x;
  1062.                     for (int y :L)
  1063.                     {
  1064.                         if (L[y] != x)
  1065.                         {
  1066.                             edges.resize(label + 1);
  1067.                             edges[x].push_back(y);
  1068.                             edges[y].push_back(x);
  1069.  
  1070.                         }
  1071.                     }
  1072.                 }
  1073.             }
  1074.         }
  1075.     }
  1076.  
  1077.  
  1078.     int newlabel = 0;
  1079.    
  1080.     int* newlabels = (int*)calloc(label+1, sizeof(int));
  1081.     for (int i = 1; i <= label; i++)
  1082.     {
  1083.         if (newlabels[i] == 0)
  1084.         {
  1085.             newlabel++;
  1086.             std::queue<int> Q;
  1087.             newlabels[i] = newlabel;
  1088.             Q.push(i);
  1089.             while (!Q.empty())
  1090.             {
  1091.                 int x = Q.front();
  1092.                 Q.pop();
  1093.                 for (int t:edges[x])
  1094.                 {
  1095.                    
  1096.                     if (newlabels[t] == 0)
  1097.                     {
  1098.                         newlabels[t] = newlabel;
  1099.                         Q.push(t);
  1100.                     }
  1101.                 }
  1102.             }
  1103.         }
  1104.     }
  1105.  
  1106.  
  1107.    
  1108.  
  1109.     free(newlabels);
  1110.  
  1111. }
  1112.  
  1113. ////////////////// LAB 6 ////////////////////////////////
  1114.  
  1115.  
  1116.  
  1117.  
  1118. typedef struct {
  1119.     int i, j;   // coordonata pixelului de contur
  1120.     byte c; //codul inlantuit
  1121. }point;
  1122.  
  1123.  
  1124. void  border()
  1125. {
  1126.     char fname[MAX_PATH];
  1127.     while (openFileDlg(fname))
  1128.     {
  1129.         int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 }; // rand (coordonata orizontala)
  1130.         int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 }; // coloana (coordonata verticala)
  1131.  
  1132.         Mat src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1133.         int height = src.rows;
  1134.         int width = src.cols;
  1135.  
  1136.         Mat dst = Mat(height, width, CV_8UC1, Scalar(255));
  1137.  
  1138.  
  1139.         std::vector <point> contur;
  1140.         Point start;
  1141.         bool primul = false;
  1142.         for (int i = 0; (i < height) && primul == false; i++)
  1143.         {
  1144.             for (int j = 0; j < width; j++)
  1145.             {
  1146.                 if (src.at<uchar>(i, j) == 0)
  1147.                 {
  1148.                     dst.at<uchar>(i, j) = 0;
  1149.                     start = { i, j };
  1150.                     primul = true;
  1151.                     break;
  1152.  
  1153.                 }
  1154.             }
  1155.  
  1156.         }
  1157.         int dir = 7;
  1158.         contur.push_back(point{ start.x, start.y,7 });
  1159.         int n = 0;
  1160.         bool finish = false;
  1161.  
  1162.         int i = start.x;
  1163.         int j = start.y;
  1164.  
  1165.        
  1166.         while (!finish)
  1167.         {
  1168.  
  1169.             if (dir % 2 == 0) {
  1170.                 dir = (dir + 7) % 8;
  1171.             }else
  1172.             {
  1173.                 dir = (dir + 6) % 8;
  1174.  
  1175.             }
  1176.  
  1177.            
  1178.            
  1179.             while(src.at<uchar>(i+di[dir],j+dj[dir])!=0)
  1180.             {
  1181.  
  1182.                 dir = dir + 1;
  1183.                 if (dir == 8) {
  1184.                     dir = 0;
  1185.                 }
  1186.             }
  1187.            
  1188.             contur.push_back(point{ i + di[dir], j + dj[dir], (byte)dir });
  1189.             i += di[dir];
  1190.             j += dj[dir];
  1191.  
  1192.  
  1193.             n++;
  1194.  
  1195.             if (n > 2 && contur.at(0).i == contur.at(n - 1).i && contur.at(0).j == contur.at(n - 1).j && contur.at(1).i == contur.at(n).i && contur.at(1).j == contur.at(n).j) {
  1196.                 finish = true;
  1197.             }
  1198.         }
  1199.  
  1200.         int d;
  1201.         printf("cod inlantuit: ");
  1202.         for (int i = 1; i < contur.size() - 1; i++)
  1203.         {
  1204.  
  1205.             dst.at<uchar>(contur.at(i).i, contur.at(i).j) = 0;
  1206.             printf("%d ", contur.at(i).c);
  1207.  
  1208.         }
  1209.         printf("\n\n");
  1210.  
  1211.         printf("derivata : ");
  1212.  
  1213.         for (int i = 0; i < contur.size() - 1; i++)
  1214.         {
  1215.  
  1216.             //calcularea derivatei
  1217.             d = (8 + contur.at(i + 1).c - contur.at(i).c) % 8;
  1218.             printf("%d ", d);
  1219.         }
  1220.  
  1221.         printf("\n\n");
  1222.  
  1223.         imshow("contur imagine", dst);
  1224.         waitKey(0);
  1225.     }
  1226.  
  1227. }
  1228.  
  1229.  
  1230.  
  1231.  
  1232.  
  1233.  
  1234. void reconstruct()
  1235. {
  1236.     FILE* fp = fopen("Images/reconstruct.txt", "rt");
  1237.     if (!fp)
  1238.     {
  1239.         printf("Error opening the text file!\n");
  1240.     }
  1241.  
  1242.     int x, y, N, v;
  1243.     fscanf(fp, "%d", &x);
  1244.     fscanf(fp, "%d", &y);
  1245.     fscanf(fp, "%d", &N);
  1246.  
  1247.     std::vector<int> vectorint;
  1248.  
  1249.     for (int i = 0; i < N; i++)
  1250.     {
  1251.         fscanf(fp, "%d", &v);
  1252.         vectorint.push_back(v);
  1253.     }
  1254.  
  1255.     printf("%d %d \n %d \n", x, y, N);
  1256.  
  1257.    
  1258.     Mat img = imread("Images/gray_background.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  1259.     Mat dst = Mat(img.rows, img.cols, CV_8UC1, Scalar(255));
  1260.  
  1261.  
  1262.     int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 }; // rand (coordonata orizontala)
  1263.     int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 }; // coloana (coordonata verticala)
  1264.  
  1265.    
  1266.     for (int i = 0; i < vectorint.size(); i++)
  1267.     {
  1268.         dst.at<uchar>(x, y) = 0;
  1269.         x += di[vectorint.at(i)];
  1270.         y += dj[vectorint.at(i)];
  1271.  
  1272.  
  1273.     }
  1274.     imshow("dst", dst);
  1275.     waitKey(0);
  1276.  
  1277.  
  1278. }
  1279.  
  1280. /////////////////////////// LAB 7 /////////////////////
  1281.  
  1282. Mat dilatare(Mat src)
  1283. {
  1284.  
  1285.     Mat dst = src.clone();
  1286.     int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  1287.     int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  1288.  
  1289.     for (int i = 1; i < src.rows - 1; i++)
  1290.     {
  1291.         for (int j = 1; j < src.cols - 1; j++)
  1292.         {
  1293.             if (src.at<uchar>(i, j) == 0)
  1294.                 for (int l = 0; l < 8; l++)
  1295.                 {
  1296.                     dst.at<uchar>(di[l] + i, dj[l] + j) = 0;
  1297.                 }
  1298.         }
  1299.        
  1300.     }
  1301.    
  1302.     imshow("Imagine dilatata", dst);
  1303.    
  1304.     waitKey(0);
  1305.     return dst;
  1306. }
  1307.  
  1308. Mat eroziune(Mat src)
  1309. {
  1310.     Mat dst = src.clone();
  1311.     int dj[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
  1312.     int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
  1313.  
  1314.     for (int i = 1; i < src.rows - 1; i++)
  1315.     {
  1316.         for (int j = 1; j < src.cols - 1; j++)
  1317.         {
  1318.             if (src.at<uchar>(i, j) == 0)
  1319.                 for (int l = 0; l < 8; l++)
  1320.                 {
  1321.                     if (src.at<uchar>(di[l] + i, dj[l] + j) == 255){
  1322.                         dst.at<uchar>(i, j) = 255;
  1323.                         break;
  1324.                        
  1325.                     }
  1326.                 }
  1327.         }
  1328.     }
  1329.             imshow("Imagine erodata", dst);
  1330.            
  1331.                 waitKey(0);
  1332.             return dst;
  1333.        
  1334. }
  1335.  
  1336. Mat inchidere(Mat src)
  1337. {
  1338.    
  1339.     Mat dilatata = dilatare(src);
  1340.    
  1341.     Mat erodata = eroziune(dilatata);
  1342.  
  1343.     imshow("Imagine finala",erodata);
  1344.     waitKey(0);
  1345.     return erodata;
  1346.    
  1347. }
  1348.  
  1349. void inchidereapelNori(int n)
  1350. {
  1351.     Mat src = imread("Images/4_Close/phn1thr1_bw.bmp", 0);
  1352.     imshow("src", src);
  1353.     getchar();
  1354.    
  1355.  
  1356.     for (int i = 0; i < n; i++)
  1357.     {
  1358.         src = inchidere(src);
  1359.     }
  1360.     imshow("Final", src);
  1361.     waitKey(0);
  1362. }
  1363.  
  1364. Mat deschidere(Mat src)
  1365. {
  1366.    
  1367.  
  1368.     Mat erodata = eroziune(src);
  1369.     Mat dilatata = dilatare(erodata);
  1370.     imshow("Imagine finala", dilatata);
  1371.     //imshow("Imagine originala", src);
  1372.    
  1373.     waitKey(0);
  1374.     return erodata;
  1375. }
  1376.  
  1377. void deschhidereapelNori(int n)
  1378. {
  1379.     Mat src = imread("Images/3_Open/cel4thr3_bw.bmp", 0);
  1380.     imshow("src", src);
  1381.    
  1382.  
  1383.  
  1384.     for (int i = 0; i < n; i++)
  1385.     {
  1386.         src = deschidere(src);
  1387.     }
  1388.     imshow("Final", src);
  1389.     waitKey(0);
  1390. }
  1391.  
  1392. void dilatare_apelNori(int n)
  1393. {
  1394.     Mat src = imread("Images/1_Dilate/mon1thr1_bw.bmp", 0);
  1395.     imshow("src", src);
  1396.    
  1397.  
  1398.     for (int i = 0; i < n; i++)
  1399.     {
  1400.         src = dilatare(src);
  1401.     }
  1402.     imshow("Final", src);
  1403.     waitKey(0);
  1404.  
  1405. }
  1406.  
  1407. void eroziune_apelNori(int n)
  1408. {
  1409.     Mat src = imread("Images/1_Dilate/mon1thr1_bw.bmp", 0);
  1410.     imshow("src", src);
  1411.    
  1412.  
  1413.     for (int i = 0; i < n; i++)
  1414.     {
  1415.         src = eroziune(src);
  1416.     }
  1417.     imshow("Final", src);
  1418.     waitKey(0);
  1419. }
  1420. void contur()
  1421. {
  1422.     Mat src = imread("Images/5_BoundaryExtraction/wdg2thr3_bw.bmp", 0);
  1423.     Mat dst = src.clone();
  1424.     imshow("src", src);
  1425.     Mat temp = eroziune(src);
  1426.  
  1427.    
  1428.     for (int i = 0; i < src.rows; i++)
  1429.     {
  1430.         for (int j = 0; j < src.cols; j++)
  1431.         {
  1432.             if (src.at<uchar>(i, j) != temp.at<uchar>(i, j))
  1433.                 dst.at<uchar>(i, j) = 0;//FG
  1434.             else dst.at<uchar>(i, j) = 255;//BG
  1435.         }
  1436.     }
  1437.  
  1438.     imshow("Imagine originala", src);
  1439.     imshow("Contur", dst);
  1440.     waitKey(0);
  1441. }
  1442.  
  1443. void umplere_regiuni(int x, int y)
  1444. {
  1445.    
  1446.     Mat src = imread("Images/6_RegionFilling/reg1neg1_bw.bmp", 0);
  1447.     Mat compl = Mat(src.rows, src.cols, CV_8UC1, Scalar(255));
  1448.     Mat X1 = Mat(src.rows, src.cols, CV_8UC1, Scalar(255));
  1449.     Mat X2 = Mat(src.rows, src.cols, CV_8UC1, Scalar(255));
  1450.     Mat dst = Mat(src.rows, src.cols, CV_8UC1, Scalar(255));
  1451.     Mat temp;
  1452.     bool finish = false;
  1453.  
  1454.    
  1455.  
  1456.     for (int i = 0; i < src.rows; i++)
  1457.     {
  1458.         for (int j = 0; j < src.cols; j++)
  1459.         {
  1460.             compl.at<uchar>(i, j) = 255 - src.at<uchar>(i, j);
  1461.         }
  1462.     }
  1463.    
  1464.  
  1465.  
  1466.    
  1467.     for (int i = 0; i < src.rows; i++)
  1468.     {
  1469.         for (int j = 0; j < src.cols; j++)
  1470.         {
  1471.             if (i == x&&y == j)
  1472.             {
  1473.                 X1.at<uchar>(i, j) = 0;
  1474.             }
  1475.         }
  1476.     }
  1477.  
  1478.    
  1479.  
  1480.     do
  1481.     {
  1482.         finish = true;
  1483.         temp = dilatare(X1);
  1484.        
  1485.  
  1486.         for (int i = 0; i < src.rows; i++)
  1487.         {
  1488.             for (int j = 0; j < src.cols; j++)
  1489.             {
  1490.                 if (temp.at<uchar>(i, j) == compl.at<uchar>(i, j))
  1491.                 {
  1492.                     X2.at<uchar>(i, j) = temp.at<uchar>(i, j);
  1493.                 }
  1494.                 else
  1495.                 {
  1496.                     X2.at<uchar>(i, j) = 255;
  1497.                 }
  1498.             }
  1499.         }
  1500.         for (int i = 0; i < src.rows; i++)
  1501.         {
  1502.             for (int j = 0; j < src.cols; j++)
  1503.             {
  1504.                 if (X1.at<uchar>(i, j) != X2.at<uchar>(i, j))
  1505.                 {
  1506.                     finish = false;
  1507.                     break;
  1508.                 }
  1509.  
  1510.             }
  1511.         }
  1512.  
  1513.         X1 = X2.clone();
  1514.  
  1515.     } while (!finish);
  1516.  
  1517.     for (int i = 0; i < src.rows; i++)
  1518.     {
  1519.         for (int j = 0; j < src.cols; j++)
  1520.         {
  1521.             if (X2.at<uchar>(i, j) == 0 || src.at<uchar>(i, j) == 0)
  1522.             {
  1523.                 dst.at<uchar>(i, j) = 0;
  1524.             }
  1525.         }
  1526.     }
  1527.     imshow("src", src);
  1528.     imshow("complement", compl);
  1529.     imshow("Final", dst);
  1530.     waitKey(0);
  1531. }
  1532.  
  1533. ///////////////////////////////////// LAB 8//////////////////////////
  1534.  
  1535. int* calculHistograma(Mat img) {
  1536.  
  1537.     int *hist = (int*)malloc(sizeof(int) * 256);
  1538.  
  1539.     for (int i = 0; i < 256; i++)
  1540.         hist[i] = 0;
  1541.  
  1542.     for (int i = 0; i < img.rows; i++)
  1543.         for (int j = 0; j < img.cols; j++)
  1544.             hist[img.at<uchar>(i, j)]++;
  1545.  
  1546.     return hist;
  1547. }
  1548.  
  1549. void calcule(Mat img) {
  1550.    
  1551.     int M = img.rows * img.cols;
  1552.  
  1553.     int* hist = calculHistograma(img);
  1554.  
  1555.     showHistogram("histogram", hist, 256, 200);
  1556.  
  1557.     // niv maxim de intensitate
  1558.     int L = 255;
  1559.  
  1560.     float fdp[256];
  1561.  
  1562.     for (int i = 0; i <= L; i++)
  1563.         fdp[i] = 0;
  1564.    
  1565.  
  1566.     for (int g = 0; g <= L; g++)
  1567.         fdp[g] = (float)hist[g] / M;
  1568.  
  1569.     for (int g = 0; g <= L; g++)
  1570.         printf("%f.", fdp[g]);
  1571.  
  1572.     // val medie a niv de intensitate
  1573.     float medie = 0.0;
  1574.     for (int g = 0; g <= L; g++)
  1575.         medie += fdp[g] * g;
  1576.  
  1577.     // deviatie standard
  1578.     float deviatie = 0.0;
  1579.     for (int g = 0; g <= L; g++)
  1580.         deviatie += pow(g - medie, 2) * fdp[g];
  1581.     deviatie = sqrt(deviatie);
  1582.  
  1583.     printf("Valoare medie: %f.\n", medie);
  1584.     printf("Deviatie standard: %f.\n", deviatie);
  1585. }
  1586.  
  1587. void testHistograma()
  1588. {
  1589.     char fname[MAX_PATH];
  1590.  
  1591.     while (openFileDlg(fname)) {
  1592.         Mat img = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1593.  
  1594.         int* histograma = calculHistograma(img);
  1595.  
  1596.         showHistogram("histogram", histograma, 256, 200);
  1597.         imshow("src", img);
  1598.         waitKey(0);
  1599.     }
  1600.  
  1601.  
  1602. }
  1603.  
  1604. void testHistogramaFDP() {
  1605.  
  1606.         Mat img = imread("Images/balloons.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  1607.  
  1608.         imshow("src", img);
  1609.  
  1610.         calcule(img);
  1611.  
  1612.         waitKey(0);
  1613.    
  1614. }
  1615.  
  1616. void pragBinarizare(Mat img) {
  1617.  
  1618.     // nr de pixeli ai imaginii
  1619.     int M = img.rows * img.cols;
  1620.  
  1621.     int* hist = calculHistograma(img);
  1622.  
  1623.     showHistogram("histogram", hist, 256, 200);
  1624.  
  1625.     // fdp
  1626.     float fdp[256] = {};
  1627.  
  1628.     for (int g = 0; g < 256; g++)
  1629.         fdp[g] = (float)hist[g] / M;
  1630.  
  1631.     float T;
  1632.     int iMin = 0, iMax = 256;
  1633.  
  1634.     T = (iMax + iMin) / 2.0;
  1635.  
  1636.     float Tn;
  1637.  
  1638.     do
  1639.     {
  1640.         int Nmic = 0, Nmare = 0;
  1641.         float medieMica = 0, medieMare = 0;
  1642.  
  1643.         for (int g = 0; g <= T; g++)
  1644.             Nmic += hist[g];
  1645.         for (int g = 255; g > T; g--)
  1646.             Nmare += hist[g];
  1647.  
  1648.         for (int g = 0; g <= T; g++)
  1649.             medieMica += hist[g] * g;
  1650.         for (int g = 255; g > T; g--)
  1651.             medieMare += hist[g] * g;
  1652.  
  1653.         Tn = T;
  1654.         float min = medieMica / Nmic;
  1655.         float max = medieMare / Nmare;
  1656.         T = (min +max) / 2.0;
  1657.  
  1658.     } while (abs(Tn - T) > 0.5);
  1659.  
  1660.     printf("Prag de binarizare: %f.\n", T);
  1661.  
  1662.     Mat dest = img.clone();
  1663.     for (int i = 0; i < img.rows; i++)
  1664.         for (int j = 0; j < img.cols; j++)
  1665.             if (img.at<uchar>(i, j) < 165)
  1666.                 dest.at<uchar>(i, j) = 0;
  1667.             else
  1668.                 dest.at<uchar>(i, j) = 255;
  1669.  
  1670.     imshow("Binarizare", dest);
  1671. }
  1672.  
  1673. void testPragBinarizare() {
  1674.    
  1675.         Mat img = imread("Images/eight.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  1676.  
  1677.         imshow("src", img);
  1678.  
  1679.         pragBinarizare(img);
  1680.  
  1681.         waitKey(0);
  1682.     }
  1683.  
  1684. void LumGamma(Mat img,int offset,float gamma, int gOUTmin, int gOUTmax) {
  1685.  
  1686.     imshow("Src", img);
  1687.     showHistogram("src", calculHistograma(img), 256, 200);
  1688.  
  1689.     Mat lum = img.clone();
  1690.    
  1691.  
  1692.     printf("Luminozitate: offset = %d\n", offset);
  1693.  
  1694.     for (int i = 0; i < img.rows; i++)
  1695.         for (int j = 0; j < img.cols; j++) {
  1696.             int suma = img.at<uchar>(i, j) + offset;
  1697.             if (suma > 255)suma = 255;
  1698.             if (suma < 0)   suma = 0;
  1699.             lum.at<uchar>(i, j) = suma;
  1700.         }
  1701.     imshow("Luminozitate", lum);
  1702.     showHistogram("luminozitate", calculHistograma(lum), 256, 200);
  1703.  
  1704.     // corectia gamma
  1705.     Mat gam = img.clone();
  1706.    
  1707.  
  1708.     printf("Corectie gamma: gamma = %f\n", gamma);
  1709.  
  1710.     for (int i = 0; i < img.rows; i++)
  1711.         for (int j = 0; j < img.cols; j++) {
  1712.             float aux = pow((float)img.at<uchar>(i, j) / 255, gamma) * 255;
  1713.             if (aux > 255)
  1714.                 aux = 255;
  1715.             if (aux < 0)
  1716.                 aux = 0;
  1717.             gam.at<uchar>(i, j) = (int)aux;
  1718.         }
  1719.     imshow("Corectia gamma", gam);
  1720.     showHistogram("gamma", calculHistograma(gam), 256, 200);
  1721.  
  1722.  
  1723. // modificarea contrastului
  1724.     int gmin = 255;
  1725.     int gmax = 0;
  1726.    
  1727.  
  1728.     int* hist = calculHistograma(img);
  1729.  
  1730.     for (int i = 0; i < 255; i++) {
  1731.         if (hist[i] != 0 && i < gmin)
  1732.             gmin = i;
  1733.         if (hist[i] != 0 && i > gmax)
  1734.             gmax = i;
  1735.     }
  1736.  
  1737.     Mat contrast = img.clone();
  1738.  
  1739.     printf("Contrast:\n");
  1740.     printf("G in min = %d\n", gmin);
  1741.     printf("G in max = %d\n", gmax);
  1742.     printf("G out min = %d\n", gOUTmin);
  1743.     printf("G out max = %d\n", gOUTmax);
  1744.  
  1745.     for (int i = 0; i < img.rows; i++)
  1746.         for (int j = 0; j < img.cols; j++) {
  1747.             float aux = gOUTmin + (img.at<uchar>(i, j) - gmin) * (gOUTmax - gOUTmin) / (gmax - gmin);
  1748.             if (aux > 255)
  1749.                 aux = 255;
  1750.             if (aux < 0)
  1751.                 aux = 0;
  1752.             contrast.at<uchar>(i, j) = (int)aux;
  1753.         }
  1754.     imshow("Contrast", contrast);
  1755.     showHistogram("contrast", calculHistograma(contrast), 256, 200);
  1756.    
  1757. }
  1758.  
  1759. void testCalculeHistograma(int offset,float gamma, int gOUTmin, int gOUTmax) {
  1760.    
  1761.         Mat img = imread("Images/wilderness.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  1762.  
  1763.         imshow("src", img);
  1764.  
  1765.         LumGamma(img,offset,gamma,gOUTmin, gOUTmax);
  1766.  
  1767.         waitKey(0);
  1768.     }
  1769.  
  1770. void egalizareHisto(Mat img) {
  1771.  
  1772.     int *hist = calculHistograma(img);
  1773.  
  1774.     showHistogram("histogram SRC", hist, 256, 200);
  1775.  
  1776.     int hc[256] ;
  1777.     int tab[256];
  1778.      hc[0] = 0;
  1779.  
  1780.     for (int g = 1; g < 256; g++)
  1781.         tab[g] = 0;
  1782.  
  1783.     for (int g = 1; g < 256; g++)
  1784.         hc[g] = hc[g - 1] + hist[g];
  1785.  
  1786.     Mat dst = img.clone();
  1787.  
  1788.     int M = img.rows * img.cols;
  1789.  
  1790.     for (int g = 0; g < 256; g++)
  1791.         tab[g] = 255 * hc[g] / M;
  1792.  
  1793.     for (int i = 0; i < img.rows; i++)
  1794.         for (int j = 0; j < img.cols; j++)
  1795.             dst.at<uchar>(i, j) = tab[img.at<uchar>(i, j)];
  1796.  
  1797.     int *histDst = calculHistograma(dst);
  1798.  
  1799.     imshow("dst", dst);
  1800.     showHistogram("histogram DST", histDst, 256, 200);
  1801. }
  1802.  
  1803. void testEgalizareHisto() {
  1804.    
  1805.         Mat img = imread("Images\baloons.bmp", CV_LOAD_IMAGE_GRAYSCALE);
  1806.         imshow("src", img);
  1807.         egalizareHisto(img);
  1808.         waitKey(0);
  1809.     }
  1810.  
  1811.  
  1812.  
  1813. /////////////////////////// LAB 9 //////////////////
  1814. Mat filtru1(Mat src, Mat filtru)
  1815. {
  1816.     Mat dst = Mat(src.rows, src.cols, CV_8UC1);
  1817.     int i, j, i2 = 0, j2 = 0;
  1818.     int pixel = 0;
  1819.     int sum = 0;
  1820.  
  1821.     for (i = 0; i < filtru.rows; i++)
  1822.         for (j = 0; j < filtru.cols; j++)
  1823.         {
  1824.             sum = sum + filtru.at<short>(i, j);
  1825.         }
  1826.  
  1827.     for (i = 1; i < src.rows - 1; i++)
  1828.         for (j = 1; j < src.cols - 1; j++)
  1829.         {
  1830.             pixel = 0;
  1831.             for (i2 = 0; i2 < filtru.rows; i2++)
  1832.                 for (j2 = 0; j2 < filtru.cols; j2++)
  1833.                     pixel = pixel + (filtru.at<short>(i2, j2) * src.at<uchar>(i + i2 - 1, j + j2 - 1));
  1834.  
  1835.             if (sum != 0)
  1836.             {
  1837.                 pixel /= sum;
  1838.             }
  1839.             if (pixel >= 255) {
  1840.                 pixel = 255;
  1841.             }
  1842.             if (pixel <= 0)
  1843.             {
  1844.                 pixel = 0;
  1845.             }
  1846.             dst.at<uchar>(i, j) = pixel;
  1847.         }
  1848.    
  1849.     printf("Sum=%d \n", sum);
  1850.     return dst;
  1851. }
  1852.  
  1853. Mat convolutie(Mat src, Mat filtru)
  1854. {
  1855.     Mat dst = Mat(src.rows, src.cols, CV_8UC1);
  1856.     int i, j, i2 = 0, j2 = 0;
  1857.     int pixel = 0;
  1858.     int sum = 0;
  1859.  
  1860.     for (i = 0; i < filtru.rows; i++)
  1861.         for (j = 0; j < filtru.cols; j++)
  1862.         {
  1863.             sum = sum + filtru.at<short>(i, j);
  1864.         }
  1865.  
  1866.     for (i = 1; i < src.rows - 1; i++)
  1867.         for (j = 1; j < src.cols - 1; j++)
  1868.         {
  1869.             pixel = 0;
  1870.             for (i2 = 0; i2 < filtru.rows; i2++)
  1871.                 for (j2 = 0; j2 < filtru.cols; j2++)
  1872.                     pixel = pixel + (filtru.at<short>(i2, j2) * src.at<uchar>(i + i2 - 1, j + j2 - 1));
  1873.  
  1874.            
  1875.             if (pixel >= 255) {
  1876.                 pixel = 255;
  1877.             }
  1878.             if (pixel <= 0)
  1879.             {
  1880.                 pixel = 0;
  1881.             }
  1882.             dst.at<uchar>(i, j) = pixel;
  1883.         }
  1884.  
  1885.     printf("Sum=%d \n", sum);
  1886.     return dst;
  1887. }
  1888.  
  1889. Mat filtruMedie() {
  1890.     Mat filtru = Mat(3, 3, CV_16SC1);
  1891.     filtru.at<short>(0, 0) = 1;
  1892.     filtru.at<short>(0, 1) = 1;
  1893.     filtru.at<short>(0, 2) = 1;
  1894.     filtru.at<short>(1, 0) = 1;
  1895.     filtru.at<short>(1, 1) = 1;
  1896.     filtru.at<short>(1, 2) = 1;
  1897.     filtru.at<short>(2, 0) = 1;
  1898.     filtru.at<short>(2, 1) = 1;
  1899.     filtru.at<short>(2, 2) = 1;
  1900.     return filtru;
  1901. }
  1902.  
  1903. void apelFiltruMedie() {
  1904.     char fname[MAX_PATH];
  1905.     while (openFileDlg(fname)) {
  1906.         Mat source;
  1907.         source = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1908.         Mat dest = filtru1(source, filtruMedie());
  1909.         imshow("image", source);
  1910.         imshow("dst", dest);
  1911.         waitKey();
  1912.     }
  1913. }
  1914.  
  1915. Mat filtruGaussian()
  1916. {
  1917.     Mat filtru = Mat(3, 3, CV_16SC1);
  1918.     filtru.at<short>(0, 0) = 1;
  1919.     filtru.at<short>(0, 1) = 2;
  1920.     filtru.at<short>(0, 2) = 1;
  1921.     filtru.at<short>(1, 0) = 2;
  1922.     filtru.at<short>(1, 1) = 4;
  1923.     filtru.at<short>(1, 2) = 2;
  1924.     filtru.at<short>(2, 0) = 1;
  1925.     filtru.at<short>(2, 1) = 2;
  1926.     filtru.at<short>(2, 2) = 1;
  1927.     return filtru;
  1928.  
  1929.  
  1930. }
  1931.  
  1932. void apelFiltruGauss() {
  1933.     char fname[MAX_PATH];
  1934.     while (openFileDlg(fname)) {
  1935.         Mat source;
  1936.         source = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  1937.         Mat dest = filtru1(source, filtruGaussian());
  1938.         imshow("image", source);
  1939.         imshow("dst", dest);
  1940.         waitKey();
  1941.     }
  1942. }
  1943.  
  1944. Mat filtru2(Mat src, Mat filtru)
  1945. {
  1946.    
  1947.     Mat dst = Mat(src.rows, src.cols, CV_32SC1);
  1948.     Mat dst2 = Mat(src.rows, src.cols, CV_8UC1);
  1949.     int i, j, i2 = 0, j2 = 0;
  1950.     int pixel = 0;
  1951.     int sum = 0;
  1952.     int min = 32000, max = 0;
  1953.  
  1954.    
  1955.  
  1956.     for (i = 1; i < src.rows - 1; i++)
  1957.         for (j = 1; j < src.cols - 1; j++)
  1958.         {
  1959.             pixel = 0;
  1960.             for (i2 = 0; i2 < filtru.rows; i2++)
  1961.                 for (j2 = 0; j2 < filtru.cols; j2++)
  1962.                     pixel = pixel + (filtru.at<short>(i2, j2) * src.at<uchar>(i + i2 - 1, j + j2 - 1));
  1963.  
  1964.             if (pixel >= 255) {
  1965.                 pixel = 255;
  1966.             }
  1967.             //modul de imagine
  1968.             if (pixel <= 0)
  1969.             {
  1970.                 pixel = 0;
  1971.             }
  1972.             dst.at<int>(i, j) = pixel;
  1973.         }
  1974.     for (i = 1; i < src.rows - 1; i++)
  1975.         for (j = 1; j < src.cols - 1; j++) {
  1976.             if (min > dst.at<int>(i, j)) { min = dst.at<int>(i, j); }
  1977.             if (max < dst.at<int>(i, j)) { max = dst.at<int>(i, j); }
  1978.         }
  1979.     for (i = 1; i < src.rows - 1; i++) {
  1980.         for (j = 1; j < src.cols - 1; j++) {
  1981.             dst2.at<uchar>(i, j) = ((dst.at<int>(i, j) - min) * 255) / (max - min);
  1982.         }
  1983.     }
  1984.  
  1985.     return dst2;
  1986.    
  1987. }
  1988.  
  1989. Mat filtruLaplace()
  1990. {
  1991.     Mat filtru = Mat(3, 3, CV_16SC1);
  1992.     filtru.at<short>(0, 0) = -1;
  1993.     filtru.at<short>(0, 1) = -1;
  1994.     filtru.at<short>(0, 2) = -1;
  1995.     filtru.at<short>(1, 0) = -1;
  1996.     filtru.at<short>(1, 1) = 8;
  1997.     filtru.at<short>(1, 2) = -1;
  1998.     filtru.at<short>(2, 0) = -1;
  1999.     filtru.at<short>(2, 1) = -1;
  2000.     filtru.at<short>(2, 2) = -1;
  2001.     return filtru;
  2002.  
  2003. }
  2004.  
  2005. void apelLaPlace()
  2006. {
  2007.     char fname[MAX_PATH];
  2008.     while (openFileDlg(fname)) {
  2009.         Mat source;
  2010.         source = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2011.         Mat dest = filtru2(source, filtruLaplace());
  2012.         imshow("image", source);
  2013.         imshow("dst", dest);
  2014.         waitKey();
  2015.     }
  2016. }
  2017.  
  2018. Mat filtruHigh()
  2019. {
  2020.     Mat filtru = Mat(3, 3, CV_16SC1);
  2021.     filtru.at<short>(0, 0) = -1;
  2022.     filtru.at<short>(0, 1) = -1;
  2023.     filtru.at<short>(0, 2) = -1;
  2024.     filtru.at<short>(1, 0) = -1;
  2025.     filtru.at<short>(1, 1) = 9;
  2026.     filtru.at<short>(1, 2) = -1;
  2027.     filtru.at<short>(2, 0) = -1;
  2028.     filtru.at<short>(2, 1) = -1;
  2029.     filtru.at<short>(2, 2) = -1;
  2030.     return filtru;
  2031.  
  2032. }
  2033.  
  2034. void apelHigh()
  2035. {
  2036.     char fname[MAX_PATH];
  2037.     while (openFileDlg(fname)) {
  2038.         Mat source;
  2039.         source = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2040.         Mat dest = filtru2(source, filtruHigh());
  2041.         imshow("image", source);
  2042.         imshow("dst", dest);
  2043.         waitKey();
  2044.     }
  2045. }
  2046.  
  2047. /////////////////////////////// LAB 10 /////////////////////
  2048.  
  2049. void filtruMedian(Mat src, int w) {
  2050.     double t = (double)getTickCount();
  2051.     Mat dst = src.clone();
  2052.     int k = w / 2;
  2053.     int index;
  2054.  
  2055.     std::vector <uchar> V = {};
  2056.     imshow("Original", src);
  2057.  
  2058.     for (int y = k; y < src.rows - k; y++) {
  2059.         for (int x = k; x < src.cols - k; x++) {
  2060.             int index = 0;
  2061.             for (int i = -k; i <= k; i++) {
  2062.                 for (int j = -k; j <= k; j++) {
  2063.                     V.push_back(src.at<uchar>(y + i, x + j));
  2064.                     index++;
  2065.                 }
  2066.             }
  2067.             std::sort(V.begin(), V.end());
  2068.             uchar mean = V[w*w / 2];
  2069.             dst.at<uchar>(y, x) = mean;
  2070.             V.clear();
  2071.         }
  2072.     }
  2073.  
  2074.     imshow("Rez", dst);
  2075.     t = ((double)getTickCount() - t) / getTickFrequency();
  2076.     // Display (in the console window) the processing time in [ms]
  2077.     printf("Time = %.3f [ms]\n", t * 1000);
  2078.  
  2079.  
  2080. }
  2081.  
  2082. void apelareMedian()
  2083. {
  2084.  
  2085.     char fname[MAX_PATH];
  2086.     while (openFileDlg(fname)) {
  2087.         Mat src;
  2088.         src = imread(fname, CV_LOAD_IMAGE_GRAYSCALE);
  2089.         filtruMedian(src, 3);
  2090.        
  2091.        
  2092.         waitKey();
  2093.     }
  2094.  
  2095. }
  2096.  
  2097. Mat filtruGaussian(Mat src, int w) {
  2098.     double t = (double)getTickCount(); // Get the current time [ms]
  2099.     Mat dst = src.clone();
  2100.  
  2101.  
  2102.    
  2103.     float G[7][7] = { 0 };
  2104.     float sigma = (float)w / 6;
  2105.     int k = w / 2;
  2106.  
  2107.     for (int x = 0; x < w; x++) {
  2108.         for (int y = 0; y < w; y++) {
  2109.             G[x][y] = 1.0 / (2 * PI*sigma*sigma) * exp(-(((x - w/2)*(x - w/2) + (y - w/2)*(y - w/2)) / (2 * sigma*sigma)));
  2110.         }
  2111.     }
  2112.  
  2113.     for (int x = k; x < src.rows - k; x++)
  2114.         for (int y = k; y < src.cols - k; y++)
  2115.         {
  2116.             int aux = 0;
  2117.             for (int i = -k; i <= k; i++)
  2118.                 for (int j = -k; j <= k; j++)
  2119.                 {
  2120.                     aux += src.at<uchar>(x + j, y + i)*G[j + k][i + k];
  2121.                 }
  2122.  
  2123.             dst.at<uchar>(x, y) = aux;
  2124.  
  2125.  
  2126.         }
  2127.     imshow("Original", src);
  2128.     imshow("Rezultat", dst);
  2129.     //Mat dest = filtru1(dst, filtruGaussian());
  2130.     //imshow("Dupa convolutie", dest);
  2131.     t = ((double)getTickCount() - t) / getTickFrequency();
  2132.     // Display (in the console window) the processing time in [ms]
  2133.     printf("Time = %.3f [ms]\n", t * 1000);
  2134.     return dst;
  2135. }
  2136.  
  2137. void apelareGaussian()
  2138. {
  2139.    
  2140.         Mat src;
  2141.         src = imread("Images/imagini_zgomot/portrait_Gauss1.bmp", 0);
  2142.         Mat dst=filtruGaussian(src, 7);
  2143.        
  2144.        
  2145.        
  2146.  
  2147.         waitKey();
  2148.    
  2149.  
  2150. }
  2151.  
  2152. void filtruGaussian2(Mat img ,int w) {
  2153.  
  2154.  
  2155.     double t = (double)getTickCount(); // Get the current time [ms]
  2156.     float sigma = (float)(w / 6.0);
  2157.  
  2158.    
  2159.     Mat clone = img.clone();
  2160.     int k = w/ 2;
  2161.  
  2162.     uchar V[50] = { 0 };
  2163.     float Gx[7] = { 0 };
  2164.     float Gy[7]= { 0 };
  2165.  
  2166.     for (int x = 0; x < w; x++)
  2167.         for (int y = 0; y < w; y++) {
  2168.             if (y == w / 2) Gy[x] = 1.0 / (2 * PI*sigma)*exp(-(((y - w/2)*(y - w/2)) / (2 * sigma*sigma)));
  2169.             if (x == w / 2) Gx[y] = 1.0 / (2 * PI*sigma)*exp(-(((x - w/2)*(x - w/2)) / (2 * sigma*sigma)));
  2170.  
  2171.  
  2172.         }
  2173.  
  2174.     for (int x = k; x < img.rows - k; x++)
  2175.         for (int y = k; y < img.cols - k; y++)
  2176.         {
  2177.             float aux = 0;
  2178.             for (int i = -k; i <= k; i++)
  2179.                 for (int j = -k; j <= k; j++)
  2180.                 {
  2181.                     aux += Gx[j + k] * Gy[i + k] * img.at<uchar>(x + j, y + i);
  2182.                 }
  2183.  
  2184.             clone.at<uchar>(x, y) = aux;
  2185.  
  2186.  
  2187.         }
  2188.  
  2189.        
  2190.     imshow("original", img);
  2191.     imshow("rezultat", clone);
  2192.     t = ((double)getTickCount() - t) / getTickFrequency();
  2193.     // Display (in the console window) the processing time in [ms]
  2194.     printf("Time = %.3f [ms]\n", t * 1000);
  2195.     waitKey(0);
  2196. }
  2197.  
  2198. void apelareGaussian2()
  2199. {
  2200.  
  2201.     Mat src;
  2202.     src = imread("Images/imagini_zgomot/portrait_Gauss1.bmp", 0);
  2203.     //filtruGaussian(src,7);
  2204.     filtruGaussian2(src, 7);
  2205.  
  2206.  
  2207.  
  2208.     waitKey();
  2209.  
  2210.  
  2211. }
  2212.  
  2213.  
  2214.  
  2215. /////////////////////////// LAB 11 /////////////////////////
  2216.  
  2217.  
  2218. void prewitt(Mat src)
  2219. {
  2220.  
  2221.     int Hx[3][3] = { { -1, 0, 1 },
  2222.                      { -1, 0, 1 },
  2223.                      { -1, 0, 1 } };
  2224.  
  2225.     int Hy[3][3] = { { 1, 1, 1 },
  2226.                      { 0, 0, 0 },
  2227.                      { -1, -1, -1 } };
  2228.  
  2229.     Mat dstx = src.clone();
  2230.     Mat dsty = src.clone();
  2231.     int k = 1;
  2232.     int pixelx, pixely;
  2233.     for (int y = 1; y < src.rows - 1; y++)
  2234.     {
  2235.         for (int x = 1; x < src.cols -1; x++)
  2236.         {
  2237.             int aux1 = 0, aux2 = 0;
  2238.             for (int i = -1; i <= 1; i++)
  2239.             {
  2240.                 for (int j = -1; j <= 1; j++)
  2241.                 {
  2242.                     aux1 += src.at<uchar>(x + j, y + i) * Hx[j + 1][i + 1];
  2243.                     aux2 += src.at<uchar>(x + j, y + i) * Hy[j + 1][i + 1];
  2244.                 }
  2245.  
  2246.  
  2247.  
  2248.             }
  2249.             if (aux1 < 0)
  2250.                 dstx.at<uchar>(x, y) = 0;
  2251.             else if (aux1 > 255)
  2252.                 dstx.at<uchar>(x, y) = 255;
  2253.             else
  2254.                 dstx.at<uchar>(x, y) = aux1;
  2255.  
  2256.             if (aux2 < 0)
  2257.                 dsty.at<uchar>(x, y) = 0;
  2258.             else if (aux2 > 255)
  2259.                 dsty.at<uchar>(x, y) = 255;
  2260.             else
  2261.                 dsty.at<uchar>(x, y) = aux2;
  2262.         }
  2263.     }
  2264.  
  2265.     imshow("Original", src);
  2266.     imshow("X component", dstx);
  2267.     imshow("Y component", dsty);
  2268.     waitKey(0);
  2269. }
  2270.  
  2271. void apelarePrewitt()
  2272. {
  2273.  
  2274.     Mat src;
  2275.     src = imread("Images/imagini_muchii/cameraman.bmp", 0);
  2276.     prewitt(src);
  2277.  
  2278.  
  2279.  
  2280.     waitKey();
  2281.  
  2282. }
  2283.  
  2284. void sobel(Mat src)
  2285. {
  2286.  
  2287.     int Hx[3][3] = { { -1, 0, 1 },
  2288.     { -2, 0, 2 },
  2289.     { -1, 0, 1 } };
  2290.  
  2291.     int Hy[3][3] = { { 1, 2, 1 },
  2292.     { 0, 0, 0 },
  2293.     { -1, -2, -1 } };
  2294.  
  2295.     Mat dstx = src.clone();
  2296.     Mat dsty = src.clone();
  2297.     int k = 1;
  2298.     int pixelx, pixely;
  2299.     for (int y = k; y < src.rows - k; y++)
  2300.     {
  2301.         for (int x = k; x < src.cols - k; x++)
  2302.         {
  2303.             int aux1 = 0, aux2 = 0;
  2304.             for (int i = -k; i <= k; i++)
  2305.             {
  2306.                 for (int j = -k; j <= k; j++)
  2307.                 {
  2308.                     aux1 += src.at<uchar>(x + j, y + i) * Hx[j + k][i + k];
  2309.                     aux2 += src.at<uchar>(x + j, y + i) * Hy[j + k][i + k];
  2310.                 }
  2311.  
  2312.  
  2313.  
  2314.             }
  2315.             if (aux1 < 0)
  2316.                 dstx.at<uchar>(x, y) = 0;
  2317.             else if (aux1 > 255)
  2318.                 dstx.at<uchar>(x, y) = 255;
  2319.             else
  2320.                 dstx.at<uchar>(x, y) = aux1;
  2321.  
  2322.             if (aux2 < 0)
  2323.                 dsty.at<uchar>(x, y) = 0;
  2324.             else if (aux2 > 255)
  2325.                 dsty.at<uchar>(x, y) = 255;
  2326.             else
  2327.                 dsty.at<uchar>(x, y) = aux2;
  2328.         }
  2329.     }
  2330.  
  2331.     imshow("Original", src);
  2332.     imshow("X component", dstx);
  2333.     imshow("Y component", dsty);
  2334.     waitKey(0);
  2335. }
  2336.  
  2337. void apelareSobel()
  2338. {
  2339.  
  2340.     Mat src;
  2341.     src = imread("Images/imagini_muchii/cameraman.bmp", 0);
  2342.     sobel(src);
  2343.  
  2344.  
  2345.  
  2346.     waitKey();
  2347.  
  2348. }
  2349.  
  2350. void Roberts(Mat src)
  2351. {
  2352.     int Hx[2][2] = { { 1, 0 },
  2353.     { 0, -1 } };
  2354.  
  2355.     int Hy[2][2] = { { 0, -1 },
  2356.     { 1, 0 } };
  2357.  
  2358.     Mat dest_x = src.clone();
  2359.     Mat dest_y = src.clone();
  2360.     int k = 1;
  2361.     for (int y = k; y < src.rows - k; y++)
  2362.     {
  2363.         for (int x = k; x < src.cols - k; x++)
  2364.         {
  2365.             int aux1 = 0, aux2 = 0;
  2366.             for (int i = -k; i < k; i++)
  2367.             {
  2368.                 for (int j = -k; j < k; j++)
  2369.                 {
  2370.                     aux1 += src.at<uchar>(x + j, y + i) * Hx[j + k][i + k];
  2371.                     aux2 += src.at<uchar>(x + j, y + i) * Hy[j + k][i + k];
  2372.                 }
  2373.  
  2374.                 if (aux1 < 0)
  2375.                     dest_x.at<uchar>(x, y) = 0;
  2376.                 else if (aux1 > 255)
  2377.                     dest_x.at<uchar>(x, y) = 255;
  2378.                 else
  2379.                     dest_x.at<uchar>(x, y) = aux1;
  2380.  
  2381.                 if (aux2 < 0)
  2382.                     dest_y.at<uchar>(x, y) = 0;
  2383.                 else if (aux2 > 255)
  2384.                     dest_y.at<uchar>(x, y) = 255;
  2385.                 else
  2386.                     dest_y.at<uchar>(x, y) = aux2;
  2387.  
  2388.             }
  2389.         }
  2390.     }
  2391.  
  2392.     imshow("Original", src);
  2393.     imshow("X component", dest_x);
  2394.     imshow("Y component", dest_y);
  2395.     waitKey(0);
  2396.  
  2397. }
  2398.  
  2399. void canny(Mat src)
  2400. {
  2401.     Mat temp = src.clone(); //matrice temporara
  2402.     Mat modul = Mat::zeros(src.size(), CV_8UC1); //matricea pt. modulul gradientului
  2403.     Mat directie = Mat::zeros(src.size(), CV_8UC1); //matricea pt. directia gradientului
  2404.  
  2405.     int Sx[3][3] = { { -1, 0, 1 },{ -2, 0, 2 },{ -1, 0, 1 } };
  2406.     int Sy[3][3] = { { 1, 2, 1 },{ 0, 0, 0 },{ -1, -2, -1 } };
  2407.  
  2408.     int w;
  2409.     float teta;
  2410.     int dir;
  2411.     Mat canny_res;
  2412.  
  2413.  
  2414.     temp = filtruGaussian(src, 5);
  2415.     imshow("Gauss res", temp);
  2416.     //waitKey(0);
  2417.  
  2418.     for (int i = 2; i < temp.rows - 2; i++)
  2419.     {
  2420.         for (int j = 2; j < temp.cols - 2; j++)
  2421.         {
  2422.             float gradX = 0, gradY = 0;
  2423.  
  2424.             for (int l1 = 0; l1 < 3; l1++)
  2425.             {
  2426.                 for (int l2 = 0; l2 < 3; l2++)
  2427.                 {
  2428.                     gradX += temp.at<uchar>(i + l1 - 1, j + l2 - 1) * Sx[l1][l2];
  2429.                     gradY += temp.at<uchar>(i + l1 - 1, j + l2 - 1) * Sy[l1][l2];
  2430.                 }
  2431.             }
  2432.  
  2433.  
  2434.         ;
  2435.             modul.at<uchar>(i, j) = sqrt(gradX * gradX + gradY * gradY) / 5.65;
  2436.  
  2437.             teta = atan2((float)gradY, (float)gradX);
  2438.             if ((teta > 3 * PI / 8 && teta < 5 * PI / 8) || (teta > -5 * PI / 8 && teta < -3 * PI / 8))
  2439.             {
  2440.                 dir = 0;
  2441.             }
  2442.  
  2443.             if ((teta > PI / 8 && teta < 3 * PI / 8) || (teta > -7 * PI / 8 && teta < -5 * PI / 8))
  2444.             {
  2445.                 dir = 1;
  2446.             }
  2447.  
  2448.             if ((teta > -PI / 8 && teta < PI / 8) || teta > 7 * PI / 8 && teta < -7 * PI / 8)
  2449.             {
  2450.                 dir = 2;
  2451.             }
  2452.  
  2453.             if ((teta > 5 * PI / 8 && teta < 7 * PI / 8) || (teta > -3 * PI / 8 && teta < -PI / 8))
  2454.             {
  2455.                 dir = 3;
  2456.             }
  2457.  
  2458.             directie.at<uchar>(i, j) = dir;
  2459.         }
  2460.     }
  2461.  
  2462.  
  2463.     // sobel
  2464.     Mat tempSobelX = temp.clone();
  2465.  
  2466.     for (int i = 1; i < temp.rows - 1; i++)
  2467.     {
  2468.         for (int j = 1; j < temp.cols - 1; j++)
  2469.         {
  2470.             tempSobelX.at<uchar>(i, j) = (
  2471.                 -1 * src.at<uchar>(i - 1, j - 1) +
  2472.                 0 * src.at<uchar>(i - 1, j) +
  2473.                 1 * src.at<uchar>(i - 1, j + 1) +
  2474.                 -2 * src.at<uchar>(i, j - 1) +
  2475.                 0 * src.at<uchar>(i, j) +
  2476.                 2 * src.at<uchar>(i, j + 1) +
  2477.                 -1 * src.at<uchar>(i + 1, j - 1) +
  2478.                 0 * src.at<uchar>(i + 1, j) +
  2479.                 1 * src.at<uchar>(i + 1, j + 1)) / 16;
  2480.         }
  2481.     }
  2482.  
  2483.     //imshow("Res Sobel X", tempSobelX);
  2484.  
  2485.  
  2486.     Mat tempSobelY = temp.clone();
  2487.  
  2488.     for (int i = 1; i < temp.rows - 1; i++)
  2489.     {
  2490.         for (int j = 1; j < temp.cols - 1; j++)
  2491.         {
  2492.             tempSobelY.at<uchar>(i, j) = (
  2493.                 1 * src.at<uchar>(i - 1, j - 1) +
  2494.                 2 * src.at<uchar>(i - 1, j) +
  2495.                 1 * src.at<uchar>(i - 1, j + 1) +
  2496.                 0 * src.at<uchar>(i, j - 1) +
  2497.                 0 * src.at<uchar>(i, j) +
  2498.                 0 * src.at<uchar>(i, j + 1) +
  2499.                 -1 * src.at<uchar>(i + 1, j - 1) +
  2500.                 -2 * src.at<uchar>(i + 1, j) +
  2501.                 -1 * src.at<uchar>(i + 1, j + 1)) / 16;
  2502.         }
  2503.     }
  2504.     //
  2505.     //imshow("Res Sobel Y", tempSobelY);
  2506.  
  2507.     imshow("Modul res", modul);
  2508.  
  2509.  
  2510.  
  2511.  
  2512.    
  2513.  
  2514.     Mat nms = modul.clone();
  2515.     for (int i = 1; i < src.rows - 1; ++i)
  2516.     {
  2517.         for (int j = 1; j < src.cols - 1; ++j)
  2518.         {
  2519.             int dir = directie.at<uchar>(i, j);
  2520.             switch (dir)
  2521.             {
  2522.             case 0:
  2523.             {
  2524.                 if (i == 0)
  2525.                 {
  2526.                     if (modul.at<uchar>(i, j) < modul.at<uchar>(i + 1, j))
  2527.                     {
  2528.                         nms.at<uchar>(i, j) = 0;
  2529.                     }
  2530.                 }
  2531.                 else if (i == src.rows - 1)
  2532.                 {
  2533.                     if (modul.at<uchar>(i, j) < modul.at<uchar>(i - 1, j))
  2534.                     {
  2535.                         nms.at<uchar>(i, j) = 0;
  2536.                     }
  2537.                 }
  2538.                 else
  2539.                 {
  2540.                     if (modul.at<uchar>(i, j) < modul.at<uchar>(i - 1, j) ||
  2541.                         modul.at<uchar>(i, j) < modul.at<uchar>(i + 1, j)
  2542.                         )
  2543.                     {
  2544.                         nms.at<uchar>(i, j) = 0;
  2545.                     }
  2546.                 }
  2547.                 break;
  2548.             }
  2549.             case 1:
  2550.             {
  2551.  
  2552.                 if (modul.at<uchar>(i, j) < modul.at<uchar>(i - 1, j + 1) ||
  2553.                     modul.at<uchar>(i, j) < modul.at<uchar>(i + 1, j - 1)
  2554.                     )
  2555.                 {
  2556.                     nms.at<uchar>(i, j) = 0;
  2557.                 }
  2558.                 break;
  2559.             }
  2560.             case 2:
  2561.             {
  2562.                 if (j == 0)
  2563.                 {
  2564.                     if (modul.at<uchar>(i, j) < modul.at<uchar>(i, j + 1))
  2565.                     {
  2566.                         nms.at<uchar>(i, j) = 0;
  2567.                     }
  2568.                 }
  2569.                 else if (j == src.cols - 1)
  2570.                 {
  2571.                     if (modul.at<uchar>(i, j) < modul.at<uchar>(i, j - 1))
  2572.                     {
  2573.                         nms.at<uchar>(i, j) = 0;
  2574.                     }
  2575.                 }
  2576.                 else
  2577.                 {
  2578.                     if (modul.at<uchar>(i, j) < modul.at<uchar>(i, j - 1) ||
  2579.                         modul.at<uchar>(i, j) < modul.at<uchar>(i, j + 1)
  2580.                         )
  2581.                     {
  2582.                         nms.at<uchar>(i, j) = 0;
  2583.                     }
  2584.                 }
  2585.                 break;
  2586.             }
  2587.             default:
  2588.             {
  2589.                 if (modul.at<uchar>(i, j) < modul.at<uchar>(i - 1, j - 1) ||
  2590.                     modul.at<uchar>(i, j) < modul.at<uchar>(i + 1, j + 1)
  2591.                     )
  2592.                 {
  2593.                     nms.at<uchar>(i, j) = 0;
  2594.                 }
  2595.                 break;
  2596.             }
  2597.             }
  2598.         }
  2599.     }
  2600.  
  2601.     imshow("Non-max suppression", nms);
  2602.    
  2603.  
  2604.  
  2605.  
  2606.     //compute histogram
  2607.  
  2608.     int hist[256];
  2609.     for (int i = 0; i < 255; ++i)
  2610.     {
  2611.         hist[i] = 0;
  2612.     }
  2613.     for (int i = 0; i < src.rows; ++i)
  2614.     {
  2615.         for (int j = 0; j < src.cols; ++j)
  2616.         {
  2617.             hist[nms.data[i * src.cols + j]]++;
  2618.         }
  2619.     }
  2620.  
  2621.  
  2622.     float  k = 0.4;
  2623.     float nrnonmuchie = 0.9 * (nms.rows * nms.cols - hist[0]);
  2624.     int pragadaptiv;
  2625.     int sum = 0;
  2626.  
  2627.     for (int i = 1; i < 255; i++)
  2628.     {
  2629.         sum += hist[i];
  2630.         if (sum > nrnonmuchie)
  2631.         {
  2632.             pragadaptiv =hist[i];
  2633.             break;
  2634.         }
  2635.  
  2636.     }
  2637.     int x;
  2638.     printf("prag adaptiv + %d", pragadaptiv);
  2639.     scanf("%d",&x);
  2640.  
  2641.     float pH = pragadaptiv;
  2642.     float pL = 0.4 * pH;
  2643.  
  2644.     /* double threshold */
  2645.  
  2646.     Mat thr = nms.clone();
  2647.     for (int i = 0; i < src.rows; ++i)
  2648.     {
  2649.         for (int j = 0; j < src.cols; ++j)
  2650.         {
  2651.             if (nms.data[i * src.cols + j] < pL)
  2652.             {
  2653.                 thr.data[i * src.cols + j] = 0;
  2654.             }
  2655.             else if (nms.data[i * src.cols + j] > pH)
  2656.             {
  2657.                 thr.data[i * src.cols + j] = STRONG;
  2658.             }
  2659.             else if (nms.data[i * src.cols + j] < pH && nms.data[i * src.cols + j] > pL)
  2660.             {
  2661.                 thr.data[i * src.cols + j] = WEAK;
  2662.             }
  2663.         }
  2664.     }
  2665.  
  2666.     imshow("thr", thr);
  2667.    
  2668.    
  2669.  
  2670.    
  2671.  
  2672.  
  2673.  
  2674.  
  2675.     waitKey(0);
  2676. }
  2677.  
  2678. void cannyTest()
  2679. {
  2680.     Mat src;
  2681.     src = imread("Images/saturn.bmp", 0);
  2682.     canny(src);
  2683.     waitKey(0);
  2684. }
  2685.  
  2686.  
  2687. int main()
  2688. {
  2689.     int op;
  2690.     Mat src,src1,src2,src3;
  2691.     do
  2692.     {
  2693.         system("cls");
  2694.         destroyAllWindows();
  2695.         printf("Menu:\n");
  2696.         printf(" 1 - Open image\n");
  2697.         printf(" 2 - Open BMP images from folder\n");
  2698.         printf(" 3 - Image negative - diblook style\n");
  2699.         printf(" 4 - BGR->HSV\n");
  2700.         printf(" 5 - Resize image\n");
  2701.         printf(" 6 - Canny edge detection\n");
  2702.         printf(" 7 - L1 Negative Image \n");
  2703.         printf(" 8 - Snap frame from live video\n");
  2704.         printf(" 9 - Mouse callback demo\n");
  2705.         printf(" 10 - Imagine cu factor aditiv\n");
  2706.         printf(" 11 - Imagine cu factor multiplicativ\n");
  2707.         printf(" 12 - Imagine 4 sectoare\n");
  2708.         printf(" 13 - Inversa matricii\n");
  2709.         printf(" 14 - Copiaza Canale\n");
  2710.         printf(" 15 - Imagine GrayScale\n");
  2711.         printf(" 16 - Imagine Alb-Negru\n");
  2712.         printf(" 17 - Imagine HSV\n");
  2713.         printf(" 18 - In imagine\n");
  2714.         printf(" 19 - Proprietati geometrice\n");
  2715.         printf(" 20 - Algoritm 1 – Traversarea în lăţime\n");
  2716.         printf(" 21 - Draw Border\n");
  2717.         printf(" 22 - Reconstruct\n");
  2718.         printf(" 23 - Dilatare\n");
  2719.         printf(" 24 - Eroziune\n");
  2720.         printf(" 25 - Inchidere\n");
  2721.         printf(" 26 - Inchidere de N ori\n");
  2722.         printf(" 27 - Deschidere\n");
  2723.         printf(" 28 - Deschidere de N ori\n");
  2724.         printf(" 29 - Dilatare de N ori\n");
  2725.         printf(" 30 - Eroziune de N ori\n");
  2726.         printf(" 31 - Contur\n");
  2727.         printf(" 32 - Umplere Regiuni\n");
  2728.         printf(" 33 - Histograma\n");
  2729.         printf(" 34 - PDFHistograma\n");
  2730.         printf(" 35 - Binarizare\n");
  2731.         printf(" 36 - Calcule Histograma\n");
  2732.         printf(" 37 - Egalizare\n");
  2733.         printf(" 38 - Filtru Medie\n");
  2734.         printf(" 39 - Filtru Gaussian\n");
  2735.         printf(" 40 - Filtru LaPlace\n");
  2736.         printf(" 41 - Filtru High\n");
  2737.         printf(" 42 - Filtru Median\n");
  2738.         printf(" 43 - Filtru Gaussian\n");
  2739.         printf(" 44 - Filtru Gaussian 2\n");
  2740.         printf(" 45 - Prewitt\n");
  2741.         printf(" 46 - Sobel\n");
  2742.         printf(" 47 - Canny\n");
  2743.         printf(" 0 - Exit\n\n");
  2744.         printf("Option: ");
  2745.         scanf("%d",&op);
  2746.         switch (op)
  2747.         {
  2748.             case 1:
  2749.                 testOpenImage();
  2750.                 break;
  2751.             case 2:
  2752.                 testOpenImagesFld();
  2753.                 break;
  2754.             case 3:
  2755.                 testParcurgereSimplaDiblookStyle(); //diblook style
  2756.                 break;
  2757.             case 4:
  2758.                 //testColor2Gray();
  2759.                 testBGR2HSV();
  2760.                 break;
  2761.             case 5:
  2762.                 testResize();
  2763.                 break;
  2764.             case 6:
  2765.                 testCanny();
  2766.                 break;
  2767.             case 7:
  2768.                 negative_image();
  2769.                 break;
  2770.             case 8:
  2771.                 testSnap();
  2772.                 break;
  2773.             case 9:
  2774.                 testMouseClick();
  2775.                 break;
  2776.             case 10:
  2777.                 changeGray(100);
  2778.                 break;
  2779.             case 11:
  2780.                 changeGrayMulti(2);
  2781.                 break;
  2782.             case 12:
  2783.                 patruSectoare();
  2784.                 break;
  2785.             case 13:
  2786.                 inv();
  2787.                 break;
  2788.             case 14:
  2789.                 copiazaCanale();
  2790.                 break;
  2791.             case 15:
  2792.                 colorToGray();
  2793.                 break;
  2794.             case 16:
  2795.                 grayToALb();
  2796.                 break;
  2797.             case 17:
  2798.                 convertHSV();
  2799.                 break;
  2800.             case 18:
  2801.            
  2802.             src = imread("Images/Lena_24bits.bmp", CV_LOAD_IMAGE_COLOR);
  2803.                 isInside(src, 10, 10);
  2804.                 break;
  2805.             case 19:
  2806.                 testMouseClickProprietati();
  2807.                 break;
  2808.             case 20:
  2809.                 traversare();
  2810.                 break;
  2811.             case 21:
  2812.                 border();
  2813.                 break;
  2814.             case 22:
  2815.                 reconstruct();
  2816.                 break;
  2817.             case 23:
  2818.                 src = imread("Images/1_Dilate/mon1thr1_bw.bmp", 0);
  2819.                 dilatare(src);
  2820.                 break;
  2821.             case 24:
  2822.                 src1 = imread("Images/2_Erode/mon1thr1_bw.bmp", 0);
  2823.                 eroziune(src1);
  2824.                 break;
  2825.             case 25:
  2826.                  src2 = imread("Images/4_Close/phn1thr1_bw.bmp", 0);
  2827.                 inchidere(src2);
  2828.                 break;
  2829.             case 26:
  2830.                 inchidereapelNori(2);
  2831.                 break;
  2832.             case 27:
  2833.                 src3 = imread("Images/3_Open/cel4thr3_bw.bmp", 0);
  2834.                 deschidere(src3);
  2835.                 break;
  2836.             case 28:
  2837.                 deschhidereapelNori(2);
  2838.                 break;
  2839.             case 29:
  2840.                 dilatare_apelNori(10);
  2841.                 break; 
  2842.             case 30:
  2843.                     eroziune_apelNori(10);
  2844.                     break;
  2845.             case 31:
  2846.                 contur();
  2847.                 break;
  2848.             case 32:
  2849.                 umplere_regiuni(80, 80);
  2850.                 break;
  2851.             case 33:
  2852.                 testHistograma();
  2853.                 break;
  2854.             case 34:
  2855.              testHistogramaFDP();
  2856.                 break;
  2857.             case 35:
  2858.                 testPragBinarizare(); break;
  2859.             case 36:
  2860.                 testCalculeHistograma(100,2.5,100,250); break;
  2861.             case 37:
  2862.                 testEgalizareHisto();
  2863.                 break;
  2864.             case 38:
  2865.                 apelFiltruMedie();
  2866.                 break;
  2867.             case 39:
  2868.                 apelFiltruGauss();
  2869.                 break;
  2870.             case 40:
  2871.                 apelLaPlace();
  2872.                 break;
  2873.             case 41:
  2874.                 apelHigh();
  2875.                 break;
  2876.             case 42:
  2877.                 apelareMedian();
  2878.                 break;
  2879.             case 43:
  2880.                 apelareGaussian();
  2881.                 break;
  2882.             case 44:
  2883.                 apelareGaussian2();
  2884.                 break;
  2885.             case 45:
  2886.                 apelarePrewitt();
  2887.                 break;
  2888.             case 46:
  2889.                     apelareSobel();
  2890.                     break;
  2891.             case 47:
  2892.                 cannyTest();
  2893.                 break;
  2894. }
  2895.     }
  2896.     while (op!=0);
  2897.     return 0;
  2898. }
RAW Paste Data
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
 
Top