API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 7th, 2019
131
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.61 KB | None | 0 0
raw download clone embed print report
  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdlib.h>
  3. #include <math.h>
  4. #include <stdio.h>
  5. #include <locale.h>
  6.  
  7. int odczyt_pliku(struct obraz* hp1);
  8. int zapis_pliku(struct obraz hp1);
  9. void zapis_histogram(int* ile, struct obraz hp1);
  10. void zwalnianie_pamieci(struct obraz* hp1);
  11. void zwalnianie_blad(struct obraz* hp1, int ile);
  12. int obrot(struct obraz* hp1);
  13. void histogram(struct obraz* hp1, int* ile);
  14. void negatyw(struct obraz* hp1);
  15. void pieprz_sol(struct obraz* hp1);
  16. int filtr(struct obraz* hp1);
  17. void progowanie(struct obraz* hp1);
  18. struct obraz kopia_zapasowa(struct obraz* hp1);
  19.  
  20. struct obraz
  21. {
  22. char* nazwa_pliku;
  23. char* standard;
  24. int szerokosc;
  25. int wysokosc;
  26. int zakres;
  27. int** piksele; //tablica na piksele
  28.  
  29.  
  30. };
  31.  
  32.  
  33. int main()
  34. {
  35. int x;
  36. int k = 0;
  37. int* ile;
  38. int wybor = 0;//tablica była
  39. int wybor1 = 0;
  40. struct obraz* hp1;
  41. struct obraz kopia_robocza;
  42. hp1 = (struct obraz*)malloc(1 * sizeof(struct obraz));
  43.  
  44. srand(time(NULL));
  45.  
  46. do
  47. {
  48. puts("Menu");
  49. puts("1.Odczyt");
  50. puts("2.Wyjscie");
  51. wybor = getch();
  52. system("cls");
  53. switch (wybor)
  54. {
  55. case ('1'):
  56.  
  57. x = odczyt_pliku(hp1);// odczyt z pliku
  58. if (x == 0)
  59. break;
  60. if (x == 1)//ogarnac czyszczenie pamieci
  61. {
  62. kopia_robocza = kopia_zapasowa(hp1);
  63. do {
  64. puts("Mozliwe operacje na odczytanym obrazie:");
  65. puts("1.Obrot");
  66. puts("2.Progowanie");
  67. puts("3.Negatyw");
  68. puts("4.Pieprz i sol");
  69. puts("5.Filtr");
  70. puts("6.Zapis");
  71. puts("7.Cofnij");
  72. wybor1 = getch();
  73. //system("cls");
  74. switch (wybor1)
  75. {
  76.  
  77. case ('1'):
  78. puts("Podaj wielokrotnosc kata 90 stopni:");
  79. k = getch();
  80. for (int i = 0; i < k - 48; i++)
  81. {
  82. obrot(&kopia_robocza);
  83. }
  84.  
  85. puts("Wykonano obrot");
  86. break;
  87.  
  88. case ('2'):
  89.  
  90. //ile = (int*)calloc(kopia_robocza.zakres+1 , sizeof(int));
  91. //histogram(&kopia_robocza, ile);
  92. //zapis_histogram(ile, *hp1);
  93. progowanie(&kopia_robocza);
  94. puts("wykonano progowanie");
  95. break;
  96. case ('3'):
  97.  
  98. negatyw(&kopia_robocza);
  99. puts("wykonano negatyw");
  100. break;
  101.  
  102. case ('4'):
  103. pieprz_sol(&kopia_robocza);
  104. puts("Przyprawy");
  105. break;
  106.  
  107. case ('5'):
  108. filtr(&kopia_robocza);
  109. puts("przefiltrowano");
  110. break;
  111.  
  112. case('6'):
  113.  
  114. zapis_pliku(kopia_robocza);//zapis musi byc oddzielna funkcja, dodac petle do
  115. break;
  116.  
  117.  
  118. default:
  119.  
  120. break;
  121.  
  122. }
  123. system("PAUSE");
  124. system("cls");
  125.  
  126. } while (wybor1 != '7');
  127. }
  128. else
  129. {
  130. printf("Problem z alokacja %d wiersza, zwalniam pamiec\n", x);
  131. zwalnianie_blad(hp1, x);
  132. exit(0);
  133. }
  134. break;
  135.  
  136. case ('2'):
  137. exit(0);
  138. break;
  139.  
  140. default:
  141. break;
  142. }
  143.  
  144. } while (wybor != '2');
  145. return 0;
  146.  
  147.  
  148. }
  149.  
  150. int odczyt_pliku(struct obraz* hp1)
  151. {
  152. FILE* plik;
  153. char komentarze;
  154. hp1->nazwa_pliku = (char*)malloc(100 * sizeof(char));//alokacja tablicy z nazwa
  155.  
  156. printf("Podaj nazwe pliku:\n");
  157. scanf("%s", hp1->nazwa_pliku);//wczytanie nazyw obrazu
  158.  
  159. plik = fopen(hp1->nazwa_pliku, "r");//otwarcie pliku o podanej nazwie
  160. if (plik == NULL)//czy plik sie otworzyl
  161. {
  162. perror("Error");//komunikat dlaczego blad
  163. return 0;
  164. }
  165. else
  166. puts("Znaleziono plik");
  167.  
  168. fscanf(plik, "%c", &komentarze);
  169. while (komentarze == '#')//szukanie komentarzy
  170. {
  171. while (komentarze != '\n')//dopoki nie jest nowa linia
  172. {
  173. fscanf(plik, "%c", &komentarze);
  174.  
  175. }
  176. fscanf(plik, "%c", &komentarze);//przeskok do nowej lini
  177.  
  178. }
  179.  
  180. fseek(plik, -1, SEEK_CUR); //przesuniecie znacznika pliku o jeden w tył
  181. fscanf(plik, "%s\n", &hp1->standard);//musi być na adres :)(hp1->wysokosc) * sizeof&(hp1->piksele)
  182.  
  183. fscanf(plik, "%c", &komentarze);
  184. while (komentarze == '#')
  185. {
  186. while (komentarze != '\n')
  187. {
  188. fscanf(plik, "%c", &komentarze);
  189.  
  190. }
  191. fscanf(plik, "%c", &komentarze);
  192.  
  193. }
  194.  
  195. fseek(plik, -1, SEEK_CUR);
  196. fscanf(plik, "%d", &hp1->szerokosc);
  197.  
  198. fscanf(plik, "%c", &komentarze);
  199. while (komentarze == '#')
  200. {
  201. while (komentarze != '\n')
  202. {
  203. fscanf(plik, "%c", &komentarze);
  204.  
  205. }
  206. fscanf(plik, "%c", &komentarze);
  207.  
  208. }
  209.  
  210. fseek(plik, -1, SEEK_CUR);
  211. fscanf(plik, "%d", &hp1->wysokosc);
  212.  
  213. fscanf(plik, "%c", &komentarze);
  214. while (komentarze == '#')
  215. {
  216. while (komentarze != '\n')
  217. {
  218. fscanf(plik, "%c", &komentarze);
  219.  
  220. }
  221. fscanf(plik, "%c", &komentarze);
  222.  
  223. }
  224. fseek(plik, -1, SEEK_CUR);
  225. fscanf(plik, "%d", &hp1->zakres);
  226.  
  227. //deklaracja pamieci na tablice 2 wymiary
  228.  
  229. hp1->piksele = (int**)malloc(hp1->wysokosc * sizeof(int));//rzutowanie(int) pamieci po zwrocie malloca
  230. if (hp1->piksele != NULL)
  231. {
  232. for (int i = 0; i < (hp1->wysokosc); i++)
  233. {
  234.  
  235. hp1->piksele[i] = (int*)malloc(hp1->szerokosc * sizeof(int));//alokacja tablicy na odpowiednin rozmiar
  236. if (hp1->piksele[i] == NULL)
  237. {
  238. return i;
  239. }
  240.  
  241. }
  242.  
  243. for (int i = 0; i < hp1->wysokosc; i++)//wpisanie wartosci z pliku
  244. {
  245. for (int j = 0; j < hp1->szerokosc; j++)
  246. {
  247. fscanf(plik, "%c", &komentarze);//czyta znak
  248.  
  249.  
  250. while (komentarze == '#')//jezeli komentarz
  251. {
  252. while (komentarze != '\n')//dopóki nie \n
  253. {
  254. fscanf(plik, "%c", &komentarze);
  255.  
  256. }
  257. fscanf(plik, "%c", &komentarze);
  258.  
  259. }
  260. fseek(plik, -1, SEEK_CUR);
  261.  
  262. fscanf(plik, "%d", &hp1->piksele[i][j]);
  263.  
  264.  
  265. }
  266.  
  267. }
  268.  
  269.  
  270. printf("standard:%s\n", &hp1->standard);
  271. }
  272. else
  273. {
  274. puts("problem z alokacja tablicy");
  275. fclose(plik);
  276. return 0;
  277. }
  278.  
  279.  
  280.  
  281. fclose(plik);
  282. return 1;
  283.  
  284.  
  285. }
  286.  
  287. int zapis_pliku(struct obraz hp1)
  288. {
  289. FILE* plik;
  290. char x = 0;
  291. hp1.nazwa_pliku = (char*)malloc(100 * sizeof(char));//alokacja tablicy z nazwa
  292. puts("Podaj nazwe pliku:");
  293. scanf("%s", hp1.nazwa_pliku);//wczytanie nazyw obrazu
  294. plik = fopen(hp1.nazwa_pliku, "w");//otwarcie pliku o podanej nazwie
  295. if (plik == NULL)//czy plik sie utworzyl
  296. {
  297. perror("Tablice.csv");//komunikat dlaczego blad
  298. return 0;
  299. }
  300.  
  301.  
  302. fprintf(plik, "%s\n", &hp1.standard);
  303. fprintf(plik, "%d %d\n", hp1.szerokosc, hp1.wysokosc);
  304. fprintf(plik, "%d\n", hp1.zakres);
  305.  
  306. for (int i = 0; i < hp1.wysokosc; i++)//wpisanie wartosci z pliku
  307. {
  308. for (int j = 0; j < hp1.szerokosc; j++)
  309. {
  310.  
  311. fprintf(plik, "%d ", hp1.piksele[i][j]);
  312.  
  313. }
  314. fprintf(plik, "\n");
  315. }
  316. fclose(plik);
  317. puts("Utworzono plik");
  318.  
  319. return 1;
  320. }
  321.  
  322. void zwalnianie_pamieci(struct obraz* hp1)
  323. {
  324.  
  325. for (int i = 0; i < (hp1->wysokosc); i++)
  326. {
  327. free((hp1->piksele[i]));
  328. }
  329. free((hp1->piksele));
  330.  
  331.  
  332. }
  333.  
  334. void zwalnianie_blad(struct obraz* hp1, int ile)
  335. {
  336. for (int i = 0; i < ile; i++)
  337. {
  338. free((hp1->piksele[i]));
  339. }
  340. free((hp1->piksele));
  341.  
  342. }
  343.  
  344. struct obraz kopia_zapasowa(struct obraz* hp1)//kopia robocza aby mozna ten sam obraz przekształcać
  345. {
  346. int i, j;
  347. struct obraz kopia_robocza;
  348. kopia_robocza.zakres = hp1->zakres;
  349. kopia_robocza.szerokosc = hp1->szerokosc;
  350. kopia_robocza.wysokosc = hp1->wysokosc;
  351. kopia_robocza.standard = hp1->standard;
  352. kopia_robocza.nazwa_pliku = hp1->nazwa_pliku;
  353. kopia_robocza.piksele = (int**)malloc(hp1->wysokosc * sizeof(int));
  354. if (kopia_robocza.piksele != NULL)
  355. {
  356. for (i = 0; i < hp1->wysokosc; i++)
  357. {
  358. kopia_robocza.piksele[i] = (int*)malloc(hp1->szerokosc * sizeof(int));
  359. if (kopia_robocza.piksele == NULL)
  360. printf("BLAD!!!");
  361. }
  362. }
  363. else printf("BLAD!!!");
  364. for (i = 0; i < hp1->wysokosc; i++)
  365. {
  366. for (j = 0; j < hp1->szerokosc; j++)
  367. {
  368. kopia_robocza.piksele[i][j] = hp1->piksele[i][j];
  369.  
  370. }
  371. }
  372. return kopia_robocza;
  373.  
  374. }
  375.  
  376. int obrot(struct obraz* hp1)
  377. {
  378. int i, j;
  379. struct obraz kopia_robocza;
  380. kopia_robocza = kopia_zapasowa(hp1);//co to robi?
  381. for (i = 0; i < hp1->wysokosc; i++)
  382. {
  383. free(hp1->piksele[i]);
  384. }
  385. free(hp1->piksele);
  386.  
  387. hp1->szerokosc = kopia_robocza.wysokosc;
  388. hp1->wysokosc = kopia_robocza.szerokosc;
  389. hp1->piksele = (int**)malloc(hp1->wysokosc * sizeof(int));
  390. if (hp1->piksele != NULL)
  391. {
  392. for (i = 0; i < hp1->wysokosc; i++)
  393. {
  394. hp1->piksele[i] = (int*)malloc(hp1->szerokosc * sizeof(int));
  395. if (hp1->piksele == NULL)
  396. return 1;
  397. }
  398. }
  399. for (i = 0; i < hp1->wysokosc; i++)
  400. {
  401. for (j = 0; j < hp1->szerokosc; j++)
  402. {
  403. hp1->piksele[i][j] = kopia_robocza.piksele[j][kopia_robocza.szerokosc - i - 1];
  404. }
  405. }
  406. for (i = 0; i < kopia_robocza.wysokosc; i++)
  407. {
  408. free(kopia_robocza.piksele[i]);
  409. }
  410. free(kopia_robocza.piksele);
  411. return 0;
  412.  
  413.  
  414.  
  415.  
  416. }
  417.  
  418. void histogram(struct obraz* hp1, int* ile)
  419. {
  420. int i, j;
  421. int max = 0;
  422.  
  423. for (i = 0; i < hp1->wysokosc; i++)
  424. {
  425. for (j = 0; j < hp1->szerokosc; j++)
  426. {
  427.  
  428. //ile[hp1->piksele[i][j]]++;//sumowanie
  429. ile[i]=ile[i] + hp1->piksele[i][j];
  430.  
  431. }
  432. }
  433. for (i = 0; i < hp1->zakres; i++)
  434. {
  435. if (ile[i] > max)
  436. max = ile[i];
  437. }
  438. for (i = 0; i < hp1->zakres; i++)
  439. {
  440. ile[i] = ile[i] * hp1->wysokosc / max;
  441. }
  442.  
  443. }
  444. void zapis_histogram(int *ile, struct obraz hp1)
  445. {
  446.  
  447. FILE* plik;
  448.  
  449. int i;
  450. plik = fopen("tablice.csv", "w");
  451.  
  452. if (plik == NULL)//czy plik sie otworzyl
  453. {
  454. perror("Tablice.csv");//komunikat dlaczego blad
  455.  
  456. }
  457.  
  458. for (i = 0; i < hp1.wysokosc; i++)
  459. {
  460. fprintf(plik, "%d\n", *ile++);
  461.  
  462. }
  463.  
  464. fclose(plik);
  465.  
  466.  
  467. }
  468.  
  469. void negatyw(struct obraz* hp1)
  470. {
  471. int i, j;
  472. for (i = 0; i < hp1->wysokosc; i++)
  473. {
  474. for (j = 0; j < hp1->szerokosc; j++)
  475. {
  476. hp1->piksele[i][j] = hp1->zakres - hp1->piksele[i][j];
  477. }
  478. }
  479.  
  480. }
  481. void pieprz_sol(struct obraz* hp1)
  482. {
  483. int i, j;
  484. for (i = 0; i < hp1->wysokosc; i++)
  485. {
  486. for (j = 0; j < hp1->szerokosc; j++)
  487. {
  488. if (rand() % 11 < 1)
  489. {
  490. if (rand() % 2) hp1->piksele[i][j] = 0;
  491. else
  492. {
  493. hp1->piksele[i][j] = hp1->zakres;
  494. }
  495. }
  496.  
  497. }
  498. }
  499. }
  500. int filtr(struct obraz* hp1)
  501. {
  502. int gauss[3][3] = {
  503. {1,2,1},
  504. {2,4,2},
  505. {1,2,1}
  506. };
  507.  
  508. int i, j, k, l;
  509. int okno = 0;
  510. int suma = 16;
  511. struct obraz kopia_robocza;
  512. kopia_robocza = kopia_zapasowa(hp1);
  513. for (i = 0; i < hp1->wysokosc - 2; i++)
  514. {
  515. for (j = 0; j < hp1->szerokosc - 2; j++)
  516. {
  517. for (k = 0; k < 3; k++)
  518. {
  519. for (l = 0; l < 3; l++)
  520. {
  521. okno = okno + kopia_robocza.piksele[i + k][j + l] * gauss[k][l];
  522. }
  523. }
  524. hp1->piksele[i + 1][j + 1] = okno / suma;
  525. okno = 0;
  526. }
  527. }
  528. for (i = 0; i < kopia_robocza.wysokosc; i++)
  529. {
  530. free(kopia_robocza.piksele[i]);
  531. }
  532. free(kopia_robocza.piksele);
  533. return 0;
  534.  
  535.  
  536.  
  537.  
  538. }
  539. void progowanie(struct obraz* hp1)
  540. {
  541. int i, j, prog;
  542. puts("podaj wartosc progu");
  543. scanf("%d", &prog);
  544. for (i = 0; i < hp1->wysokosc; i++)
  545. {
  546. for (j = 0; j < hp1->szerokosc; j++)
  547. {
  548. if (hp1->piksele[i][j] < prog)
  549. hp1->piksele[i][j] = 0;
  550. else
  551. hp1->piksele[i][j] = hp1->zakres;
  552. }
  553. }
  554.  
  555. }
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!