API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 23rd, 2017
72
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 21.15 KB | None | 0 0
raw download clone embed print report
  1. //
  2. // main.cpp
  3. // course
  4. //
  5. // Created by Эльвина Лукманова on 21.10.16.
  6. // Copyright © 2016 Эльвина Лукманова. All rights reserved.
  7.  
  8. #include <iostream>
  9. #include <random>
  10. #include <cmath>
  11. #include <fstream>
  12. #include <opencv2/highgui/highgui.hpp>
  13. #include <opencv2/imgproc/imgproc.hpp>
  14. #include <armadillo>
  15. #include <tbb/tbb.h>
  16.  
  17. using namespace std;
  18. using namespace cv;
  19.  
  20. enum CHANNEL {
  21. BLUE,
  22. GREEN,
  23. RED
  24. };
  25.  
  26. namespace color {
  27. Scalar blue = Scalar(255, 0, 0);
  28. Scalar green = Scalar(0, 255, 0);
  29. Scalar red = Scalar(0, 0, 255);
  30. Scalar white = Scalar(255, 255, 255);
  31. Scalar black = Scalar(0, 0, 0);
  32. auto random = []() {
  33. return Scalar(rand() % 255, rand() % 255, rand() % 255);
  34. };
  35. }
  36.  
  37. //вычисление всех степеней X^pow*Y^pow как указано в статье Рудаковой страница 5 самый верх
  38. void count_degrees (const Point2f & input, int degree, vector<double> & output_vector) {
  39. for (int i = degree; i >= 0 ; i--) {
  40. for (int j = 0; j <= i; j++) {
  41. output_vector.push_back(pow(input.x, (i - j)) * pow(input.y, j));
  42. }
  43. }
  44. }
  45.  
  46. void least_quadrantic (const vector<vector<double>> & input, int degree, const vector<double> & centers_green,
  47. vector<vector<double>> & output, vector<double> & solution) {
  48. int end = (degree + 1) * (degree + 2) / 2;
  49. for (int i = 0; i < end; i++) {
  50. vector<double> additional;
  51. for (int j = 0; j < end; j++) {
  52. double sum = 0;
  53. for (int k = 0; k < input.size(); k++) {
  54. sum += input[k][j] * input[k][i];
  55. }
  56. additional.push_back(sum);
  57. }
  58. output.push_back(additional);
  59. double sum = 0;
  60. for (int k = 0; k < input.size(); k++){
  61. sum += centers_green[k] * input[k][i];
  62. }
  63. solution.push_back(sum);
  64. }
  65. }
  66.  
  67. Point2i solution(const arma::vec & coefficients_for_x, const arma::vec & coefficients_for_y, int degree,
  68. const Point2f & current_pixel_coordinate, int optical_center_x, int optical_center_y) {
  69.  
  70. Point2f corrected_coordinate{0, 0};
  71. vector<double> degrees_for_x;
  72. vector<double> degrees_for_y;
  73.  
  74. count_degrees(current_pixel_coordinate, degree, degrees_for_x);
  75. count_degrees(Point2f(current_pixel_coordinate.y, current_pixel_coordinate.x), degree, degrees_for_y);
  76.  
  77. for (int i = 0; i < degrees_for_x.size(); i++) {
  78. corrected_coordinate.x += coefficients_for_x[i] * degrees_for_x[i];
  79. corrected_coordinate.y += coefficients_for_y[i] * degrees_for_y[i];
  80. }
  81.  
  82. return {(int)(round(optical_center_x + corrected_coordinate.x)),
  83. (int)(round(optical_center_y - corrected_coordinate.y))};
  84.  
  85. }
  86.  
  87. int main() {
  88.  
  89. //тестовый шаблон
  90. // unsigned int height = 1123, width = 1587;
  91. // Mat image(height, width, CV_8UC3, Scalar(255, 255, 255)); //генерация шаблона
  92. // int x = 45, y = 45, radius = 15;
  93. // while (x + 15 < width){
  94. // while (y + 15 < height) {
  95. // circle(image, Point(x, y), radius, Scalar(0, 0, 0), CV_FILLED, 15 );
  96. // y += 45;
  97. // }
  98. // y = 45;
  99. // x += 45;
  100. //
  101. // }
  102. //
  103. //
  104. // imwrite("/Users/elvinalu/Desktop/picture.jpeg", image);
  105. //второй тестовый шаблон -- имитация аберрации
  106. unsigned int height = 1600, width = 1600;
  107. Mat image(height, width, CV_8UC3, color::white); //генерация шаблона
  108. int x = 400, y = 400, radius = 150;
  109. while (x + radius < width) {
  110. while (y + radius < height) {
  111. circle(image, Point(x, y), radius, color::black, CV_FILLED, 15);
  112. y += 400;
  113. }
  114. x += 400, y = 400;
  115. }
  116. imwrite("/Users/elvinalu/Desktop/picture.jpeg", image);
  117. image.release();
  118.  
  119. Mat image1 = imread ("/Users/elvinalu/Desktop/picture.jpeg", 1);
  120. for (int i = 0; i < 600; i++) {
  121. for (int j = 0; j < image1.cols; j++) {
  122. if (j < 600) {
  123. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i + 3, j + 3)[0];
  124. } else {
  125. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i + 3, j)[0];
  126. if (j > 1000) {
  127. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i + 3, j - 3)[0];
  128. }
  129. }
  130. }
  131. }
  132. for (int i = 600; i < 1000; i++) {
  133. for (int j = 0; j < 600; j++) {
  134. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i, j + 3)[0];
  135.  
  136. }
  137. for (int j = image1.cols; j > 1000; j--) {
  138. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i, j - 3)[0];
  139. }
  140. }
  141. for (int i = image1.rows - 1; i > 1000; i--) {
  142. for (int j = 0; j < image1.cols; j++) {
  143. if (j < 600) {
  144. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i - 3, j + 3)[0];
  145. } else {
  146. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i - 3, j)[0];
  147. if (j > 1000) {
  148. image1.at<Vec3b>(i, j)[0] = image1.at<Vec3b>(i - 3, j - 3)[0];
  149. }
  150. }
  151. }
  152. }
  153. // imwrite("/Users/elvinalu/Desktop/picture1.jpeg", image1);
  154. // Mat img = imread("/Users/elvinalu/Desktop/picture1.jpeg", 1); //загрузка фотографии шаблона
  155. // Mat imgy = imread("/Users/elvinalu/Desktop/picture1.jpeg", 1);
  156.  
  157. Mat image2 = imread ("/Users/elvinalu/Desktop/picture.jpeg", 1);
  158. for (int i = 0; i < 600; i++) {
  159. for (int j = 0; j < image2.cols; j++) {
  160. if (j < 600) {
  161. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i + 3, j + 3)[2];
  162. } else {
  163. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i + 3, j)[2];
  164. if (j > 1000) {
  165. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i + 3, j - 3)[2];
  166. }
  167. }
  168. }
  169. }
  170. for (int i = 600; i < 1000; i++) {
  171. for (int j = 0; j < 600; j++) {
  172. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i ,j + 3)[2];
  173.  
  174. }
  175. for (int j = image2.cols; j > 1000; j--) {
  176. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i, j - 3)[2];
  177. }
  178. }
  179. for (int i = image2.rows - 1; i > 1000; i--) {
  180. for (int j = 0; j < image2.cols; j++) {
  181. if (j < 600) {
  182. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i - 3, j + 3)[2];
  183. } else {
  184. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i - 3, j)[2];
  185. if (j > 1000) {
  186. image2.at<Vec3b>(i, j)[2] = image2.at<Vec3b>(i - 3, j - 3)[2];
  187. }
  188. }
  189. }
  190. }
  191. imwrite("/Users/elvinalu/Desktop/picture2.jpeg", image2);
  192. // Mat img = imread("/Users/elvinalu/Desktop/picture2.jpeg", 1); //загрузка фотографии шаблона
  193. // Mat imgy = imread("/Users/elvinalu/Desktop/picture2.jpeg", 1);
  194.  
  195. Mat img = imread("/Users/elvinalu/Desktop/IMG_0124.jpg", 1); //загрузка фотографии шаблона
  196. Mat imgy = imread("/Users/elvinalu/Desktop/IMG_0124.jpg", 1);
  197.  
  198. Mat img_result(img.rows, img.cols, CV_8UC3, color::white);
  199. Mat img_copy(img.rows, img.cols, CV_8UC3, color::white);
  200. Mat imge(img.rows, img.cols, CV_8UC3, color::white);
  201. vector<Mat> channels;
  202. split(img, channels);//разбиение шаблона на каналы
  203.  
  204. Mat red;
  205. Mat green;
  206. Mat blue;
  207.  
  208. vector<vector<Point>> contours_red;
  209. vector<vector<Point>> contours_blue;
  210. vector<vector<Point>> contours_green;
  211.  
  212. auto draw_contours_in_specified_channel = [&](size_t channel, Mat & color, vector<vector<Point>> & contours, string channel_name) {
  213.  
  214. blur(channels[channel], color, Size(3, 3));
  215. threshold(color, color, 135, 255, THRESH_BINARY);
  216. findContours(color, contours, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
  217. vector<RotatedRect> min_rect(contours.size());
  218. vector<RotatedRect> min_ellipse;
  219. for (int i = 0; i < contours.size(); i++) {
  220. min_rect[i] = minAreaRect(Mat(contours[i]));
  221. if (contours[i].size() > 5 && min_rect[i].size.width > 15.0) {
  222. min_ellipse.push_back(fitEllipse(Mat(contours[i])));
  223. }
  224. }
  225. for (int i = 0; i < min_ellipse.size(); i++) {
  226. auto contour_color = color::random();
  227. drawContours(imge, contours, i, contour_color, 1, 8, vector<Vec4i>(), 0, Point());
  228. ellipse(img_copy, min_ellipse[i], contour_color, 2, 8);
  229. Point2f rect_points[4];
  230. min_rect[i].points(rect_points);
  231. for (int j = 0; j < 4; j++) {
  232. line(imge, rect_points[j], rect_points[(j + 1) % 4], contour_color, 1, 8);
  233. }
  234. }
  235. imwrite("/Users/elvinalu/Desktop/" + channel_name + ".jpg", color);
  236. return min_ellipse;
  237. };
  238.  
  239. auto min_ellipse_red = draw_contours_in_specified_channel(CHANNEL::RED, red, contours_red, "red");
  240. auto min_ellipse_blue = draw_contours_in_specified_channel(CHANNEL::BLUE, blue, contours_blue, "blue");
  241. auto min_ellipse_green = draw_contours_in_specified_channel(CHANNEL::GREEN, green, contours_green, "green");
  242.  
  243. cout << min_ellipse_red.size() << ' ' << min_ellipse_blue.size() << ' ' << min_ellipse_green.size() << endl;
  244. auto calculate_distortion = [&](vector<RotatedRect> & min_ellipse, Scalar color) {
  245.  
  246. for (int i = 0; i < min_ellipse_green.size(); i++) {
  247. for (int j = 0; j < min_ellipse.size(); j++) {
  248. if (abs(min_ellipse_green[i].center.x - min_ellipse[j].center.x) < 10 &&
  249. abs(min_ellipse_green[i].center.y - min_ellipse[j].center.y) < 10 && i!=j) {
  250. swap(min_ellipse[j], min_ellipse[i]);
  251. break;
  252. }
  253. }
  254. Point distortion = (min_ellipse[i].center - min_ellipse_green[i].center) * 15;
  255. line(imge, (Point)min_ellipse_green[i].center, (Point)min_ellipse[i].center + distortion, color, 3);
  256. circle(imge, (Point)min_ellipse_green[i].center, 1, color::green, CV_FILLED, 15);
  257. }
  258. };
  259.  
  260. calculate_distortion(min_ellipse_red, color::red);
  261. calculate_distortion(min_ellipse_blue, color::blue);
  262.  
  263. // работа с центрами и их перевод в локальную систему относительно центров эллипсов в зеленом канале
  264. imwrite("/Users/elvinalu/Desktop/picture0.jpeg", imge);
  265. vector <Point2f> centers_red (min_ellipse_red.size());
  266. vector <double> centers_green_X (min_ellipse_green.size());
  267. vector <double> centers_green_Y (min_ellipse_green.size());
  268. vector <Point2f> centers_blue (min_ellipse_blue.size());
  269.  
  270. float min_blue_distortion_x = 10, min_blue_distortion_y = 10, min_red_distortion_x = 10, min_red_distortion_y = 10;
  271. int key = 0;
  272.  
  273. for (int i = 0; i < min_ellipse_green.size(); i++) {
  274. if ((abs(min_ellipse_green[i].center.x - min_ellipse_blue[i].center.x) <= min_blue_distortion_x) &&
  275. (abs(min_ellipse_green[i].center.y - min_ellipse_blue[i].center.y) <= min_blue_distortion_y) &&
  276. (abs(min_ellipse_green[i].center.x - min_ellipse_red[i].center.x) <= min_red_distortion_x) &&
  277. (abs(min_ellipse_green[i].center.y - min_ellipse_red[i].center.y) <= min_red_distortion_y))
  278. {
  279. min_red_distortion_x = abs (min_ellipse_green[i].center.x - min_ellipse_red[i].center.x);
  280. min_blue_distortion_x = abs(min_ellipse_green[i].center.x - min_ellipse_blue[i].center.x);
  281. min_blue_distortion_y = abs(min_ellipse_green[i].center.y - min_ellipse_blue[i].center.y);
  282. min_red_distortion_y = abs(min_ellipse_green[i].center.y - min_ellipse_red[i].center.y);
  283. key = i;
  284. }
  285. }
  286.  
  287. Point2i optical_center = Point2i(round(min_ellipse_green[key].center.x), round(min_ellipse_green[key].center.y));
  288.  
  289. auto coordinate_transition = [](vector<Point2f> & centers, const vector<RotatedRect> & min_ellipse, const Point2f & optical_center) {
  290. for (int i = 0; i < min_ellipse.size(); i++) {
  291. centers[i].x = (min_ellipse[i].center.x - optical_center.x);
  292. centers[i].y = (optical_center.y - min_ellipse[i].center.y);
  293. }
  294. };
  295.  
  296. coordinate_transition(centers_red, min_ellipse_red, optical_center);
  297. coordinate_transition(centers_blue, min_ellipse_red, optical_center);
  298.  
  299. for (int i = 0; i < min_ellipse_green.size(); i++) {
  300. centers_green_X[i] = (min_ellipse_green[i].center.x - optical_center.x);
  301. centers_green_Y[i] = (optical_center.y - min_ellipse_green[i].center.y);
  302. }
  303.  
  304. int Degree = 1;
  305. vector<vector<double>> red_Xy(centers_red.size());
  306. vector<vector<double>> blue_Xy(centers_blue.size());
  307. vector<vector<double>> blue_xY(centers_blue.size());
  308. vector<vector<double>> red_xY(centers_red.size());
  309.  
  310. tbb::parallel_for(int(0), (int)centers_red.size(), [&](int i) {
  311. count_degrees(centers_red[i], Degree, red_Xy[i]);
  312. count_degrees(centers_blue[i], Degree, blue_Xy[i]);
  313. count_degrees(Point2f(centers_red[i].y, centers_red[i].x), Degree, red_xY[i]);
  314. count_degrees(Point2f(centers_blue[i].y, centers_blue[i].x), Degree, blue_xY[i]);
  315. });
  316.  
  317. //запись вывода в файл
  318. ofstream out ("/Users/elvinalu/Desktop/test1.txt");
  319. out << scientific;
  320. out.precision(1);
  321. int end = (Degree + 1) * (Degree + 2) / 2;
  322. for (int i = 0; i < centers_red.size(); i++) {
  323. for (int j = 0; j < end; j++) {
  324. if (j != end - 1) {
  325. out <<"p[" << i << "][" << j << "]*" << blue_Xy[i][j] << "+ ";
  326. } else {
  327. out <<"p[" << i << "][" << j << "]*" << blue_Xy[i][j] << " = " << centers_green_X[i];
  328. }
  329.  
  330. }
  331. out << endl;
  332. }
  333. out.close();
  334. vector<vector<double>> DegreeX_yRed;
  335. vector<vector<double>> DegreeX_yBlue;
  336. vector<double> solve_green_RedX;
  337. vector<double> solve_green_BlueX;
  338. vector<vector<double>> Degreex_YRed;
  339. vector<vector<double>> Degreex_YBlue;
  340. vector<double> solve_green_RedY;
  341. vector<double> solve_green_BlueY;
  342.  
  343. least_quadrantic(red_Xy, Degree, centers_green_X, DegreeX_yRed, solve_green_RedX);
  344. least_quadrantic(blue_Xy, Degree, centers_green_X, DegreeX_yBlue, solve_green_BlueX);
  345. least_quadrantic(red_xY, Degree, centers_green_Y, Degreex_YRed, solve_green_RedY);
  346. least_quadrantic(blue_xY, Degree, centers_green_Y, Degreex_YBlue, solve_green_BlueY);
  347.  
  348. //запись вывода в файл для наглядности + создание дополнительных матриц для решения системы ЛУ в armadillo
  349. ofstream fout ("/Users/elvinalu/Desktop/test2.txt");
  350. fout << scientific;
  351. fout.precision(1);
  352. arma::mat redx = arma::Mat<double>(DegreeX_yRed.size(), DegreeX_yRed.size());
  353. arma::mat bluex = arma::Mat<double>(DegreeX_yBlue.size(), DegreeX_yBlue.size());
  354. arma::mat redy = arma::Mat<double>(Degreex_YRed.size(), Degreex_YRed.size());
  355. arma::mat bluey = arma::Mat<double>(Degreex_YBlue.size(), Degreex_YBlue.size());
  356.  
  357. for (int i = 0; i < DegreeX_yRed.size(); i++) {
  358. for (int j = 0; j < DegreeX_yRed.size(); j++) {
  359. redx(i, j) = DegreeX_yRed[i][j];
  360. bluex(i, j) = DegreeX_yBlue[i][j];
  361. redy(i, j) = Degreex_YRed[i][j];
  362. bluey(i, j) = Degreex_YBlue[i][j];
  363. if (j != end - 1) {
  364. fout << DegreeX_yRed[i][j] << "+ ";
  365. } else {
  366. fout << DegreeX_yRed[i][j] << " = 0";
  367. }
  368.  
  369. }
  370. fout << endl;
  371. }
  372. fout.close();
  373. cout << endl << optical_center << endl;
  374. arma::vec solrgx = arma::solve(redx, move(arma::vec(solve_green_RedX)));
  375. arma::vec solbgx = arma::solve(bluex, move(arma::vec(solve_green_BlueX)));
  376. arma::vec solrgy = arma::solve(redy, move(arma::vec(solve_green_RedY)));
  377. arma::vec solbgy = arma::solve(bluey, move(arma::vec(solve_green_BlueY)));
  378. solrgx.print();
  379. cout << endl << endl;
  380. solrgy.print();
  381. cout << endl << endl;
  382. solbgx.print();
  383. cout << endl;
  384. solbgy.print();
  385.  
  386. double maxi = 0, maxj = 0;
  387. double maxi1 = 0, maxj1 = 0;
  388.  
  389.  
  390. //_____________________________________
  391. //
  392. //ЗДЕСЬ ТЕСТОВАЯ РАСПЕЧАТКА МАКСИМАЛЬНЫХ ОТКЛОНЕНИЙ В КРАСНОМ КАНАЛЕ ДЛЯ УЖЕ САППРОКСИМИРОВАННЫХ ЗНАЧЕНИЙ!!!
  393. //
  394. //_____________________________________
  395.  
  396.  
  397. for (int t = 0; t < centers_red.size(); t++) {
  398. Point2i coord_red = solution(solrgx, solrgy, Degree, Point2f(centers_red[t].x,centers_red[t].y), optical_center.x, optical_center.y);
  399. if (maxi < abs(min_ellipse_green[t].center.x - coord_red.x)) {
  400. maxi = abs(min_ellipse_green[t].center.x - coord_red.x);
  401. }
  402. if (maxj < abs(min_ellipse_green[t].center.y - coord_red.y)) {
  403. maxj = abs(min_ellipse_green[t].center.y - coord_red.y);
  404. }
  405. cout << min_ellipse_red[t].center << "; " << min_ellipse_green[t].center << endl;
  406. cout << coord_red << "; [" << centers_green_X[t] << "; " << centers_green_Y[t] << "];" << endl;
  407. cout << endl << endl;
  408. if (maxi1 < abs(centers_green_X[t] - centers_red[t].x)) {
  409. maxi1 = abs(centers_green_X[t] - centers_red[t].x);
  410. }
  411. if (maxj1 < abs(centers_green_Y[t]- centers_red[t].y)) {
  412. maxj1 = abs(centers_green_Y[t] - centers_red[t].y);
  413. }
  414. }
  415. //новое максимальное отклонение
  416.  
  417. cout << maxi << " " << maxj << endl;
  418.  
  419. //старое
  420.  
  421. cout << maxi1 << " " << maxj1 << endl;
  422. cout << endl << endl << endl;
  423.  
  424. double maxbi = 0, maxbj = 0;
  425. double maxib1 = 0, maxjb1 = 0;
  426.  
  427. for (int t = 0; t < centers_blue.size(); t++) {
  428. Point2i coord_blue = solution(solbgx, solbgy, Degree, Point2f(centers_blue[t].x,centers_blue[t].y), optical_center.x, optical_center.y);
  429. if (maxbi < abs(min_ellipse_green[t].center.x - min_ellipse_blue[t].center.x)) {
  430. maxbi = abs(min_ellipse_green[t].center.x - min_ellipse_blue[t].center.x);
  431. }
  432. if (maxbj < abs(min_ellipse_green[t].center.y - min_ellipse_blue[t].center.y)) {
  433. maxbj = abs(min_ellipse_green[t].center.y - min_ellipse_blue[t].center.y);
  434. }
  435. cout << min_ellipse_blue[t].center << "; " << min_ellipse_green[t].center << endl;
  436. cout << coord_blue << "; " << min_ellipse_green[t].center << endl;
  437. cout << endl << endl;
  438. if (maxib1 < abs(centers_green_X[t] - centers_blue[t].x)) {
  439. maxib1 = abs(centers_green_X[t] - centers_blue[t].x);
  440. }
  441. if (maxjb1 < abs(centers_green_Y[t]- centers_blue[t].y)) {
  442. maxjb1 = abs(centers_green_Y[t] - centers_blue[t].y);
  443. }
  444. }
  445.  
  446. //новое максимальное отклонение
  447.  
  448. cout << maxbi << " " << maxbj << endl;
  449.  
  450. //старое
  451.  
  452. cout << maxib1 << " " << maxjb1 << endl;
  453.  
  454. imshow("img2", imgy);
  455. imwrite("/Users/elvinalu/Desktop/picture3.jpeg", imgy);
  456.  
  457. tbb::tick_count t0 = tbb::tick_count().now();
  458. tbb::parallel_for(int(0), img.rows, [&](int i) {
  459. tbb::parallel_for(int(0), img.cols, [&](int j) {
  460. Point2i coord_red = solution(solrgx, solrgy, Degree, Point2f(i - optical_center.x,optical_center.y - j), optical_center.x, optical_center.y);
  461. Point2i coord_blue = solution(solbgx, solbgy, Degree, Point2f(i - optical_center.x,optical_center.y - j), optical_center.x, optical_center.y);
  462. //solution(solbgx, solbgy, Degree, Point2f(centers_blue[t].x,centers_blue[t].y), optical_center.x, optical_center.y)
  463. //img_result.at<Vec3b>(i, j)[2] = imgy.at<Vec3b> (i, j)[2];
  464. img_result.at<Vec3b>(i, j)[1] = imgy.at<Vec3b>(i, j)[1];
  465. //img_result.at<Vec3b>(i, j)[0] = imgy.at<Vec3b>(i,j)[0];
  466.  
  467. img_result.at<Vec3b>(coord_blue.x, coord_blue.y)[0] = imgy.at<Vec3b>(i, j)[0];
  468. img_result.at<Vec3b>(coord_red.x, coord_red.y)[2] = imgy.at<Vec3b>(i, j)[2];
  469. if (i == 397 && ((j > 396 && j < 401) || (j > 798 && j < 802))) {
  470. printf(" %d; %d\t\t%.0d; %.0d\n", i, j, coord_blue.x, coord_blue.y);
  471. }
  472.  
  473. });
  474. });
  475. tbb::tick_count t1 = tbb::tick_count().now();
  476. cout << (t1 - t0).seconds() << endl;
  477.  
  478. cout << "end" ;
  479. imshow("img_result", img_result);
  480. imwrite("/Users/elvinalu/Desktop/pictr.jpeg", img_result);
  481. image.release();
  482. red.release();
  483. green.release();
  484. blue.release();
  485. img.release();
  486. imge.release();
  487. imgy.release();
  488. img_copy.release();
  489. img_result.release();
  490. image1.release();
  491. image2.release();
  492. return 0;
  493. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!