KOSELSKI_KOD_INF

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

void wczytajRozmiar(int *rozmiar);
int losuj(int min, int max);
float minimum(float t[], int rozmiar);
float maximum(float t[], int rozmiar);
void zamien(float *a, float*b);
void wczytajWsp(float wsp[4]);
void dziedzina(float *dMin, float *dMax);
void generator(float wsp[], float dMin, float dMax, float wyniki[], int rozmiar);
void losowanieSzumu(float szum[], float wyniki[], int rozmiar);
void zapisuj(float szum[], int rozmiar);
void odczytujDane(float **tablica, int *nowyRoz);
void babelSort(float tab[], int n);
void filtrMedianowy(float *zaszumiona, float *odszumiona, int rozmiar);
void filtrSredniej(float *zaszumiona, float *odszumiona, int rozmiar);

int main(int argc, char **argv)
{
	FILE* plik;
	float wspolczynniki[4];
	float *wyniki = NULL, *szum = NULL, *odszum = NULL;
	float dolna, gorna;
	int rozmiar = 0;
	int i, opcja, filtr, stan = 0;
	srand((unsigned int)(time(NULL)));
	setlocale(LC_ALL, "polish_poland");

	printf("Wybierz opcje:\n 1) Generacja sygnalu\n 2) Generacja szumu\n 3) Filtrowanie\n 4) Zapisywanie\n 5) Wczytywanie zaszumionego sygnalu\n 6) Koniec programu\n)");
	while (scanf("%d", &opcja))
	{
		switch (opcja)
		{
		case 1:
			if (stan == 1 || stan == 2 || stan == 3 || stan == 4 || stan == 5)
			{
				printf("Nie mozesz wybrac tej opcji poniewaz wczytales/wygenerowales/filtrowales/zaszumiales juz sygnal\n");
				break;
			}
			printf(" Generacja odbedzie sie na podstawie funkcji y = A * sin(x / B) - C * cos(x) + D\n ");
			wczytajRozmiar(&rozmiar);
			wyniki = malloc(rozmiar * sizeof(*wyniki));
			wczytajWsp(wspolczynniki);
			dziedzina(&dolna, &gorna);
			generator(wspolczynniki, dolna, gorna, wyniki, rozmiar);
			stan = 1;
			break;
		case 2:
			if (stan == 1 || (stan != 2 && stan !=3 && stan != 5))
			{
				szum = malloc(rozmiar * sizeof(*szum));
				losowanieSzumu(szum, wyniki, rozmiar);
				stan = 2;
			}
			else
				printf("Jeszcze nie wygerowales/juz zaszumiles sygnal!\n");
			break;
		case 3:
			if (stan == 2 || stan == 5)
			{
				odszum = malloc(rozmiar * sizeof(*odszum));
				printf("Czy chcesz zastosowac filtr Medianowy(wpisz 1) czy filtr Sredniej(wpisz 2)?\n");
				scanf("%d", &filtr);
				if (filtr == 1)
					filtrMedianowy(szum, odszum, rozmiar);
				else if (filtr == 2)
					filtrSredniej(szum, odszum, rozmiar);
				else
				{
					printf("Nie wybrales dobrej opcji.\nWybierz jeszcze raz Filtrowanie i wybierz dobra opcje!\n");
					break;
				}
				printf("Sygnal zostal odszumiony\n");
				stan = 3;
				break;
			}
			else
			{
				printf("Nie zaszumiles sygnalu/juz zafiltrowales\n");
				break;
			}
		case 4:
			if (stan == 3)
			{
				zapisuj(szum, rozmiar);
				plik = fopen("C:\\Users\\Admin\\Desktop\\odszumiony.csv", "w");
				if (plik == NULL)
				{
					printf("Nie udalo sie zapisac do pliku odszumionego sygnalu\n ");
					break;
				}
				for (i = 0; i < rozmiar; i++)
					fprintf(plik, "%f\n", odszum[i]);
				fclose(plik);
				printf("Zapisano odszumiony sygnal\n");
				stan = 4;
			}
			else
				printf("Nie mozna zapisac (mozliwe ze juz to zrobiles)! Najpierw zaszum/wczytaj sygnal i filtruj.\n");
			break;
		case 5:
			if (stan == 1 || stan == 2 || stan == 3)
			{
				printf("Nie mozesz wczytac sygnalu poniewaz zostal wygenerowany\n");
				break;
			}
			odczytujDane(&szum, &rozmiar);
			stan = 5;
			break;
		case 6:
			if (wyniki != NULL)
				free(wyniki);
			if (szum != NULL)
				free(szum);
			if (odszum != NULL)
				free(odszum);
			return 0;
		default:
			printf("Wybierz opcje od 1 do 6.\n");
			break;
		}
		system("pause");
		system("cls");
		printf(" 1)Generacja sygnalu\n 2)Generacja szumu\n 3)Filtrowanie\n 4)Zapisywanie\n 5)Wczytywanie zaszumionego sygnalu\n 6)Koniec programu\n)");
	}
}

void wczytajRozmiar(int *rozmiar)
{
	printf("Podaj ilosc probek generowanego sygnalu(>5):\n");
	scanf("%d", rozmiar);
	while (*rozmiar <= 5)
	{
		printf("Wprowadz wieksza ilosc probek [>5] \n");
		scanf("%d", rozmiar);
	}
}

int losuj(int min, int max)
{
	return rand() % (max - min + 1) + min;
}

float minimum(float t[], int rozmiar)
{
	int i = 0;
	int mini = 0;
	for (i = 0; i < rozmiar - 1; i++)
	{
		if (t[i + 1] < t[mini])
			mini = i + 1;
	}
	return t[mini];
}

float maximum(float t[], int rozmiar)
{
	int i = 0;
	int maxi = 0;
	for (i = 0; i < rozmiar - 1; i++)
	{
		if (t[i + 1] > t[maxi])
			maxi = i + 1;
	}
	return t[maxi];
}

void zamien(float *a, float*b)
{
	float pom = *a;
	*a = *b;
	*b = pom;
}

void wczytajWsp(float wsp[4])
{
	printf("Podaj wspolczynnik A\n");
	scanf("%f", &wsp[0]);
	printf("Podaj wspolczynnik B(!=0):\n");
	scanf("%f", &wsp[1]);
	while (wsp[1] == 0)
	{
		printf("Wprowadz inny wspolczynnik B(!=0)\n");
		scanf("%f", &wsp[1]);
	}
	printf("Podaj wspolczynnik C\n");
	scanf("%f", &wsp[2]);
	printf("Podaj wspolczynnik D\n");
	scanf("%f", &wsp[3]);
}


void dziedzina(float *dMin, float *dMax)
{
	printf("Podaj dolny zakres dziedziny:\n");
	scanf("%f", dMin);
	printf("Podaj gorny zakres dziedziny:\n");
	scanf("%f", dMax);
	if (*dMin > *dMax)
		zamien(dMin, dMax);
	else if (*dMin == *dMax)
	{
		*dMax = *dMax + 1;
		printf("Podales takie same granice, gorna zostala zwiekszona o 1\n");
	}
}

void generator(float wsp[], float dMin, float dMax, float wyniki[], int rozmiar)
{
	int i = 0;
	float x = dMin;
	const float przyrost = (float)((fabs(dMax - dMin)) / rozmiar);
	for (i = 0; i < rozmiar; i++)
	{
		wyniki[i] = (float)(wsp[0] * sin(x / wsp[1]) - wsp[2] * cos(x) + wsp[3]);
		x += przyrost;
	}
	printf("Sygnal zostal wygenerowany\n");
}

void losowanieSzumu(float szum[], float wyniki[], int rozmiar)
{
	int indeks = 0, i = 0;
	int iloscZaszum;
	float amplituda, pom, ymin, ymax;
	for (i = 0; i < rozmiar; i++)
		szum[i] = wyniki[i];
	iloscZaszum = losuj((rozmiar * 10) / 100, (rozmiar * 20) / 100);	//od 10 do 20 procent zaszumienie
	ymin = minimum(szum, rozmiar);
	ymax = maximum(szum, rozmiar);
	amplituda = ymax - ymin;
	for (i = 0; i < iloscZaszum; i++)
	{
		indeks = rand() % rozmiar;
		pom = szum[indeks];
		szum[indeks] = (float)(((float)rand() / (float)(RAND_MAX))*(amplituda / 2) - amplituda / 4. + pom);
	}
	printf("Zaszumiono sygnal\n");
}

void zapisuj(float szum[], int rozmiar)
{
	FILE* plik;
	int i;
	plik = fopen("C:\\Users\\Admin\\Desktop\\plik.csv", "w");
	if (plik == NULL)
	{
		printf("Nie mozna otworzyc pliku\n");
	}
	else
	{
		for (i = 0; i < rozmiar; i++)
			fprintf(plik, "%f\n", szum[i]);
		fclose(plik);
		printf("Zapisano sygnal zaszumiony\n");
	}
}

void odczytujDane(float **tablica, int *nowyRoz)
{
	int licznik = 0, i = 0;
	float *pom = NULL;
	FILE* plik;
	plik = fopen("C:\\Users\\Admin\\Desktop\\plik.csv", "r");
	if (plik == NULL)
	{
		printf("Nie mozna otworzyc pliku\n");
	}
	else
	{
		while (fgetc(plik) != EOF)
		{
			fseek(plik, -1, SEEK_CUR);
			licznik++;
			pom = realloc(pom, licznik * sizeof(float));
			fscanf(plik, "%f\n", &pom[licznik - 1]);
		}
		*nowyRoz = licznik;
		*tablica = realloc(*tablica, licznik * sizeof(float));
		for (i = 0; i < licznik; i++)
			(*tablica)[i] = pom[i];
		free(pom);
		fclose(plik);
		printf("Udalo sie wczytac\n");
	}
}

void babelSort(float tab[], int rozmiar)
{
	int i, j;
	for (i = 0; i < rozmiar - 1; i++)
		for (j = 0; j < rozmiar - i - 1; j++)
			if (tab[j] > tab[j + 1])
				zamien(&tab[j], &tab[j + 1]);
}

void filtrMedianowy(float *zaszumiona, float *odszumiona, int rozmiar)
{
	int i;
	float *tymczasowa;
	float mediana[5];
	tymczasowa = malloc(rozmiar * sizeof(float));
	for (i = 0; i < rozmiar; i++)
		*(tymczasowa + i) = *(zaszumiona + i);
	for (i = 2; i < rozmiar - 2; i++)
	{
		mediana[0] = tymczasowa[i - 2];
		mediana[1] = tymczasowa[i - 1];
		mediana[2] = tymczasowa[i];
		mediana[3] = tymczasowa[i + 1];
		mediana[4] = tymczasowa[i + 2];
		babelSort(mediana, 5);
		odszumiona[i] = mediana[2];
	}
	//przypadek dla 0 elementu zaszumionej z odbiciem lustrzanym
	mediana[0] = tymczasowa[2];
	mediana[1] = tymczasowa[1];
	mediana[2] = tymczasowa[0];
	mediana[3] = tymczasowa[1];
	mediana[4] = tymczasowa[2];
	babelSort(mediana, 5);
	odszumiona[0] = mediana[2];
	//przypadek dla 1 elementu zaszumionej z odbiciem lustrzanym
	mediana[0] = tymczasowa[0];
	mediana[1] = tymczasowa[0];
	mediana[2] = tymczasowa[1];
	mediana[3] = tymczasowa[2];
	mediana[4] = tymczasowa[3];
	babelSort(mediana, 5);
	odszumiona[1] = mediana[2];
	//przypadek dla rozmiar-2 elementu zaszumionej z odbiciem lustrzanym
	mediana[0] = tymczasowa[rozmiar - 4];
	mediana[1] = tymczasowa[rozmiar - 3];
	mediana[2] = tymczasowa[rozmiar - 2];
	mediana[3] = tymczasowa[rozmiar - 1];
	mediana[4] = tymczasowa[rozmiar - 3];
	babelSort(mediana, 5);
	odszumiona[rozmiar - 2] = mediana[2];
	//przypadek dla rozmiar-1 elementu zaszumionej z odbiciem lustrzanym
	mediana[0] = tymczasowa[rozmiar - 3];
	mediana[1] = tymczasowa[rozmiar - 2];
	mediana[2] = tymczasowa[rozmiar - 1];
	mediana[3] = tymczasowa[rozmiar - 2];
	mediana[4] = tymczasowa[rozmiar - 3];
	babelSort(mediana, 5);
	odszumiona[rozmiar - 1] = mediana[2];

	free(tymczasowa);
}

void filtrSredniej(float *zaszumiona, float *odszumiona, int rozmiar)
{
	int i;
	for (i = 2; i < rozmiar - 2; i++)
	{
		odszumiona[i] = (float)((zaszumiona[i - 2] + zaszumiona[i - 1] + zaszumiona[i] + zaszumiona[i + 1] + zaszumiona[i + 2]) / 5);
	}
	odszumiona[0] = zaszumiona[0];
	odszumiona[1] = zaszumiona[1];
	odszumiona[rozmiar - 1] = zaszumiona[rozmiar - 1];
	odszumiona[rozmiar - 2] = zaszumiona[rozmiar - 2];
}