Facebook
From Melodic Finch, 1 Week ago, written in C++.
Embed
Download Paste or View Raw
Hits: 22
  1. #include "opencv2/core/core.hpp"
  2. #include "opencv2/highgui/highgui.hpp"
  3. #include <iostream>
  4. #include <cmath>
  5. #include <string>
  6. #include <vector>
  7.  
  8. cv::Mat& perform(cv::Mat& I){
  9.   CV_Assert(I.depth() != sizeof(uchar));
  10.   switch(I.channels())  {
  11.   case 1:
  12.     for( int i = 0; i < I.rows; ++i)
  13.         for( int j = 0; j < I.cols; ++j )
  14.             I.at<uchar>(i,j) = (I.at<uchar>(i,j)/32)*32;
  15.     break;
  16.   case 3:
  17.     cv::Mat_<cv::Vec3b> _I = I;
  18.     for( int i = 0; i < I.rows; ++i)
  19.         for( int j = 0; j < I.cols; ++j ){
  20.             _I(i,j)[0] = (_I(i,j)[0]/32)*32;
  21.             _I(i,j)[1] = (_I(i,j)[1]/32)*32;
  22.             _I(i,j)[2] = (_I(i,j)[2]/32)*32;
  23.         }
  24.     I = _I;
  25.     break;
  26.   }
  27.   return I;
  28. }
  29.  
  30. cv::Mat selectMax(cv::Mat& I){
  31.     CV_Assert(I.depth() != sizeof(uchar));
  32.     cv::Mat  res(I.rows,I.cols, CV_8UC3);
  33.     switch(I.channels())  {
  34.     case 3:
  35.         cv::Mat_<cv::Vec3b> _I = I;
  36.         cv::Mat_<cv::Vec3b> _R = res;
  37.         for( int i = 0; i < I.rows; ++i)
  38.             for( int j = 0; j < I.cols; ++j ){
  39.                 int sel = (_I(i,j)[0] < _I(i,j)[1])?1:0;
  40.                 sel = _I(i,j)[sel] < _I(i,j)[2]?2:sel;
  41.                 _R(i,j)[0] = sel==0?255:0;
  42.                 _R(i,j)[1] = sel==1?255:0;
  43.                 _R(i,j)[2] = sel==2?255:0;
  44.             }
  45.         res = _R;
  46.         break;
  47.     }
  48.     return res;
  49. }
  50.  
  51. int pole(cv::Mat& I) {
  52.         int pole = 0;
  53.         CV_Assert(I.depth() != sizeof(uchar));
  54.         cv::Mat  res(I.rows, I.cols, CV_8UC3);
  55.         switch (I.channels()) {
  56.         case 3:
  57.                 cv::Mat_<cv::Vec3b> _I = I;
  58.                 cv::Mat_<cv::Vec3b> _R = res;
  59.  
  60.  
  61.                 for (int i = 0; i < I.rows; ++i)
  62.                         for (int j = 0; j < I.cols; ++j) {
  63.                                 if (_I(i, j)[0] == 0) {
  64.                                         pole++;
  65.                                 }
  66.                         }
  67.                 res = _R;
  68.                 break;
  69.         }
  70.         return pole;
  71. }
  72.  
  73.  
  74.  
  75. int obwod(cv::Mat& I) {
  76.         int ob = 0;
  77.         CV_Assert(I.depth() != sizeof(uchar));
  78.         switch (I.channels()) {
  79.         case 3:
  80.                 cv::Mat_<cv::Vec3b> _I = I;
  81.  
  82.  
  83.                 for (int i = 1; i < I.rows -1; ++i)
  84.                         for (int j = 1; j < I.cols -1 ; ++j) {
  85.                                 if (_I(i, j)[0] == 0) {
  86.                                         if (_I(i+1, j+1)[0] != 0)
  87.                                                 ob++;
  88.                                         else if (_I(i + 1, j )[0] != 0)
  89.                                                 ob++;
  90.                                         else if (_I(i + 1, j - 1)[0] != 0)
  91.                                                 ob++;
  92.                                         else if (_I(i - 1, j + 1)[0] != 0)
  93.                                                 ob++;
  94.                                         else if (_I(i - 1, j)[0] != 0)
  95.                                                 ob++;
  96.                                         else if (_I(i - 1, j - 1)[0] != 0)
  97.                                                 ob++;
  98.                                         else if (_I(i , j - 1)[0] != 0)
  99.                                                 ob++;
  100.                                         else if (_I(i, j + 1)[0] != 0)
  101.                                                 ob++;
  102.                                 }
  103.                         }
  104.                 break;
  105.         }
  106.         return ob;
  107. }
  108.  
  109. double w3(int ob, int p) {
  110.         //double pi = 3.14159265;
  111.         double pi = 3.14;
  112.         return (ob / (2 * sqrt(pi * p))) - 1;
  113. }
  114.  
  115. long maleM(cv::Mat& I, int p, int q) {
  116.         long pole = 0;
  117.         CV_Assert(I.depth() != sizeof(uchar));
  118.         cv::Mat  res(I.rows, I.cols, CV_8UC3);
  119.         switch (I.channels()) {
  120.         case 3:
  121.                 cv::Mat_<cv::Vec3b> _I = I;
  122.                 cv::Mat_<cv::Vec3b> _R = res;
  123.                 for (int i = 0; i < I.rows; ++i)
  124.                         for (int j = 0; j < I.cols; ++j) {
  125.                                 if (_I(i, j)[0] == 0) {
  126.                                         pole += pow(i, p) * pow(j, q);
  127.                                 }
  128.                         }
  129.                 res = _R;
  130.                 break;
  131.         }
  132.         return pole;
  133. }
  134.  
  135. double M02(cv::Mat& I) {
  136.         long m02 = maleM(I, 0, 2);
  137.         long m01 = maleM(I, 0, 1);
  138.         long m00 = maleM(I, 0, 0);
  139.  
  140.         return m02 - pow(m01, 2)  / m00;
  141. }
  142.  
  143. double M20(cv::Mat& I) {
  144.         long m20 = maleM(I, 2, 0);
  145.         long m10 = maleM(I, 1, 0);
  146.         long m00 = maleM(I, 0, 0);
  147.  
  148.         return m20 - pow(m10, 2)  / m00;
  149. }
  150.  
  151. double M11(cv::Mat& I) {
  152.         double m11 = maleM(I, 1, 1);
  153.         double m10 = maleM(I, 1, 0);
  154.         double m01 = maleM(I, 0, 1);
  155.         double m00 = maleM(I, 0, 0);
  156.  
  157.         return m11 - ((m10 * m01) / m00);
  158. }
  159.  
  160. double M1(cv::Mat& I) {
  161.         long m00 = maleM(I, 0, 0);
  162.         return (M02(I) + M20(I)) / pow(m00, 2);
  163. }
  164.  
  165. double M7(cv::Mat& I) {
  166.         long m00 = maleM(I, 0, 0);
  167.  
  168.         return (M20(I)* M02(I) - pow(M11(I), 2)) / pow(m00, 4);
  169. }
  170.  
  171. long m(cv::Mat& I, int p, int q, int g, int r) {
  172.         long pole = 0;
  173.         CV_Assert(I.depth() != sizeof(uchar));
  174.         cv::Mat  res(I.rows, I.cols, CV_8UC3);
  175.         switch (I.channels()) {
  176.         case 3:
  177.                 cv::Mat_<cv::Vec3b> _I = I;
  178.                 cv::Mat_<cv::Vec3b> _R = res;
  179.                 for (int i = 0; i < I.rows; ++i)
  180.                         for (int j = 0; j < I.cols; ++j) {
  181.                                 if (_I(i, j)[1] == r && _I(i, j)[2] == g) {
  182.                                         pole += pow(i, p) * pow(j, q);
  183.                                 }
  184.                         }
  185.                 res = _R;
  186.                 break;
  187.         }
  188.         return pole;
  189. }
  190.  
  191. cv::Mat& to_nk(cv::Mat& I, int g, int r) {
  192.         CV_Assert(I.depth() != sizeof(uchar));
  193.         switch (I.channels()) {
  194.         case 1:
  195.                 break;
  196.         case 3:
  197.                 cv::Mat_<cv::Vec3b> _I = I;
  198.                 for (int i = 0; i < I.rows; ++i)
  199.                         for (int j = 0; j < I.cols; ++j) {
  200.                                 if (_I(i, j)[1] == r && _I(i, j)[2] == g) {
  201.                                         _I(i, j)[0] = 0;
  202.                                         _I(i, j)[1] = 0;
  203.                                         _I(i, j)[2] = 0;
  204.                                 }
  205.                                 else {
  206.                                         _I(i, j)[0] = 255;
  207.                                         _I(i, j)[1] = 255;
  208.                                         _I(i, j)[2] = 255;
  209.                                 }
  210.                         }
  211.                 I = _I;
  212.                 break;
  213.         }
  214.         return I;
  215. }
  216.  
  217.  
  218. int minx(cv::Mat& I) {
  219.         int minx = 0;
  220.         switch (I.channels()) {
  221.         case 3:
  222.                 cv::Mat_<cv::Vec3b> _I = I;
  223.                  minx = I.rows;
  224.                 for (int i = 0; i < I.rows; ++i)
  225.                         for (int j = 0; j < I.cols; ++j) {
  226.                                 if (_I(i, j)[0] == 0) {
  227.                                         if (j < minx)
  228.                                                 minx = j;
  229.                                 }
  230.                         }
  231.                 break;
  232.         }
  233.         return minx;
  234. }
  235.  
  236. int miny(cv::Mat& I) {
  237.         int pole = 0;
  238.         switch (I.channels()) {
  239.         case 3:
  240.                 cv::Mat_<cv::Vec3b> _I = I;
  241.                 int miny = I.cols;
  242.                 for (int i = 0; i < I.rows; ++i)
  243.                         for (int j = 0; j < I.cols; ++j) {
  244.                                 if (_I(i, j)[0] == 0) {
  245.                                         if (i < miny)
  246.                                                 miny = i;
  247.                                 }
  248.                         }
  249.                 pole = miny;
  250.                 break;
  251.         }
  252.         return pole;
  253. }
  254.  
  255. int maxx(cv::Mat& I) {
  256.         int pole = 0;
  257.         switch (I.channels()) {
  258.         case 3:
  259.                 cv::Mat_<cv::Vec3b> _I = I;
  260.                 int maxx = 0;
  261.                 for (int i = 0; i < I.rows; ++i)
  262.                         for (int j = 0; j < I.cols; ++j) {
  263.                                 if (_I(i, j)[0] == 0) {
  264.                                         if (j> maxx)
  265.                                                 maxx = j;
  266.                                 }
  267.                         }
  268.                 pole = maxx;
  269.                 break;
  270.         }
  271.         return pole;
  272. }
  273.  
  274. int maxy(cv::Mat& I) {
  275.         int pole = 0;
  276.         switch (I.channels()) {
  277.         case 3:
  278.                 cv::Mat_<cv::Vec3b> _I = I;
  279.                 int maxy = 0;
  280.                 for (int i = 0; i < I.rows; ++i)
  281.                         for (int j = 0; j < I.cols; ++j) {
  282.                                 if (_I(i, j)[0] == 0) {
  283.                                         if (i > maxy)
  284.                                                 maxy = i;
  285.                                 }
  286.                         }
  287.                 pole = maxy;
  288.                 break;
  289.         }
  290.         return pole;
  291. }
  292.  
  293. double ifalka(cv::Mat& I) {
  294.         double m10 = maleM(I, 1, 0);
  295.         double m00 = maleM(I, 0, 0);
  296.         return m10 / m00;
  297. }
  298.  
  299. double jfalka(cv::Mat& I) {
  300.         double m01 = maleM(I, 0, 1);
  301.         double m00 = maleM(I, 0, 0);
  302.         return m01 / m00;
  303. }
  304.  
  305. int nachylenie(cv::Mat& I) {
  306.         double pi = 3.14159265;
  307. /*     
  308.         int min_x = minx(I);
  309.         int min_y = miny(I);
  310.         int max_x = maxx(I);
  311.         int max_y = maxy(I);
  312. */
  313.         int min_x = miny(I);
  314.         int min_y = minx(I);
  315.         int max_x = maxy(I);
  316.         int max_y = maxx(I);
  317.  
  318.         double sr_x = min_x + (max_x - min_x) / 2;
  319.         double sr_y = min_y + (max_y - min_y) / 2;
  320.  
  321.         double sc_x = ifalka(I);
  322.         double sc_y = jfalka(I);
  323.  
  324.         double v_x = sr_x - sc_x;
  325.         double v_y = sr_y - sc_y;
  326.  
  327.         double rad = std::atan2(v_x, v_y);
  328.  
  329.         return (rad / pi)* 180.0;
  330. }
  331.  
  332. int main(int, char *[]) {
  333.         char *line[5] = { "elipsa.dib", "elipsa1.dib", "kolo.dib", "prost.dib", "troj.dib" };
  334.  
  335.         for (int i = 0; i < 5; i++) {
  336.                
  337.                 cv::Mat image = cv::imread(line[i]);
  338.                 int ob = obwod(image);
  339.                 int p = pole(image);
  340.                 int m00 = maleM(image, 0, 0);
  341.                 double a = w3(ob, p);
  342.  
  343.                 double m1 = M1(image);
  344.                 double m7 = M7(image);
  345.  
  346.                 std::cout << line[i] << " S: " << p << " L: " << ob << " W3: " << a << " M1: " << m1 << " M7: " << m7 << std::endl;
  347.         }
  348.  
  349.         for (int i = 0; i < 5; i++) {
  350.  
  351.                 cv::Mat st = cv::imread("strzalki_1.dib");
  352.                 cv::Mat image = to_nk(st, i * 45, 180 - i * 45);
  353.  
  354.                 int ob = obwod(image);
  355.                 int p = pole(image);
  356.                 int m00 = maleM(image, 0, 0);
  357.                 double a = w3(ob, p);
  358.  
  359.                 double m1 = M1(image);
  360.                 double m7 = M7(image);
  361.  
  362.                 double nac = nachylenie(image);
  363.  
  364.                 std::cout << "strzalki_1 R" << i * 45 << " S: " << p << " L: " << ob << " W3: " << a << " M1: " << m1 << " M7: " << m7 << " nachylenie: " << nac << std::endl;
  365.  
  366.  
  367.         }
  368.  
  369.         for (int i = 0; i < 5; i++) {
  370.  
  371.                 cv::Mat st = cv::imread("strzalki_2.dib");
  372.                 cv::Mat image = to_nk(st, i * 45, 180 - i * 45);
  373.  
  374.                 int ob = obwod(image);
  375.                 int p = pole(image);
  376.                 int m00 = maleM(image, 0, 0);
  377.                 double a = w3(ob, p);
  378.  
  379.                 double m1 = M1(image);
  380.                 double m7 = M7(image);
  381.  
  382.                 double nac = nachylenie(image);
  383.  
  384.                 std::cout << "strzalki_2 R" << i * 45 << " S: " << p << " L: " << ob << " W3: " << a << " M1: " << m1 << " M7: " << m7 << " nachylenie: " << nac << std::endl;
  385.  
  386.  
  387.         }
  388.  
  389.     cv::waitKey(-1);
  390.     return 0;
  391. }
  392.