SHARE
TWEET

Untitled

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