API tools faq
paste
DarkDevourer

Курсовая ООП без класса

DarkDevourer
May 20th, 2020
72
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.97 KB | None | 0 0
raw download clone embed print report
  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3. #include <math.h>
  4. #include <cstdlib>
  5. #include <string>
  6. #include <fstream>
  7. #include <GL/freeglut.h>
  8. #include <windows.h>
  9. #include <ctime>
  10.  
  11.  
  12. /*class Graphics
  13. {
  14. private:
  15. double *X; //Указатели на будущий динамический массив
  16. int N, w, h; //Размерность массива и графика
  17. string changer;
  18. public:
  19. Graphics(int);
  20. Graphics();
  21. ~Graphics();
  22. void Printing_Arrays_into_Files(double *X, int *N); //Метод, записывающий массив X[k] в файл
  23. void Graph_Draw1(); //Подпрограмма, создающая график массива X[k]
  24. void Graph_Draw2(); //Подпрограмма, создающая частотную характеристику массива X[k]
  25. void Graph_Draw3(); //Подпрограмма, создающая гистограмму массива X[k]
  26. private:
  27. void From_String_To_Double(int *flag, string &x, int *k, double *X, int *N); //Подпрограмма для получения элементов массива X[k] из строки x
  28. void Graphics_Creation1(); //Подпрограмма, создающая график массива X[k]
  29. void Graphics_Creation2(); //Подпрограмма, создающая частотную характеристику массива X[k]
  30. void Graphics_Creation3(); //Подпрограмма, создающая гистограмму массива X[k]
  31. void PrintText(float x, float y, int r, int g, int b, string string); //Подпрограмма, показывающая текст на экране (для расположения координат и названий осей графиков)
  32. void reshape(int w, int h);
  33. void ScreenShot1(int W, int Hz); //Подпрограмма, сохраняющая график X[k] функции в bmp-файл
  34. void ScreenShot2(int W, int H); //Подпрограмма, сохраняющая частотный график в bmp-файл
  35. void ScreenShot3(int W, int H); //Подпрограмма, сохраняющая гистограмму в bmp-файл
  36. };*/
  37. using namespace std;
  38.  
  39. void Printing_Arrays_into_Files(double *X, int *N); //Метод, записывающий массив X[k] в файл
  40.  
  41. void From_String_To_Double(int *flag, string &x, int *k, double *X, int *N); //Подпрограмма для получения элементов массива X[k] из строки x
  42.  
  43. void Graphics_Creation1(); //Подпрограмма, создающая график массива X[k]
  44.  
  45. void Graphics_Creation2(); //Подпрограмма, создающая частотную характеристику массива X[k]
  46.  
  47. void Graphics_Creation3(); //Подпрограмма, создающая гистограмму массива X[k]
  48.  
  49. void PrintText(float x, float y, int r, int g, int b, string string); //Подпрограмма, показывающая текст на экране (для расположения координат и названий осей графиков)
  50.  
  51. void reshape(int w, int h);
  52.  
  53. void ScreenShot1(int W, int Hz); //Подпрограмма, сохраняющая график X[k] функции в bmp-файл
  54.  
  55. void ScreenShot2(int W, int H); //Подпрограмма, сохраняющая частотный график в bmp-файл
  56.  
  57. void ScreenShot3(int W, int H); //Подпрограмма, сохраняющая гистограмму в bmp-файл
  58.  
  59. double *X; //Указатели на будущие динамические массивы
  60. int N; //Размерность массива
  61.  
  62. int w, h; //w - ширина будущего окна с графиками, h - его высота
  63.  
  64. string changer; //Строка для рисования числа-масштаба на экран. Нужна для того, чтобы убрать 0 после ",", если дробная часть равна 0 или бесконечно мала
  65.  
  66. void From_String_To_Double(int *flag, string &x, int *k, double *X, int *N)
  67. {
  68. size_t number2 = x.find_first_not_of("-,.0123456789");
  69. size_t symbols = x.find_first_not_of("-,.");
  70. size_t point = x.find_first_not_of(".");
  71. if ((number2 != std::string::npos) || (symbols == std::string::npos) || (x.find(".") != x.rfind(".")))
  72. {
  73. cout << "Ошибка. Наличие постороннего символа (написано не число). Возврат в меню." << endl;
  74. *flag = 1;
  75. return;
  76. }
  77.  
  78. while (x.find(".") != -1)
  79. {
  80. x.replace(x.find("."), 1, ",");
  81. }
  82.  
  83. X[*k] = stod(x.c_str());
  84.  
  85. *k += 1;
  86. }
  87.  
  88. void Printing_Arrays_into_Files(double *X, int *N) //Подпрограмма, записывающая массив X[k] в файл
  89. {
  90. int k;
  91. std::ofstream out;
  92. out.open("C:\\Kursovaya\\KursovayaOutput.txt"); //Открытие файла вывода
  93. if (!out.is_open()) //Если файл не открылся
  94. {
  95. cout << "Файл для записи массивов: C:\\Kursovaya\\KursovayaOutput.txt - открыть не удалось." << endl;
  96. return;
  97. }
  98. out << "Массив X[k]:" << endl;
  99. for (k = 0; k < *N; k++) //Запись массива X[k]
  100. {
  101. out << "X[" << k << "] = " << X[k] << endl;
  102. }
  103. out.close(); //Закрытие файла вывода
  104. }
  105.  
  106.  
  107. void Graphics_Creation1() //Подпрограмма, создающая графики массивf X[k]
  108. {
  109. int length_x = w - 15; //Длина каждого графика по оси x
  110. int length_y = floor(h - 60);
  111. double y_max, y_min, length;
  112. int k, i, y;
  113. double mast_y;
  114. double mast_x = floor(w - 15 / N);
  115. glClear(GL_COLOR_BUFFER_BIT);
  116.  
  117. //Создание вертикальных и горизонтальных осей двух графиков
  118.  
  119.  
  120. glBegin(GL_LINES); //Построение вертикальной оси
  121. glColor3f(0.0, 0.0, 0.0);
  122. glVertex2i(5, h - 30);
  123. glColor3f(0.0, 0.0, 0.0);
  124. glVertex2i(5, h - 30 - length_y);
  125. glEnd();
  126.  
  127. glBegin(GL_LINES); //Черчение стрелки
  128. glColor3f(0.0, 0.0, 0.0);
  129. glVertex2i(5, h - 30);
  130. glColor3f(0.0, 0.0, 0.0);
  131. glVertex2i(0, h - 30 - 10);
  132. glEnd();
  133. glBegin(GL_LINES);
  134. glColor3f(0.0, 0.0, 0.0);
  135. glVertex2i(5, h - 30);
  136. glColor3f(0.0, 0.0, 0.0);
  137. glVertex2i(10, h - 30 - 10);
  138. glEnd();
  139.  
  140. y_max = 200;
  141. y_min = -200;
  142.  
  143. //Находим наибольший и наименьший элементы X[k]
  144. {
  145.  
  146. for (i = 1; i < N; i++)
  147. {
  148. if (y_max < X[i])
  149. {
  150. y_max = X[i];
  151. }
  152. else if (y_min > X[i])
  153. {
  154. y_min = X[i];
  155. }
  156. }
  157. }
  158.  
  159. //Построение горизонтальной оси
  160. length = y_max - y_min;
  161. mast_y = length_y / length; //Масштаб оси ординат по кол-ву точек
  162. y = h - 30 - length_y * y_max / length;
  163. glBegin(GL_LINES);
  164. glColor3f(0.0, 0.0, 0.0);
  165. glVertex2i(5, y);
  166. glColor3f(0.0, 0.0, 0.0);
  167. glVertex2i(w, y);
  168. glEnd();
  169.  
  170. glBegin(GL_LINES); //Черчение стрелки
  171. glColor3f(0.0, 0.0, 0.0);
  172. glVertex2i(w, y);
  173. glColor3f(0.0, 0.0, 0.0);
  174. glVertex2i(w - 10, y - 5);
  175. glEnd();
  176. glBegin(GL_LINES);
  177. glColor3f(0.0, 0.0, 0.0);
  178. glVertex2i(w, y);
  179. glColor3f(0.0, 0.0, 0.0);
  180. glVertex2i(w - 10, y + 5);
  181. glEnd();
  182.  
  183.  
  184. //Подписывание осей графиков
  185. PrintText(15, h - 30, 0, 0, 0, "X[k]");
  186. PrintText(w - 10, y - 15, 0, 0, 0, "k");
  187.  
  188. //Построение штрихов на горизонтальной оси
  189. for (i = 0; i < N; i++)
  190. {
  191. glBegin(GL_LINES); //X[k]
  192. glColor3f(0.0, 0.0, 0.0);
  193. glVertex2i(5 + mast_x * i / N, y + 5);
  194. glColor3f(0.0, 0.0, 0.0);
  195. glVertex2i(5 + mast_x * i / N, y - 5);
  196. glEnd();
  197. PrintText(5 + mast_x * i / N, y - 17, 0, 0, 0, to_string(i));
  198. }
  199.  
  200. //Построение штрихов на вертикальной оси
  201. //Количество штрихов фиксированно - 20. При -200<=y<=200 шаг равен 20. Иначе - меняется.
  202. //Если заменить 20 на N, а 19 - на N-1, число штрихов по вертикали станет равным числу штрихов по горизонтали
  203. for (k = 1; k <= 19; k++)
  204. {
  205.  
  206. if (y - k * length_y / 20 >= h - 30 - length_y)
  207. {
  208. glBegin(GL_LINES); //X[k]
  209. glColor3f(0.0, 0.0, 0.0);
  210. glVertex2i(0, y - k * length_y / 20);
  211. glColor3f(0.0, 0.0, 0.0);
  212. glVertex2i(10, y - k * length_y / 20);
  213. glEnd();
  214. changer = to_string(-(y_max - y_min) / 20 * k);
  215. if (-(y_max - y_min) / 20 * k + floor(-(y_max - y_min) / 20 * k) <= 0.000001)
  216. {
  217. changer.erase(changer.find(","), changer.length() - changer.find(","));
  218. }
  219. if (k != 0)
  220. {
  221. PrintText(15, y - k * length_y / 20 - 5, 0, 0, 0, changer);
  222. }
  223. }
  224. else
  225. {
  226. glBegin(GL_LINES); //X[k]
  227. glColor3f(0.0, 0.0, 0.0);
  228. glVertex2i(0, y + (20 - k) * length_y / 20);
  229. glColor3f(0.0, 0.0, 0.0);
  230. glVertex2i(10, y + (20 - k) * length_y / 20);
  231. glEnd();
  232. changer = to_string((y_max - y_min) / 20 * (20 - k));
  233. if ((y_max - y_min) / 20 * (20 - k) - floor((y_max - y_min) / 20 * (20 - k)) <= 0.000001)
  234. {
  235. changer.erase(changer.find(","), changer.length() - changer.find(","));
  236. }
  237. PrintText(15, y + (20 - k) * length_y / 20 - 5, 0, 0, 0, changer);
  238. }
  239.  
  240. }
  241.  
  242. //Построение графиков
  243.  
  244. for (k = 0; k < N; k++)
  245. {
  246. if (k != N - 1)
  247. {
  248. glBegin(GL_LINES); //X[k]
  249. glColor3f(0.0, 0.0, 0.0);
  250. glVertex2i(5 + k * mast_x / N, y + X[k] * mast_y);
  251. glColor3f(0.0, 0.0, 0.0);
  252. glVertex2i(5 + (k + 1) * mast_x / N, y + X[k + 1] * mast_y);
  253. glEnd();
  254.  
  255. }
  256.  
  257. glPointSize(5);
  258.  
  259. glBegin(GL_POINTS); //X[k] - выделение точек
  260. glColor3f(0.0, 0.0, 0.0);
  261. glVertex2i(5 + mast_x * k / N, y + X[k] * mast_y);
  262. glEnd();
  263.  
  264. }
  265.  
  266. ScreenShot1(w, h);
  267. glutSwapBuffers();
  268. }
  269.  
  270. //Подпрограмма, рисующая частотный график X[k]
  271. void Graphics_Creation2()
  272. {
  273. int length_x = w - 15; //Длина оси x
  274. int length_y = h - 60; //Длина оси y
  275. double y_max, y_min, length;
  276. int u, i, y;
  277. double mast_y;
  278. double mast_x = floor(w - 15 / N);
  279. glClear(GL_COLOR_BUFFER_BIT);
  280.  
  281. //Создание вертикальных и горизонтальных осей графика
  282.  
  283. glBegin(GL_LINES); //Построение вертикальной оси
  284. glColor3f(0.0, 0.0, 0.0);
  285. glVertex2i(5, h - 30);
  286. glColor3f(0.0, 0.0, 0.0);
  287. glVertex2i(5, h - 30 - length_y);
  288. glEnd();
  289.  
  290. glBegin(GL_LINES); //Черчение стрелки
  291. glColor3f(0.0, 0.0, 0.0);
  292. glVertex2i(5, h - 30);
  293. glColor3f(0.0, 0.0, 0.0);
  294. glVertex2i(0, h - 40);
  295. glEnd();
  296. glBegin(GL_LINES);
  297. glColor3f(0.0, 0.0, 0.0);
  298. glVertex2i(5, h - 30);
  299. glColor3f(0.0, 0.0, 0.0);
  300. glVertex2i(10, h - 40);
  301. glEnd();
  302.  
  303. y_max = 200;
  304. y_min = -200;
  305. for (i = 1; i < N; i++)
  306. {
  307. if (y_max < X[i])
  308. {
  309. y_max = X[i];
  310. }
  311. else if (y_min > X[i])
  312. {
  313. y_min = X[i];
  314. }
  315. }
  316. //Построение горизонтальной оси
  317. length = y_max - y_min;
  318. mast_y = length_y / length; //Масштаб оси ординат по кол-ву точек
  319. y = h - 30 - length_y * y_max / length;
  320.  
  321. glBegin(GL_LINES);
  322. glColor3f(0.0, 0.0, 0.0);
  323. glVertex2i(5, y);
  324. glColor3f(0.0, 0.0, 0.0);
  325. glVertex2i(w, y);
  326. glEnd();
  327.  
  328. glBegin(GL_LINES); //Черчение стрелки
  329. glColor3f(0.0, 0.0, 0.0);
  330. glVertex2i(w, y);
  331. glColor3f(0.0, 0.0, 0.0);
  332. glVertex2i(w - 10, y - 5);
  333. glEnd();
  334. glBegin(GL_LINES);
  335. glColor3f(0.0, 0.0, 0.0);
  336. glVertex2i(w, y);
  337. glColor3f(0.0, 0.0, 0.0);
  338. glVertex2i(w - 10, y + 5);
  339. glEnd();
  340.  
  341.  
  342. //Подписывание осей графиков
  343. PrintText(15, h - 30, 0, 0, 0, "H[u]");
  344. PrintText(w - 10, y - 15, 0, 0, 0, "u");
  345.  
  346. //Построение штрихов на горизонтальной оси
  347. for (u = 0; u < N; u++)
  348. {
  349. glBegin(GL_LINES); //X[k]
  350. glColor3f(0.0, 0.0, 0.0);
  351. glVertex2i(5 + mast_x * u / N, y + 5);
  352. glColor3f(0.0, 0.0, 0.0);
  353. glVertex2i(5 + mast_x * u / N, y - 5);
  354. glEnd();
  355. PrintText(5 + mast_x * u / N, y - 17, 0, 0, 0, to_string(u));
  356. }
  357.  
  358. //Построение штрихов на вертикальной оси
  359. //Количество штрихов фиксированно - 20. При -200<=y<=200 шаг равен 20. Иначе - меняется.
  360. //Если заменить 20 на N, а 19 - на N-1, число штрихов по вертикали станет равным числу штрихов по горизонтали
  361. for (u = 1; u <= 19; u++)
  362. {
  363. if (y - u * length_y / 20 >= h - 30 - length_y)
  364. {
  365. glBegin(GL_LINES); //X[k]
  366. glColor3f(0.0, 0.0, 0.0);
  367. glVertex2i(0, y - u * length_y / 20);
  368. glColor3f(0.0, 0.0, 0.0);
  369. glVertex2i(10, y - u * length_y / 20);
  370. glEnd();
  371. if (u != 0)
  372. {
  373. changer = to_string(-(y_max - y_min) / 20 * u);
  374. if (-(y_max - y_min) / 20 * u + floor(-(y_max - y_min) / 20 * u) <= 0.000001)
  375. {
  376. changer.erase(changer.find(","), changer.length() - changer.find(","));
  377. }
  378. PrintText(15, y - u * length_y / 20 - 5, 0, 0, 0, changer);
  379. }
  380. }
  381. else
  382. {
  383. glBegin(GL_LINES); //X[k]
  384. glColor3f(0.0, 0.0, 0.0);
  385. glVertex2i(0, y + (20 - u) * length_y / 20);
  386. glColor3f(0.0, 0.0, 0.0);
  387. glVertex2i(10, y + (20 - u) * length_y / 20);
  388. glEnd();
  389. changer = to_string((y_max - y_min) / 20 * (20 - u));
  390. if ((y_max - y_min) / 20 * (20 - u) - floor((y_max - y_min) / 20 * (20 - u)) <= 0.000001)
  391. {
  392. changer.erase(changer.find(","), changer.length() - changer.find(","));
  393. }
  394. PrintText(15, y + (20 - u) * length_y / 20 - 5, 0, 0, 0, changer);
  395. }
  396. }
  397.  
  398. //Построение графиков
  399.  
  400. for (u = 0; u < N; u++)
  401. {
  402. glBegin(GL_LINES); //H[k]
  403. glColor3f(0.0, 0.0, 0.0);
  404. glVertex2i(5 + u * mast_x / N, y);
  405. glColor3f(0.0, 0.0, 0.0);
  406. glVertex2i(5 + (u)* mast_x / N, y + X[u] * mast_y);
  407. glEnd();
  408.  
  409. glPointSize(5);
  410.  
  411. glBegin(GL_POINTS); //H[k] - выделение точек
  412. glColor3f(0.0, 0.0, 0.0);
  413. glVertex2i(5 + mast_x * u / N, y + X[u] * mast_y);
  414. glEnd();
  415.  
  416. }
  417.  
  418. ScreenShot2(w, h);
  419. glutSwapBuffers();
  420. }
  421.  
  422. void Graphics_Creation3() //Подпрограмма, создающая графики массивf X[k]
  423. {
  424. int length_x = w - 15; //Длина каждого графика по оси x
  425. int length_y = floor(h - 60);
  426. double y_max, y_min, length;
  427. int k, i, y;
  428. double mast_y;
  429. double mast_x = floor(w - 15 / N);
  430. glClear(GL_COLOR_BUFFER_BIT);
  431.  
  432. //Создание вертикальных и горизонтальных осей двух графиков
  433.  
  434.  
  435. glBegin(GL_LINES); //Построение вертикальной оси
  436. glColor3f(0.0, 0.0, 0.0);
  437. glVertex2i(5, h - 30);
  438. glColor3f(0.0, 0.0, 0.0);
  439. glVertex2i(5, h - 30 - length_y);
  440. glEnd();
  441.  
  442. glBegin(GL_LINES); //Черчение стрелки
  443. glColor3f(0.0, 0.0, 0.0);
  444. glVertex2i(5, h - 30);
  445. glColor3f(0.0, 0.0, 0.0);
  446. glVertex2i(0, h - 30 - 10);
  447. glEnd();
  448. glBegin(GL_LINES);
  449. glColor3f(0.0, 0.0, 0.0);
  450. glVertex2i(5, h - 30);
  451. glColor3f(0.0, 0.0, 0.0);
  452. glVertex2i(10, h - 30 - 10);
  453. glEnd();
  454.  
  455. y_max = 200;
  456. y_min = -200;
  457.  
  458. //Находим наибольший и наименьший элементы X[k]
  459. {
  460.  
  461. for (i = 1; i < N; i++)
  462. {
  463. if (y_max < X[i])
  464. {
  465. y_max = X[i];
  466. }
  467. else if (y_min > X[i])
  468. {
  469. y_min = X[i];
  470. }
  471. }
  472. }
  473.  
  474. //Построение горизонтальной оси
  475. length = y_max - y_min;
  476. mast_y = length_y / length; //Масштаб оси ординат по кол-ву точек
  477. y = h - 30 - length_y * y_max / length;
  478. glBegin(GL_LINES);
  479. glColor3f(0.0, 0.0, 0.0);
  480. glVertex2i(5, y);
  481. glColor3f(0.0, 0.0, 0.0);
  482. glVertex2i(w, y);
  483. glEnd();
  484.  
  485. glBegin(GL_LINES); //Черчение стрелки
  486. glColor3f(0.0, 0.0, 0.0);
  487. glVertex2i(w, y);
  488. glColor3f(0.0, 0.0, 0.0);
  489. glVertex2i(w - 10, y - 5);
  490. glEnd();
  491. glBegin(GL_LINES);
  492. glColor3f(0.0, 0.0, 0.0);
  493. glVertex2i(w, y);
  494. glColor3f(0.0, 0.0, 0.0);
  495. glVertex2i(w - 10, y + 5);
  496. glEnd();
  497.  
  498.  
  499. //Подписывание осей графиков
  500. PrintText(15, h - 30, 0, 0, 0, "X[k]");
  501. PrintText(w - 10, y - 15, 0, 0, 0, "k");
  502.  
  503. //Построение штрихов на горизонтальной оси
  504. for (i = 0; i < N; i++)
  505. {
  506. glBegin(GL_LINES); //X[k]
  507. glColor3f(0.0, 0.0, 0.0);
  508. glVertex2i(5 + mast_x * i / N, y + 5);
  509. glColor3f(0.0, 0.0, 0.0);
  510. glVertex2i(5 + mast_x * i / N, y - 5);
  511. glEnd();
  512. PrintText(5 + mast_x * i / N, y - 17, 0, 0, 0, to_string(i));
  513. }
  514.  
  515. //Построение штрихов на вертикальной оси
  516. //Количество штрихов фиксированно - 20. При -200<=y<=200 шаг равен 20. Иначе - меняется.
  517. //Если заменить 20 на N, а 19 - на N-1, число штрихов по вертикали станет равным числу штрихов по горизонтали
  518. for (k = 1; k <= 19; k++)
  519. {
  520.  
  521. if (y - k * length_y / 20 >= h - 30 - length_y)
  522. {
  523. glBegin(GL_LINES); //X[k]
  524. glColor3f(0.0, 0.0, 0.0);
  525. glVertex2i(0, y - k * length_y / 20);
  526. glColor3f(0.0, 0.0, 0.0);
  527. glVertex2i(10, y - k * length_y / 20);
  528. glEnd();
  529. changer = to_string(-(y_max - y_min) / 20 * k);
  530. if (-(y_max - y_min) / 20 * k + floor(-(y_max - y_min) / 20 * k) <= 0.000001)
  531. {
  532. changer.erase(changer.find(","), changer.length() - changer.find(","));
  533. }
  534. if (k != 0)
  535. {
  536. PrintText(15, y - k * length_y / 20 - 5, 0, 0, 0, changer);
  537. }
  538. }
  539. else
  540. {
  541. glBegin(GL_LINES); //X[k]
  542. glColor3f(0.0, 0.0, 0.0);
  543. glVertex2i(0, y + (20 - k) * length_y / 20);
  544. glColor3f(0.0, 0.0, 0.0);
  545. glVertex2i(10, y + (20 - k) * length_y / 20);
  546. glEnd();
  547. changer = to_string((y_max - y_min) / 20 * (20 - k));
  548. if ((y_max - y_min) / 20 * (20 - k) - floor((y_max - y_min) / 20 * (20 - k)) <= 0.000001)
  549. {
  550. changer.erase(changer.find(","), changer.length() - changer.find(","));
  551. }
  552. PrintText(15, y + (20 - k) * length_y / 20 - 5, 0, 0, 0, changer);
  553. }
  554.  
  555. }
  556.  
  557. //Построение графиков
  558.  
  559. for (k = 0; k < N; k++)
  560. {
  561. if (k != N - 1)
  562. {
  563. glBegin(GL_LINES); //X[k]
  564. glColor3f(0.0, 0.0, 0.0);
  565. glVertex2i(5 + k * mast_x / N, y);
  566. glColor3f(0.0, 0.0, 0.0);
  567. glVertex2i(5 + k * mast_x / N, y + X[k] * mast_y);
  568. glEnd();
  569.  
  570. glBegin(GL_LINES);
  571. glColor3f(0.0, 0.0, 0.0);
  572. glVertex2i(5 + (k + 1) * mast_x / N, y);
  573. glColor3f(0.0, 0.0, 0.0);
  574. glVertex2i(5 + (k + 1)* mast_x / N, y + X[k] * mast_y);
  575. glEnd();
  576.  
  577. glBegin(GL_LINES); //X[k]
  578. glColor3f(0.0, 0.0, 0.0);
  579. glVertex2i(5 + k * mast_x / N, y + X[k] * mast_y);
  580. glColor3f(0.0, 0.0, 0.0);
  581. glVertex2i(5 + (k + 1)* mast_x / N, y + X[k] * mast_y);
  582. glEnd();
  583.  
  584. }
  585.  
  586. }
  587.  
  588. ScreenShot3(w, h);
  589. glutSwapBuffers();
  590. }
  591.  
  592. //Подпрограмма, показывающая текст на экране (для расположения координат и названий осей графиков)
  593. void PrintText(float x, float y, int r, int g, int b, string string)
  594. {
  595. char *text = new char[string.length()];
  596. glColor3f(r, g, b);
  597. glRasterPos2f(x, y);
  598. for (int i = 0; i < string.length(); i++)
  599. text[i] = string[i];
  600. for (int i = 0; i < string.length(); i++)
  601. {
  602. glutBitmapCharacter(GLUT_BITMAP_9_BY_15, text[i]);
  603. x += 2;
  604. }
  605. delete[] text;
  606. }
  607.  
  608.  
  609. void reshape(int w, int h)
  610. {
  611. glViewport(0, 0, w, h);
  612.  
  613. glMatrixMode(GL_PROJECTION);
  614. glLoadIdentity();
  615. gluOrtho2D(0, w, 0, h);
  616.  
  617. glMatrixMode(GL_MODELVIEW);
  618. glLoadIdentity();
  619. }
  620.  
  621. void ScreenShot1(int W, int H)
  622. {
  623. FILE *F = fopen("C:\\Kursovaya\\Graphs1.bmp", "w");
  624. if (F == NULL)
  625. {
  626. cout << "Файл для записи графика массива X[k] открыть/создать не удалось." << endl;
  627. return;
  628. }
  629.  
  630. const int imSize = W * H * 3;
  631. unsigned char *image = new unsigned char[imSize];
  632.  
  633. if (!image) //Проверка, выделилиась ли память
  634. {
  635. cout << "Не удалось выделить память под массивы." << endl;
  636. return;
  637. }
  638.  
  639. memset(image, 0, imSize);
  640. glReadPixels(0, 0, W, H, GL_RGB, GL_UNSIGNED_BYTE, image);
  641. BITMAPINFO bmi;
  642. unsigned char BMI = sizeof(BITMAPINFOHEADER);
  643. unsigned char BMF = sizeof(BITMAPFILEHEADER);
  644. memset(&bmi, 0, BMI);
  645. bmi.bmiHeader.biSize = BMI;
  646. bmi.bmiHeader.biHeight = H;
  647. bmi.bmiHeader.biWidth = W;
  648. bmi.bmiHeader.biPlanes = 1;
  649. bmi.bmiHeader.biBitCount = 24;
  650. bmi.bmiHeader.biCompression = BI_RGB;
  651. bmi.bmiHeader.biSizeImage = imSize;
  652.  
  653. int nBitsOffset = BMF + BMI;
  654. LONG lImageSize = imSize;
  655. LONG lFileSize = nBitsOffset + lImageSize;
  656. BITMAPFILEHEADER bmfh;
  657. bmfh.bfType = 0x4D42;
  658. bmfh.bfOffBits = nBitsOffset;
  659. bmfh.bfSize = lFileSize;
  660. bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
  661.  
  662. UINT nWrittenFileHeaderSize = fwrite(&bmfh, 1, BMF, F);
  663. UINT nWrittenInfoHeaderSize = fwrite(&bmi, 1, BMI, F);
  664. UINT nWrittenDIBDataSize = fwrite(image, 1, imSize, F);
  665. UINT total = nWrittenDIBDataSize + nWrittenInfoHeaderSize + nWrittenFileHeaderSize;
  666. delete[]image;
  667. fclose(F);
  668. }
  669.  
  670. void ScreenShot2(int W, int H)
  671. {
  672. FILE *F = fopen("C:\\Kursovaya\\Graphs2.bmp", "w");
  673. if (F == NULL)
  674. {
  675. cout << "Файл для записи частотного графика массива X[k] открыть/создать не удалось." << endl;
  676. return;
  677. }
  678.  
  679. const int imSize = W * H * 3;
  680. unsigned char *image = new unsigned char[imSize];
  681.  
  682. if (!image) //Проверка, выделилиась ли память
  683. {
  684. cout << "Не удалось выделить память под массивы." << endl;
  685. return;
  686. }
  687.  
  688. memset(image, 0, imSize);
  689. glReadPixels(0, 0, W, H, GL_RGB, GL_UNSIGNED_BYTE, image);
  690. BITMAPINFO bmi;
  691. unsigned char BMI = sizeof(BITMAPINFOHEADER);
  692. unsigned char BMF = sizeof(BITMAPFILEHEADER);
  693. memset(&bmi, 0, BMI);
  694. bmi.bmiHeader.biSize = BMI;
  695. bmi.bmiHeader.biHeight = H;
  696. bmi.bmiHeader.biWidth = W;
  697. bmi.bmiHeader.biPlanes = 1;
  698. bmi.bmiHeader.biBitCount = 24;
  699. bmi.bmiHeader.biCompression = BI_RGB;
  700. bmi.bmiHeader.biSizeImage = imSize;
  701.  
  702. int nBitsOffset = BMF + BMI;
  703. LONG lImageSize = imSize;
  704. LONG lFileSize = nBitsOffset + lImageSize;
  705. BITMAPFILEHEADER bmfh;
  706. bmfh.bfType = 0x4D42;
  707. bmfh.bfOffBits = nBitsOffset;
  708. bmfh.bfSize = lFileSize;
  709. bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
  710.  
  711. UINT nWrittenFileHeaderSize = fwrite(&bmfh, 1, BMF, F);
  712. UINT nWrittenInfoHeaderSize = fwrite(&bmi, 1, BMI, F);
  713. UINT nWrittenDIBDataSize = fwrite(image, 1, imSize, F);
  714. UINT total = nWrittenDIBDataSize + nWrittenInfoHeaderSize + nWrittenFileHeaderSize;
  715. delete[]image;
  716. fclose(F);
  717. }
  718.  
  719. void ScreenShot3(int W, int H)
  720. {
  721. FILE *F = fopen("C:\\Kursovaya\\Graphs3.bmp", "w");
  722. if (F == NULL)
  723. {
  724. cout << "Файл для записи гистограммы массива X[k] открыть/создать не удалось." << endl;
  725. return;
  726. }
  727.  
  728. const int imSize = W * H * 3;
  729. unsigned char *image = new unsigned char[imSize];
  730.  
  731. if (!image) //Проверка, выделилиась ли память
  732. {
  733. cout << "Не удалось выделить память под массивы." << endl;
  734. return;
  735. }
  736.  
  737. memset(image, 0, imSize);
  738. glReadPixels(0, 0, W, H, GL_RGB, GL_UNSIGNED_BYTE, image);
  739. BITMAPINFO bmi;
  740. unsigned char BMI = sizeof(BITMAPINFOHEADER);
  741. unsigned char BMF = sizeof(BITMAPFILEHEADER);
  742. memset(&bmi, 0, BMI);
  743. bmi.bmiHeader.biSize = BMI;
  744. bmi.bmiHeader.biHeight = H;
  745. bmi.bmiHeader.biWidth = W;
  746. bmi.bmiHeader.biPlanes = 1;
  747. bmi.bmiHeader.biBitCount = 24;
  748. bmi.bmiHeader.biCompression = BI_RGB;
  749. bmi.bmiHeader.biSizeImage = imSize;
  750.  
  751. int nBitsOffset = BMF + BMI;
  752. LONG lImageSize = imSize;
  753. LONG lFileSize = nBitsOffset + lImageSize;
  754. BITMAPFILEHEADER bmfh;
  755. bmfh.bfType = 0x4D42;
  756. bmfh.bfOffBits = nBitsOffset;
  757. bmfh.bfSize = lFileSize;
  758. bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
  759.  
  760. UINT nWrittenFileHeaderSize = fwrite(&bmfh, 1, BMF, F);
  761. UINT nWrittenInfoHeaderSize = fwrite(&bmi, 1, BMI, F);
  762. UINT nWrittenDIBDataSize = fwrite(image, 1, imSize, F);
  763. UINT total = nWrittenDIBDataSize + nWrittenInfoHeaderSize + nWrittenFileHeaderSize;
  764. delete[]image;
  765. fclose(F);
  766. }
  767.  
  768. int main(int argc, char * argv[])
  769. {
  770. ifstream in;
  771. setlocale(LC_ALL, "RUSSIAN");
  772. string key, key1, N1, x, temps, w1, h1;
  773. int k, flag;
  774. int i;
  775. double start, graph1, graph2;
  776.  
  777. cout << "Программа для преобразования массива X[k] в массив H[u] по формуле дискретного преобразования Хартли и массива Xобр[k] по формуле обратного преобразования Хартли" << endl;
  778. while (1)
  779. {
  780. cout << "Выберите режим работы программы:\n1 - создание фиксированного массива.\n2 - создание массива на основе файла.\n0 - выход из программы.\nПримечание: название файла: \"C:\\test\\KursovayaInput.txt\"" << endl << "Выбрано ";
  781. getline(cin, key);
  782.  
  783. if (key == "1")
  784. {
  785. start = clock();
  786. flag = 0;
  787. k = 0;
  788. N = 40;
  789.  
  790. srand(time(NULL));
  791. X = new double[N]; //Создание динамических массивов (эта и две след. строки)
  792.  
  793. if (!X) //Проверка, выделилиась ли память
  794. {
  795. cout << "Не удалось выделить память под массивы." << endl;
  796. continue;
  797. }
  798.  
  799. for (k = 0; k < 40; k++)
  800. {
  801. X[k] = rand() % 401 - 200; //Заполнение массива случайными числами в диапазоне от -200 до 200
  802. }
  803.  
  804. Printing_Arrays_into_Files(X, &N); //Вывод массивов в файл
  805.  
  806. w = 1900;
  807. h = 1000; //Создание окна размером 1900x1000
  808.  
  809. //Создание окна для рисования графиков X[k] и X(обратное)[k]
  810.  
  811. glutInit(&argc, argv);
  812. glutInitDisplayMode(GLUT_DOUBLE);
  813. glutInitWindowPosition(0, 0);
  814. glutInitWindowSize(w, h);
  815. glutCreateWindow("Графики массивов");
  816.  
  817. glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,
  818. GLUT_ACTION_GLUTMAINLOOP_RETURNS);
  819.  
  820. glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  821.  
  822. glutReshapeFunc(reshape);
  823.  
  824. glutDisplayFunc(Graphics_Creation1); //Подпрограмма, рисующая графики массивов X[k] и X(обратное)[k]
  825.  
  826. graph1 = clock();
  827.  
  828. glutMainLoop();
  829.  
  830. graph1 = clock() - graph1; //Время существования 1 окна
  831.  
  832. //Создание окна для рисования частотного графика X[k]
  833. glutInit(&argc, argv);
  834. glutInitDisplayMode(GLUT_DOUBLE);
  835. glutInitWindowPosition(0, 0);
  836. glutInitWindowSize(w, h);
  837. glutCreateWindow("Графики массивов");
  838.  
  839. glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,
  840. GLUT_ACTION_GLUTMAINLOOP_RETURNS);
  841.  
  842. glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  843.  
  844. glutReshapeFunc(reshape);
  845.  
  846. glutDisplayFunc(Graphics_Creation2); //Подпрограмма, рисующая график массива H[u]
  847.  
  848. graph2 = clock();
  849.  
  850. glutMainLoop();
  851.  
  852. graph2 = clock() - graph2; //Время существования 2 окна
  853.  
  854. glutInit(&argc, argv);
  855. glutInitDisplayMode(GLUT_DOUBLE);
  856. glutInitWindowPosition(0, 0);
  857. glutInitWindowSize(w, h);
  858. glutCreateWindow("Графики массивов");
  859.  
  860. glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,
  861. GLUT_ACTION_GLUTMAINLOOP_RETURNS);
  862.  
  863. glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  864.  
  865. glutReshapeFunc(reshape);
  866.  
  867. glutDisplayFunc(Graphics_Creation3); //Подпрограмма, рисующая график массива H[u]
  868.  
  869. //graph2 = clock();
  870.  
  871. glutMainLoop();
  872.  
  873. //graph2 = clock() - graph2; //Время существования 2 окна
  874. //cin.ignore();
  875.  
  876.  
  877. delete[] X;//Очистка памяти от динамических массивов (эта и дву след. строки)
  878.  
  879. //cout << "Время выполнения алгоритма: " << clock() - graph2 - graph1 - start << endl;
  880.  
  881. }
  882.  
  883. else if (key == "2")
  884. {
  885. start = clock();
  886.  
  887. flag = 0; //Флаг для проверки правильности ввода
  888. k = 0;
  889. N1 = "";
  890.  
  891. in.open("C:\\Kursovaya\\KursovayaInput.txt"); //Открытие файла
  892. if (!in.is_open()) //Проверка, открылся файл или нет
  893. {
  894. cout << "Файл открыть не удалось. Пожалуйста, проверьте, правильно ли введено имя файла и его наличие.\nИмя файла по умолчанию - C:\\test\\KursovayaInput.txt" << endl;
  895. cin.ignore();
  896. continue;
  897. }
  898. if (in.eof())
  899. {
  900. cout << "Файл пустой. Пожалуйста, заполните его.\nАдрес файла: C:\\Kursovaya\\KursovayaInput.txt\n";
  901. in.close();
  902. cin.ignore();
  903. continue;
  904. }
  905.  
  906. getline(in, x); //Чтение строки из файла
  907. if (x.find(" ") < x.find("\t") || x.find("\t") == -1) //Берем все символы до первого пробельного символа
  908. {
  909. N1.insert(0, x, 0, x.find(" "));
  910. }
  911. else
  912. {
  913. N1.insert(0, x, 0, x.find("\t"));
  914. }
  915. size_t number1 = N1.find_first_not_of("0123456789");
  916. if (number1 != std::string::npos) //Если найдено что-то помимо цифр
  917. {
  918. cout << "Не удалось создать массив, так как первая лексема в файле - не число целого типа. Возврат в последнее меню.\n" << endl;
  919. in.close();
  920. cin.ignore();
  921. break;
  922. }
  923. N = stoi(N1.c_str()); //Получения количества элементов массива
  924.  
  925. X = new double[N]; //Создание динамических массивов (эта и две след. строки)
  926.  
  927. if (!X) //Проверка, выделилась ли память
  928. {
  929. cout << "Не удалось выделить память под массивы." << endl;
  930. continue;
  931. }
  932.  
  933. x.erase(0, N1.length()); //Удаляем в строке число - количество элементов массива
  934. while ((x.find("\t") == 0 || x.find(" ") == 0) && (x.find("\t") != -1 || x.find(" ") != -1)) //Двигаемся в строке до первого непробельного символа при его наличии
  935. {
  936. x.erase(0, 1);
  937. }
  938.  
  939. k = 0;
  940. if (N > 0) //Если количество элементов массива больше 0
  941. {
  942. do
  943. {
  944. while (1)
  945. {
  946. temps = "";
  947. i = 0;
  948.  
  949. while ((x.find(' ') != 0) && (x.find('\t') != 0) && (x.length() != 0)) //Получения из строки числа
  950. {
  951. temps.insert(i, x, 0, 1);
  952. i++;
  953. x.erase(0, 1);
  954. }
  955.  
  956. From_String_To_Double(&flag, temps, &k, X, &N); //Вызов функции, создающей элемент массива X[k] на основе строки
  957.  
  958. while ((x.find('\t') == 0 || x.find(' ') == 0) && (x.find("\t") != -1 || x.find(" ") != -1))
  959. {
  960. x.erase(0, 1);
  961. }
  962.  
  963. if (x.length() == 0 || k == N) //Выход из цикла анализа строки, если дошли до конца строки
  964. {
  965. break;
  966. }
  967.  
  968. }
  969. if (flag == 1 || k == N) //Если в файле не только числа или массив заполнен
  970. {
  971. break;
  972. }
  973. } while (getline(in, x)); //Цикл будт продолжаться, пока строки удачно считываются
  974.  
  975. if (in.bad()) //Если не удалось считать строку из-за ошибки
  976. {
  977. cout << "Произошла ошибка чтения файла." << endl;
  978. in.close();
  979. continue;
  980. }
  981.  
  982. if ((k < N)) //Если в файле оказалось чисел больше или меньше заявленного
  983. {
  984. cout << "В файле количество элементов, который нужно записать в массив X, меньше заявленного количества элементов.\n";
  985. in.close(); //Закрытие файла ввода
  986. continue;
  987. }
  988. }
  989.  
  990. in.close(); //Закрытие файла ввода
  991.  
  992. Printing_Arrays_into_Files(X, &N); //Вывод массивов в файл
  993.  
  994. w = 1900;
  995. h = 1000; //Создание окна размером 1900x1000
  996.  
  997. //Создание окна для рисования графиков
  998. glutInit(&argc, argv);
  999. glutInitDisplayMode(GLUT_DOUBLE);
  1000. glutInitWindowPosition(0, 0);
  1001. glutInitWindowSize(w, h);
  1002. glutCreateWindow("Графики массивов");
  1003.  
  1004. glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,
  1005. GLUT_ACTION_GLUTMAINLOOP_RETURNS);
  1006.  
  1007. glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  1008.  
  1009. glutReshapeFunc(reshape);
  1010.  
  1011. glutDisplayFunc(Graphics_Creation1); //Подпрограмма, рисующая графики массивов X[k] и X(обратное)[k]
  1012.  
  1013. graph1 = clock();
  1014.  
  1015. glutMainLoop();
  1016.  
  1017. graph1 = clock() - graph1; //Время существования 1 окна
  1018.  
  1019. //Создание окна для рисования частотного графика H[u]
  1020. glutInit(&argc, argv);
  1021. glutInitDisplayMode(GLUT_DOUBLE);
  1022. glutInitWindowPosition(0, 0);
  1023. glutInitWindowSize(w, h);
  1024. glutCreateWindow("Графики массивов");
  1025.  
  1026. glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,
  1027. GLUT_ACTION_GLUTMAINLOOP_RETURNS);
  1028.  
  1029. glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  1030.  
  1031. glutReshapeFunc(reshape);
  1032.  
  1033. glutDisplayFunc(Graphics_Creation2); //Подпрограмма, рисующая график массива H[u]
  1034.  
  1035. graph2 = clock();
  1036.  
  1037. glutMainLoop();
  1038.  
  1039. graph2 = clock() - graph2;
  1040.  
  1041. glutInit(&argc, argv);
  1042. glutInitDisplayMode(GLUT_DOUBLE);
  1043. glutInitWindowPosition(0, 0);
  1044. glutInitWindowSize(w, h);
  1045. glutCreateWindow("Графики массивов");
  1046.  
  1047. glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,
  1048. GLUT_ACTION_GLUTMAINLOOP_RETURNS);
  1049.  
  1050. glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  1051.  
  1052. glutReshapeFunc(reshape);
  1053.  
  1054. glutDisplayFunc(Graphics_Creation3); //Подпрограмма, рисующая график массива H[u]
  1055.  
  1056. //graph2 = clock();
  1057.  
  1058. glutMainLoop();
  1059.  
  1060. //cin.ignore(); - нужна только если размеры окна вводятся с клавиатуры
  1061.  
  1062. delete[] X;//Очистка памяти от динамических массивов (эта и две след. строки)
  1063.  
  1064. //cout << "Время выполнения алгоритма: " << clock() - graph2 - graph1 - start << endl;
  1065. }
  1066.  
  1067. else if (key == "0")
  1068. {
  1069. cout << "Завершение работы программы." << endl;
  1070. return 0;
  1071. }
  1072.  
  1073. else
  1074. {
  1075. cout << "Такой команды не существует в данной программе. Возврат в меню." << endl;
  1076. }
  1077. }
  1078. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!