#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <locale.h>
#include <stdlib.h>
#include "Header.h"
#define _CRT_SECURE_NO_WARNINGS

enum { poczatek = 0, koniec, amplituda, przes_OX, przes_OY, ilosc, okres, skok };
#define M_PI 3.14159265358979323846



double Fn_Sinus(double *tab_Wspol, double d_czas);
double Fn_Trojkat(double *tab_Wspol, double d_czas);
double Fn_Pila(double *tab_Wspol, double d_czas);
void Fn_Przypisz(const char *tekst, const char *format, void *zmienna);
void Fn_Pobierz_Dane(double *tab_Wspol, double **tab_Szum);
void Fn_Zmienna_Przypisz(const char *format, void *zmienna);
int Fn_Wypelnij(double *tab_Wspol, double **tab_Sygnal, double **tab_Argumenty, int *syg);
void Fn_Menu(void);
int Fn_Szum(double **tab_Szum, double *tab_Wspol, double *tab_Sygnal);
int Fn_Wyswietl(double *tab_Szum, double *tab_Sygnal, double *tab_Argumenty, double *tab_Wspol);
int Fn_Filtr(double *tab_Szum, double **tab_Filtrowana, double *tab_Argumenty, double *tab_Wspol);
double Fn_Babelkowe(double *tab_Pomocnicza, int okno);
double Fn_Mediana(double *tab_Szum, int okno, int poczatek, int koniec);
double Fn_Srednia(double *tab_Szum, int okno, int poczatek, int koniec);
double Fn_Wczytaj(double **tab_Sygnal, double **tab_Szum, double **tab_Filtrowana, double **tab_Argumenty, double *tab_Wspol);
char* Fn_Pobierz_Nazwe_Pliku(void);

int main()
{
	double tab_Wspol[8]; //wspolczynniki: poczatek, koniec, amplituda, przesuniecie wzg osi X, przesuniecie wzg osi Y, ilosc probek, okres, skok
	char tab_Nazwa[32] = "";
	int opcja = 0;//zmienna decyzji opcji z menu
	int syg = 0; //flaga do filtru medianowego, ktora funkcja sygnalu zostala uzyta
	double *tab_Sygnal = NULL;
	double *tab_Argumenty = NULL;
	double *tab_Szum = NULL;
	double *tab_Filtrowana = NULL;
	setlocale(LC_ALL, "polish_poland");
	
	while (1)
	{
		Fn_Menu();
		while (!scanf("%d", &opcja))
		{
			while (getchar() != '\n');
			Fn_Menu();
		}
		system("cls");
		switch (opcja)
		{
		case 0:
			return 0;
		case 1:
			Fn_Pobierz_Dane(tab_Wspol, &tab_Szum);
			Fn_Wypelnij(tab_Wspol, &tab_Sygnal, &tab_Argumenty, &syg);
			break;
		case 2:
			Fn_Szum(&tab_Szum, tab_Wspol, tab_Sygnal);
			break;
		case 3:
			Fn_Wyswietl(tab_Szum, tab_Sygnal, tab_Argumenty, tab_Wspol);
			break;
		case 4:
			break;
		case 5:
			Fn_Wczytaj(&tab_Sygnal, &tab_Szum, &tab_Filtrowana, &tab_Argumenty, tab_Wspol);
			break;
		case 6:
			Fn_Filtr(tab_Szum, &tab_Filtrowana, tab_Argumenty, tab_Wspol);
			break;
		case 7:
			break;
		default:
			printf("Nie ma takiej opcji w menu. Sprobuj ponownie.\n");
			getchar();
			while (getchar() != '\n');
		}

	};
}


double Fn_Sinus(double *tab_Wspol, double d_czas) //czas jako zmienna, ktora jest ustalana przez petle 
{
	double wynik; //wartosc sygnalu sinusoidalnego dla danego czasu
	double A = tab_Wspol[amplituda];
	double C = tab_Wspol[przes_OX];
	double D = tab_Wspol[przes_OY];
	double T = tab_Wspol[okres];

	wynik = A * sin((2 * M_PI / T)*d_czas - 2 * M_PI *(C / 100)) + D;
	
	return wynik;
}


double Fn_Trojkat(double *tab_Wspol, double d_czas)
{
	double wynik; //wartosc sygnalu trojkatnego dla danego czasu
	double A = tab_Wspol[amplituda];
	double C = tab_Wspol[przes_OX];
	double D = tab_Wspol[przes_OY];
	double T = tab_Wspol[okres];

	d_czas -= C / 100 * T; //czas z uwzglednieniem przesuniecia wzg OX
	wynik = (2 * A / T)*(d_czas - floor(d_czas / T)*T); //obliczenie punktu odniesienia do wyliczenia sygnalu trojkatnego

	if (wynik < A)
	{
		return wynik + D;
	}
	else
	{
		return 2*A - wynik + D;
	}
}


double Fn_Pila(double *tab_Wspol, double d_czas)
{
	double wynik; //wartosc sygnalu trojkatnego dla danego czasu
	double A = tab_Wspol[amplituda];
	double C = tab_Wspol[przes_OX];
	double D = tab_Wspol[przes_OY];
	double T = tab_Wspol[okres];

	d_czas -= C/100 * T; //czas z uwzglednieniem przesuniecia wzg OX
	wynik = (d_czas - floor(d_czas / T)*T); //obliczenie punktu odniesienia do wyliczenia sygnalu trojkatnego

	if (wynik < 0.95*T)
	{
		return A/(0.95*T) * wynik + D;
	}
	else
	{
		return A - A/(0.05*T) * (wynik - 0.95*T)+ D;
	}
}


void Fn_Przypisz(const char *tekst, const char *format, void *zmienna)
{
	printf("%s", tekst);
	
	while (!scanf(format, zmienna))
	{
		system("cls");
		printf("Podales cos niejasnego. Powtorz.\n");
		while (getchar() != '\n');
		printf("%s", tekst);
	}
	while (getchar() != '\n');
}


void Fn_Zmienna_Przypisz(const char *format, void *zmienna)
{
	while (!scanf(format, zmienna))
	{
		printf("Podales cos niejasnego. Powtorz: ");
		while (getchar() != '\n');
	}
	while (getchar() != '\n');
}


void Fn_Pobierz_Dane(double *tab_Wspol, double **tab_Szum) //wspolczynniki: poczatek, koniec, amplituda, przesuniecie wzg osi X, przesuniecie wzg osi Y, ilosc probek, okres, skok
{
	int wybor = 0;
	double ptr = 0;
	free(*tab_Szum);
	*tab_Szum = NULL;
	Fn_Przypisz("1) Podaj poczatek dziedziny sygnalu: ", "%lf", (tab_Wspol + poczatek));
	system("cls");
	Fn_Przypisz("2) Podaj koniec dziedziny sygnalu: ", "%lf", (tab_Wspol + koniec));
	system("cls");
	do
	{
		
		if (tab_Wspol[poczatek] > tab_Wspol[koniec])
		{
			do
			{
				printf("Podales poczatek dziedziny o wiekszej wartosci, niz koniec. Wybierz co chcesz zrobic: \n");
				printf("1) Zamienic liczby miejscami.\n");
				printf("2) Zmienic wartosci poczatku i konca przedzialu.\n");
				printf("Twoj wybor: ");
				Fn_Zmienna_Przypisz("%d", &wybor);
				system("cls");
				switch (wybor)
				{
				case 1:
					ptr = tab_Wspol[koniec];
					tab_Wspol[koniec] = tab_Wspol[poczatek];
					tab_Wspol[poczatek] = ptr;
					break;
				case 2:
					Fn_Przypisz("Podaj poczatek dziedziny sygnalu: ", "%lf", (tab_Wspol + poczatek));
					system("cls");
					Fn_Przypisz("Podaj koniec dziedziny sygnalu: ", "%lf", (tab_Wspol + koniec));
					system("cls");
				}
			} while (tab_Wspol[poczatek] > tab_Wspol[koniec]);
		}
		if (tab_Wspol[poczatek] == tab_Wspol[koniec])
		{
			do
			{
				printf("Twoj przedzial jest jednym punktem i wynosi %0.2f. \n", tab_Wspol[poczatek]);
				printf("1) To bylo zamierzone. Wiec zdaje sobie sprawe ze ilosc probek automatycznie wynosi 1.\n");
				printf("2) Chce zmienic przedzialy.\n");
				printf("Wpisz odpowiedz: ");
				Fn_Zmienna_Przypisz("%d", &wybor);
				system("cls");
				switch (wybor)
				{
				case 1:
					tab_Wspol[skok] = 0;
					tab_Wspol[ilosc] = 1;
					break;
				case 2:
					Fn_Przypisz("Podaj poczatek dziedziny sygnalu: ", "%lf", (tab_Wspol + poczatek));
					system("cls");
					Fn_Przypisz("Podaj koniec dziedziny sygnalu: ", "%lf", (tab_Wspol + koniec));
					system("cls");
					break;
				default:
					printf("Nie ma takiej opcji. Kliknij enter aby wrocic do menu wpisanie przedzialu.\n");
					while (getchar() != '\n');
					system("cls");
				}
			} while ((wybor>2 || wybor<0) || (tab_Wspol[poczatek] == tab_Wspol[koniec] && wybor == 2));
		}
	} while(tab_Wspol[poczatek] > tab_Wspol[koniec]);
	Fn_Przypisz("3) Podaj amplitude sygnalu: ", "%lf", (tab_Wspol + amplituda));
	system("cls");
	if (tab_Wspol[amplituda] == 0)
	{
		printf("Podales zerowa amplitude spowoduje to, ze twoj sygnal niezaszumiony bedzie staly. Co chcesz zrobic?: \n");
		printf("1) Zamienic wartosc amplitudy.\n");
		printf("2) Otrzymac stala wartosc sygnalu o amplitudzie A = 0.\n");
		printf("Twoj wybor: ");
		Fn_Zmienna_Przypisz("%d", &wybor);
		system("cls");
		if (wybor == 1)
		{
			do
			{
				Fn_Przypisz("Podaj amplitude sygnalu: ", "%lf", (tab_Wspol + amplituda));
				system("cls");
				if (tab_Wspol[amplituda] == 0)
				{
					printf("Podales zerowa amplitude spowoduje to, ze twoj sygnal niezaszumiony bedzie staly. Co chcesz zrobic?: \n");
					printf("1) Zamienic wartosc amplitudy.\n");
					printf("2) Otrzymac stala wartosc sygnalu o amplitudzie A = 0.\n");
					printf("Twoj wybor: ");
					Fn_Zmienna_Przypisz("%d", &wybor);
					system("cls");
					switch (wybor)
					{
					case 1:
						Fn_Przypisz("Podaj amplitude sygnalu: ", "%lf", (tab_Wspol + amplituda));
						system("cls");
						break;
					case 2:
						break;
					
					}
				}
			} while ((tab_Wspol[amplituda] == 0 && wybor == 1)|| (wybor>2 || wybor <0));
		}

	}
	Fn_Przypisz("4) Podaj przesuniecie sygnalu wzgledem osi OX w %% okresu: ", "%lf", (tab_Wspol + przes_OX));
	system("cls");
	do
	{
		if (tab_Wspol[przes_OX] < 0)
		{ 
			printf("Wartosc %% jest wartoscia dodatnia!\n");
			Fn_Przypisz("Podaj przesuniecie sygnalu wzgledem osi OX w %% okresu: ", "%lf", (tab_Wspol + przes_OX));
			system("cls");
		}
		if (tab_Wspol[przes_OX] > 100)
		{
			printf("Wartosc %% moze maksymalnie osiagac 100!\n");
			Fn_Przypisz("Podaj przesuniecie sygnalu wzgledem osi OX w %% okresu: ", "%lf", (tab_Wspol + przes_OX));
			system("cls");
		}
			
	} while (tab_Wspol[przes_OX] < 0 || tab_Wspol[przes_OX] > 100);

	Fn_Przypisz("5) Podaj przesuniecie sygnalu wzgledem osi OY: ", "%lf", (tab_Wspol + przes_OY));
	system("cls");
	if(tab_Wspol[ilosc]!=1)
	{ 
		Fn_Przypisz("6) Podaj ilosc probek: ", "%lf", (tab_Wspol + ilosc));
		system("cls");
		if (tab_Wspol[ilosc] == 0 || tab_Wspol[ilosc] < 0)
		{
			do
			{
				printf("Podales ilosc probek rowna 0 lub ujemna wartosc. Dam Ci szanse to zmienic.\n");
				Fn_Przypisz("Podaj ilosc probek: ", "%lf", (tab_Wspol + ilosc));
				system("cls");
			} while (tab_Wspol[ilosc] == 0 || tab_Wspol[ilosc] < 0);
		}
	}
	Fn_Przypisz("7) Podaj okres sygnalu: ", "%lf", (tab_Wspol + okres));
	system("cls");
	do
	{
		if (tab_Wspol[okres] == 0 || tab_Wspol[okres] < 0)
		{
			printf("Okres musi byc dodatni! \n");
			Fn_Przypisz("7) Podaj okres sygnalu: ", "%lf", (tab_Wspol + okres));
			system("cls");
			continue;
		}
		if (tab_Wspol[okres] < 0.000001)
		{

			printf("Okres jest typu double, podaj liczbe wieksza lub rowna 0.000001.\n");
			Fn_Przypisz("7) Podaj okres sygnalu: ", "%lf", (tab_Wspol + okres));
			system("cls");
			continue;
		}
	} while (tab_Wspol[okres] < 0.000001);
	
	if((tab_Wspol[koniec] - tab_Wspol[poczatek]) <= tab_Wspol[ilosc])
	{
		tab_Wspol[skok] = (tab_Wspol[koniec] - tab_Wspol[poczatek]) / (tab_Wspol[ilosc] - 1);
	}

	if ((tab_Wspol[koniec] - tab_Wspol[poczatek]) > tab_Wspol[ilosc])
	{
		tab_Wspol[skok] = (tab_Wspol[koniec] - tab_Wspol[poczatek]) / (tab_Wspol[ilosc] + 1);
		tab_Wspol[poczatek] = tab_Wspol[poczatek] + tab_Wspol[skok];
	}
}


int Fn_Wypelnij(double *tab_Wspol, double **tab_Sygnal, double **tab_Argumenty, int *syg) 
{
	int wybor = 0;
	double x = 0; //zmienna sluzaca jako odliczanie (czas)
	int i = 0; //zmienna pomocnicza do odliczania elementow tablicy
	free(*tab_Sygnal);
	free(*tab_Argumenty);
	*tab_Sygnal = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Sygnal));
	*tab_Argumenty = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Argumenty));
	if (*tab_Sygnal == NULL || *tab_Argumenty == NULL)
	{
		printf("Niestety nie udalo sie przydzielic pamieci.\n");
		if (*tab_Sygnal != NULL)
		{
			free(*tab_Sygnal); 
		}
		if (*tab_Argumenty == NULL)
		{
			free(*tab_Argumenty);
		}
		getchar();
		getchar();
		exit(0);
	}
	else
	{ 
		do
		{ 
			printf("Wybierz sygnal, ktory chcesz wygenerowac: \n");
			printf("1) Sinusoidalny\n");
			printf("2) Trojkatny\n");
			printf("3) Piloksztaltny\n");
			printf("0) Powrot do Menu\n");
			printf("Twoj wybor: ");
			Fn_Zmienna_Przypisz("%d", &wybor);
			system("cls");
			switch (wybor)
			{
			case 0:
				return 0;
			case 1:
				*syg = 1;
				for (i = 0, x = tab_Wspol[poczatek]; i < (int)tab_Wspol[ilosc]; i++, x += tab_Wspol[skok])
				{
					(*tab_Sygnal)[i] = Fn_Sinus(tab_Wspol, x);
					(*tab_Argumenty)[i] = x;
				}
				break;
			case 2:
				*syg = 2;
				for (i = 0, x = tab_Wspol[poczatek]; i < (int)tab_Wspol[ilosc]; i++, x += tab_Wspol[skok])
				{
					(*tab_Sygnal)[i] = Fn_Trojkat(tab_Wspol, x);
					(*tab_Argumenty)[i] = x;
				}
				break;
			case 3:
				*syg = 3;
				for (i = 0, x = tab_Wspol[poczatek]; i < (int)tab_Wspol[ilosc]; i++, x += tab_Wspol[skok])
				{
					(*tab_Sygnal)[i] = Fn_Pila(tab_Wspol, x);
					(*tab_Argumenty)[i] = x;
				}
				break;
			default:
				printf("Nie ma takiej opcji. Kliknij enter aby wrocic do menu generowania sygnalu.\n");
				while(getchar()!='\n');
				system("cls");
				*syg = 0;
			}
		} while (*syg == 0);
		
	}
}


void Fn_Menu(void)
{
	system("cls");
	printf("Prosze wybrac co chcialbys zrobic ... \n");
	printf("(1) Wprowadzic wspolczynniki i wygenerowac sygnal.\n");
	printf("(2) Wygenerowac szum.\n");
	printf("(3) Wyswietlic sygnal lub sygnal zaszumiony.\n");
	printf("(4) Zapisac dane do pliku.\n");
	printf("(5) Odczytac dane z pliku.\n");
	printf("(6) Uzyc filtru sygnalu.\n");
	printf("(0) Wyjsc z programu\n");
	printf("Twoj wybor: ");
}


int Fn_Szum(double **tab_Szum, double *tab_Wspol, double *tab_Sygnal)
{
	int wybor = 0;
	int x = 0; //pomocnicza liczba do odliczania
	double ptr = 0; //pomocnicza liczba do podmiany danych
	double tab_Warunki[2]; // tablica przechowaujaca warunki zaszumienia
	free(*tab_Szum);
	*tab_Szum = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Szum));
	system("cls");
	if (*tab_Szum == NULL)
	{
		printf("Niestety nie udalo sie przydzielic pamieci.\n");
		getchar();
		getchar();
		exit(0);
	}
	do
	{
		if (tab_Sygnal == NULL)
		{
			printf("Zanim zaszumisz sygnal, musisz go najpierw wygenerowac.\n");
			getchar();
			while (getchar() != '\n');
			return 0;
		}
		printf("Jaki typ zaszumienia chcialbys wygenerowac?\n");
		printf("(1) Szum z okreslonego zakresu.\n");
		printf("(2) Szum ze stala wartoscia, generowany na podstawie prawdopodobienstwa.\n");
		printf("(0) Wrocic do menu.\n");
		printf("Twoj wybor: ");
		Fn_Zmienna_Przypisz("%d", &wybor);
		system("cls");
		switch (wybor)
		{
		case 0:
			return 0;
		case 1:
			Fn_Przypisz("Wpisz minimalna wartosc zaszumienia: ", "%lf", &tab_Warunki[0]);
			Fn_Przypisz("Wpisz maksymalna wartosc zaszumienia: ", "%lf", &tab_Warunki[1]);
			system("cls");
			if (tab_Warunki[0] > tab_Warunki[1])
			{
				do
				{
					printf("Podales poczatek przedzialu o wiekszej wartosci, niz koniec. Wybierz co chcesz zrobic: \n");
					printf("1) Zamienic liczby miejscami.\n");
					printf("2) Zmienic wartosci poczatku i konca przedzialu.\n");
					Fn_Zmienna_Przypisz("%d", &wybor);
					system("cls");
					switch (wybor)
					{
					case 1:
						ptr = tab_Wspol[koniec];
						tab_Wspol[koniec] = tab_Wspol[poczatek];
						tab_Wspol[poczatek] = ptr;
						break;
					case 2:
						Fn_Przypisz("Wpisz minimalna wartosc zaszumienia: ", "%lf", &tab_Warunki[0]);
						Fn_Przypisz("Wpisz maksymalna wartosc zaszumienia: ", "%lf", &tab_Warunki[1]);
						system("cls");
						break;
					default:
						printf("Nie ma takiej opcji. Kliknij klawisz enter.\n");
						getchar();
						while (getchar() != '\n');
						system("cls");
					}
				} while (tab_Warunki[0] > tab_Warunki[1]);
			}
			for (x = 0; x < tab_Wspol[ilosc]; x++) 
			{
				(*tab_Szum)[x] = tab_Sygnal[x] + tab_Warunki[0] + ((double)rand() / (double)RAND_MAX)*(tab_Warunki[1] - tab_Warunki[0]);
			}
			break;
		case 2:
			do
			{
				
				Fn_Przypisz("Wpisz prawdopodobienstwo wystapienia zaszumienia w %%: ", "%lf", &tab_Warunki[0]);
				system("cls");
				if (tab_Warunki[0] < 0 || tab_Warunki[0] > 100)
				{
					printf("Prawdopodobienstwo w procentach moze przyjmowac wartosci z zakresu <0;100>. \n");
					while (getchar() != '\n');
					system("cls");
				}
			} while (tab_Warunki[0] < 0 || tab_Warunki[0] > 100);
			system("cls");
			Fn_Przypisz("Wpisz stala wartosc zaszumienia: ", "%lf", &tab_Warunki[1]);
			for (x = 0; x < tab_Wspol[ilosc]; x++)
			{
				if ((double)rand() / (double)RAND_MAX <= tab_Warunki[0] / 100)
				{
					(*tab_Szum)[x] = tab_Sygnal[x] + tab_Warunki[1];
				}
				else
				{
					(*tab_Szum)[x] = tab_Sygnal[x];
				}
			}
			system("cls");
			break;
		default:
			printf("Nie ma takiej opcji. Kliknij dowolny przycisk aby wrocic do wyboru.\n");
			while (getchar() != '\n');
			system("cls");
		}
	} while (wybor > 2 || wybor < 0);

}


int Fn_Wyswietl(double *tab_Szum, double *tab_Sygnal, double *tab_Argumenty, double *tab_Wspol)
{
	int wybor = 0;
	int x = 0;
	do
	{
		if (tab_Sygnal == NULL)
		{
			printf("Zanim wyswietlisz sygnal musisz go najpierw wygenerowac.\n");
			getchar();
			while (getchar() != '\n');
			break;
		}
		system("cls");
		printf("Wybierz co chcesz wyswietlic...\n");
		printf("(1) Sygnal niezaszumiony.\n");
		printf("(2) Sygnal zaszumiony.\n");
		printf("(0) Wroc do menu. \n");
		printf("Twoj wybor: ");
		Fn_Zmienna_Przypisz("%d", &wybor);
		system("cls");
		switch (wybor)
		{
		case 0:
			return 0;
		case 1:
			for (x = 0; x < tab_Wspol[ilosc]; x++)
			{
				printf("Sygnal(%0.3lf) = %0.3lf\n", tab_Argumenty[x], tab_Sygnal[x]);
			}
			system("pause");
			break;
		case 2:
			if (tab_Szum == NULL)
			{
				printf("Muisz najpierw zaszumic sygnal aby go wyswietlic.\n");
				while (getchar() != '\n');
				break;
			}
			for (x = 0; x < tab_Wspol[ilosc]; x++)
			{
				printf("Szum(%0.3lf) = %0.3lf\n", tab_Argumenty[x], tab_Szum[x]);
			}
			system("pause");
			break;
		default:
			printf("Nie ma takiej opcji. Sprobuj ponownie.\n");
			while (getchar() != '\n');
		}
	} while ((wybor > 2 || wybor < 0)|| tab_Szum == NULL);
}
	

int Fn_Filtr(double *tab_Szum, double **tab_Filtrowana, double *tab_Argumenty, double *tab_Wspol)
{
	int okno = 0;
	int wybor = 0;
	int i = 0;
	do
	{
		if (tab_Szum == NULL)
		{
			printf("Zanim przefiltrujesz sygnal musisz go najpierw zaszumic.\n");
			getchar();
			while (getchar() != '\n');
			break;
		}
		free(*tab_Filtrowana);
		*tab_Filtrowana = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Filtrowana));
		system("cls");
		printf("Z jakiego filtru chcesz skorzystac...\n");
		printf("(1) Filtr medianowy.\n");
		printf("(2) Filtr sredniej ruchomej.\n");
		printf("(0) Wroc do menu. \n");
		printf("Twoj wybor: ");
		Fn_Zmienna_Przypisz("%d", &wybor);
		system("cls");
		if (wybor == 1 || wybor == 2)
		{
			printf("Okno filtra ma szerokosc 2n + 1\nPodaj n: ");
			do
			{
				if (okno > (tab_Wspol[ilosc] - 1) / 2 || okno < 0)
				{
					printf("Zle podana wartosc okna!\n");
				}
				Fn_Zmienna_Przypisz("%d", &okno);
				
				
			} while (okno > (tab_Wspol[ilosc]- 1) / 2 || okno < 0 );
		}
		
		switch (wybor)
		{
		case 0:
			return 0;
		case 1:
			for (i = 0; i < okno; i++) (*tab_Filtrowana)[i] = tab_Szum[i];
			for (i = okno; i < tab_Wspol[ilosc] - okno; i++) (*tab_Filtrowana)[i] = Fn_Mediana(tab_Szum,okno, i-okno, i+okno);
			for (i = tab_Wspol[ilosc] - okno; i < tab_Wspol[ilosc]; i++) (*tab_Filtrowana)[i] = tab_Szum[i];
			break;
		case 2:
			for (i = 0; i < okno; i++) *(tab_Filtrowana)[i] = tab_Szum[i];
			for (i = okno; i < tab_Wspol[ilosc] - okno; i++) *(tab_Filtrowana)[i] = Fn_Srednia(tab_Szum, okno,i - okno , i + okno);
			for (i = tab_Wspol[ilosc] - okno; i < tab_Wspol[ilosc]; i++) *(tab_Filtrowana)[i] = tab_Szum[i];
			break;
		default:
			printf("Nie ma takiej opcji. Sprobuj ponownie.\n");
			while (getchar() != '\n');
		}
	} while (wybor > 2 || wybor < 0);
}


double Fn_Babelkowe(double *tab_Pomocnicza, int okno)
{
		int i, j, temp;
		for (i = 0; i < okno - 1; i++)
		{
			for (j = 0; j < okno - 1 - i; j++)
			{
				if (tab_Pomocnicza[j] > tab_Pomocnicza[j + 1])
				{
					temp = tab_Pomocnicza[j + 1];
					tab_Pomocnicza[j + 1] = tab_Pomocnicza[j];
					tab_Pomocnicza[j] = temp;
				}
			}
		}
}


double Fn_Mediana(double *tab_Szum, int okno, int poczatek, int koniec)
{
	int i;
	int ile = koniec - poczatek + 1;
	double wartosc = 0;
	double *tab_Pomocnicza = NULL;
	free(tab_Pomocnicza);
	tab_Pomocnicza = (double*)malloc((size_t)okno * sizeof(*tab_Pomocnicza));
	if (tab_Pomocnicza == NULL)
	{
		printf("Nie udalo sie przydzielic pamieci.\n");
		while (getchar() != '\n');
		return 0;
	}
	for (i = 0; i < ile; i++)
	{
		tab_Pomocnicza[i] = tab_Szum[poczatek + i];
	}
	Fn_Babelkowe(tab_Pomocnicza, okno);
	wartosc = tab_Pomocnicza[ile];
	free(tab_Pomocnicza);
	return wartosc;
}


double Fn_Srednia(double *tab_Szum, int okno, int poczatek, int koniec)
{
	int i, ile = koniec - poczatek + 1;
	double wynik = 0;
	for (i = 0; i < ile; i++)
	{
		wynik += tab_Szum[poczatek + i];
	}
	return wynik / ile;
}


double Fn_Wczytaj(double **tab_Sygnal, double **tab_Szum, double **tab_Filtrowana, double **tab_Argumenty, double *tab_Wspol)
{
	double  *glupia;
	int i = 0;
	int n = 100;
	char *nazwa;
	FILE *plik;

	system("cls");
	nazwa = Fn_Pobierz_Nazwe_Pliku();
	if (!nazwa)
	{
		printf("Nie ma takiego pliku.\n");
		getchar();
		getchar();
		return tab_Wspol[ilosc];
	}

	plik = fopen(nazwa, "r");

	if (!plik)
	{
		printf("Nie udalo sie otworzyc pliku.\n");
		free(nazwa);
		getchar();
		getchar();
		return tab_Wspol[ilosc];
	}

	free(*tab_Sygnal);
	
	if (*tab_Szum)
	{
		free(*tab_Szum);
		*tab_Szum = NULL;
	}

	if (*tab_Filtrowana)
	{
		free(*tab_Filtrowana);
		*tab_Filtrowana = NULL;
	}

	if (*tab_Argumenty)
	{
		free(*tab_Argumenty);
		*tab_Argumenty = NULL;
	}


	*tab_Sygnal = (double*)malloc(n * sizeof(double));
	*tab_Argumenty = (double*)malloc(n * sizeof(double));

	if (!(*tab_Sygnal) || !(*tab_Argumenty))
	{
		free(*tab_Sygnal);
		free(*tab_Argumenty);
		free(nazwa);
		printf("Jestesmy tutaj\n");
		printf("Nie udalo sie przydzielic pamieci.\n");
		getchar();
		getchar();
		return 0;
	}

	while (1)
	{
		if (fscanf(plik, "%lf;%lf \n", &(*tab_Argumenty)[i], &(*tab_Sygnal)[i]) == EOF)
		{
			glupia = *tab_Sygnal;
			*tab_Sygnal = (double*)realloc(*tab_Sygnal, n * sizeof(double));
			if (!(*tab_Sygnal))
			{
				free(glupia);
				free(nazwa);
				free(*tab_Argumenty);
				printf("Jestesmy tutaj 2\n");
				printf("Nie udalo sie przydzielic pamieci.\n");

				getchar();
				getchar();
				return 0;
			}
			glupia = *tab_Argumenty;
			*tab_Argumenty = (double*)realloc(*tab_Argumenty, n * sizeof(double));
			if (!(*tab_Argumenty))
			{
				free(glupia);
				free(nazwa);
				free(*tab_Sygnal);
				printf("Jestesmy tutaj 3\n"); 
				printf("Nie udalo sie przydzielic pamieci.\n");
				getchar();
				getchar();
				return 0;
			}
			free(nazwa);
			return 0;
		}

		i++;

		if (i >= n)
		{
			glupia = *tab_Sygnal;
			*tab_Sygnal = (double*)realloc(*tab_Sygnal, n * sizeof(double));
			if (!(*tab_Sygnal))
			{
				free(glupia);
				free(nazwa);
				free(*tab_Argumenty);
				printf("Jestesmy tutaj 4\n");
				printf("Nie udalo sie przydzielic pamieci.\n");
				getchar();
				getchar();
				return 0;
			}
			glupia = *tab_Argumenty;
			*tab_Argumenty = (double*)realloc(*tab_Argumenty, n * sizeof(double));
			if (!(*tab_Argumenty))
			{
				free(glupia);
				free(nazwa);
				free(*tab_Sygnal);
				printf("Jestesmy tutaj 5\n");
				printf("Nie udalo sie przydzielic pamieci.\n");
				getchar();
				getchar();
				return 0;
			}
			n += n;
		}
	}
}


char* Fn_Pobierz_Nazwe_Pliku(void)
{
	char *tab; 
	char *tab2;
	int wybor;
	int i = 4; 
	int n = 30;

	tab = (char*)malloc(n * sizeof(char));

	if (!tab)
	{
		printf("Nie udalo sie przydzielic pamieci.\n");
		getchar();
		getchar();
		return NULL;
	}
	printf("Podaj nazwe pliku (bez rozszerzenia): ");
	getchar();

	do
	{
		if (i + 1 >= n)
		{
			tab2 = tab;
			tab = (char*)realloc(tab, n * sizeof(char));
			n += n;
			if (!tab)
			{
				printf("Nie udalo sie przydzielic pamieci dla nazwy.\n");
				getchar();
				getchar();
				free(tab2);
				return NULL;
			}
		}
		tab[i - 4] = getchar();
		if (tab[i -4] == ' ')
		{
			tab[i - 4] = '_';
		}
		
		i++;
	} while (tab[i - 5] != '\n');

	tab[i - 5] = 0;
	do 
	{
		system("cls");
		printf("Wybierz rozszerzenie takiego pliku. \n");
		printf("(1) .txt (plik tekstowy)\n");
		printf("(2) .csv (arkusz kalkulacyjny)\n");
		printf("Twoj wybor: ");
		Fn_Zmienna_Przypisz("%d", &wybor);
		switch (wybor)
		{
		case 1:
			strcat(tab, ".txt");
			break;
		case 2:
			strcat(tab, ".csv");
			break;
		default:
			system("cls");
			printf("Nie ma takiej opcji.\n");
			getchar();
		}
	} while (wybor > 2 || wybor < 1);

	return tab;
}