lekarzrakanacito |
» 2026-11-03 13:29:02 define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h> // Wymagane do srand
void pobierzwsp(double wsp[])
{
printf("podaj A: \n");
scanf("%lf", &wsp[0]);
do
{
printf("podaj B(rozne od 0): \n"); // zabezpieczenie zad z ramki
scanf("%lf", &wsp[1]);
if (wsp[1] == 0)
{
printf("Blad, nie dziel przez 0\n");
}
} while (wsp[1] == 0);
printf("podaj C: \n");
scanf("%lf", &wsp[2]);
printf("podaj D: \n");
scanf("%lf", &wsp[3]);
}
void pobierzgranice(double* xmin, double* xmax)
{
do
{
printf("Podaj xmin (mniejsze od xmax): \n"); // drugie zabez zad z ramki
scanf("%lf", xmin);
printf("Podaj xmax (wieksze od xmin): \n");
scanf("%lf", xmax);
if (*xmin >= *xmax)
{
printf("Blad, xmin nie moze byc wiekszy od xmax\n");
}
} while (*xmin >= *xmax);
}
int pobierzrozmiar()
{
int n;
do
{
printf("Podaj liczbe probek (minimum 10): \n");
scanf("%d", &n);
if (n < 10)
{
printf("Blad, liczba probek minimum 10\n");
}
} while (n < 10);
return n;
}
void generujsygnal(int n, double xmin, double xmax, double sygnal[], double wsp[])
{
double dx = (xmax - xmin) / n;
for (int i = 0; i < n; i++)
{
double x = xmin + i * dx;
sygnal = wsp[0] * sin((x + wsp[2]) / wsp[1]) + wsp[3];
}
}
void wyswietlsygnal(int n, double sygnal[])
{
for (int j = 0; j < n; j++)
{
printf("sygnal nr.%d = %lf\n", j, sygnal[j]);
}
}
void generujszum(int n, double sygnal[], double zaszumiony[], double max_amplituda)
{
for (int i = 0; i < n; i++)
{
if (rand() % 100 < 40) //narzucony szum
{
double szum = ((double)rand() / RAND_MAX * 2.0 - 1.0) * max_amplituda; //szum od -A do A
zaszumiony = sygnal + szum;
}
else
{
zaszumiony = sygnal; // Brak szumu
}
}
printf("Szum zostal wygenerowany\n");
}
void filtr_medianowy(int n, double wejscie[], double wyjscie[], int k)
{
for (int i = 0; i < n; i++)
{
if (i < k || i >= n - k)
{
wyjscie = wejscie; // Skrajne probki przepisujemy
}
else
{
int okno_rozmiar = 2 * k + 1;
double okno[100];
for (int j = 0; j < okno_rozmiar; j++)
{
okno[j] = wejscie;
}
// Sortowanie babelkowe dla okna
for (int m = 0; m < okno_rozmiar - 1; m++)
{
for (int p = 0; p < okno_rozmiar - 1 - m; p++)
{
if (okno[p] > okno[p + 1])
{
double temp = okno[p];
okno[p] = okno[p + 1];
okno[p + 1] = temp;
}
}
}
wyjscie = okno[k]; // Mediana
}
}
}
void filtr_sredniej_ruchomej(int n, double wejscie[], double wyjscie[], int k)
{
int szerokosc = 2 * k + 1;
double* temp = (double*)malloc(n * sizeof(double));
if (temp == NULL) return;
for (int i = 0; i < n; i++)
{
if (i < k || i >= n - k)
{
temp = wejscie; // Skrajne probki przepisujemy
}
else
{
double suma = 0.0;
for (int j = i - k; j <= i + k; j++)
{
suma += wejscie[j];
}
temp = suma / szerokosc;
}
}
for (int i = 0; i < n; i++)
{
wyjscie = temp;
}
free(temp);
}
void zapiszsygnal(const char* nazwa_pliku, int n, double sygnal[])
{
FILE* plik = fopen(nazwa_pliku, "w");
if (plik == NULL)
{
printf("Blad otwarcia pliku\n");
return;
}
fprintf(plik, "sep=;\n");
for (int i = 0; i < n; i++)
{
fprintf(plik, "%.6lf\n", sygnal);
}
fclose(plik);
printf("Sygnal zostal pomyslnie zapisany do pliku: %s\n", nazwa_pliku);
}
// Obcina poczatek sygnalu: zwraca nowa tablice dynamiczna z probkami od N do ostatniej.
// Rozmiar nowej tablicy zapisywany jest w *nowy_n. Przy bledzie zwraca NULL.
// Numeracja probek jak przy wyswietlaniu: od 0 do n-1.
double* obetnijsygnal(int n, double sygnal[], int N, int* nowy_n)
{
if (N < 0 || N >= n)
{
printf("Blad, N musi byc w zakresie 0 - %d\n", n - 1);
*nowy_n = 0;
return NULL;
}
*nowy_n = n - N;
double* skrocony = (double*)malloc((*nowy_n) * sizeof(double));
if (skrocony == NULL)
{
printf("Blad zaalokowania pamieci!\n");
*nowy_n = 0;
return NULL;
}
for (int i = 0; i < *nowy_n; i++)
{
skrocony = sygnal[N + i];
}
return skrocony;
}
int main()
{
setlocale(LC_ALL, "polish_poland");
srand((unsigned int)time(NULL));
double wsp[4];
double xmin = 0, xmax = 0;
int n = 0;
// Wskaźniki na tablice dynamiczne sygnalow
double* sygnal = NULL;
double* zaszumiony = NULL;
double* odfiltrowany = NULL;
double* skrocony = NULL; // sygnal odfiltrowany po obcieciu poczatku
int n_skrocony = 0;
// Flagi zabezpieczajace kolejnosci operacji
int czy_szum = 0;
int czy_filtr = 0;
int czy_obciety = 0;
int opcja = -1;
while (opcja != 0)
{
printf("\n=== MENU GLOWNE ===\n");
printf("1. Generowanie sygnalu podstawowego\n");
printf("2. Wprowadzanie szumu do sygnalu\n");
printf("3. Zapis do pliku CSV\n");
printf("4. Filtracja sygnalu\n");
printf("5. Obciecie poczatku sygnalu odfiltrowanego\n");
printf("0. Zakonczenie programu\n");
printf("Wybierz opcje: ");
scanf("%d", &opcja);
switch (opcja)
{
case 1:
if (sygnal != NULL) free(sygnal);
if (zaszumiony != NULL) free(zaszumiony);
if (odfiltrowany != NULL) free(odfiltrowany);
if (skrocony != NULL) { free(skrocony); skrocony = NULL; }
n = pobierzrozmiar();
sygnal = (double*)malloc(n * sizeof(double));
zaszumiony = (double*)malloc(n * sizeof(double));
odfiltrowany = (double*)malloc(n * sizeof(double));
if (sygnal == NULL || zaszumiony == NULL || odfiltrowany == NULL)
{
printf("Blad zaalokowania pamieci!\n");
return -1;
}
pobierzwsp(wsp);
pobierzgranice(&xmin, &xmax);
generujsygnal(n, xmin, xmax, sygnal, wsp);
// Reset flag po nowej generacji
czy_szum = 0;
czy_filtr = 0;
czy_obciety = 0;
printf("Sygnal podstawowy zostal wygenerowany.\n");
break;
case 2:
// Zabezpieczeni sprawezenie czy sygnał podstawowy istnieje
if (sygnal == NULL)
{
printf("Najpierw wygeneruj sygnal podstawowy (Opcja 1)!\n");
break;
}
// Automatyczna amplituda (50% wsp A)
double max_amplituda = fabs(wsp[0]) * 0.5;
generujszum(n, sygnal, zaszumiony, max_amplituda);
czy_szum = 1;
czy_filtr = 0; // zresetuj filtrację dla nowego szumu
czy_obciety = 0;
printf("Szum zostal wygenerowany automatycznie (amplituda = %.2lf).\n", max_amplituda);
break;
case 3:
// Zabezp sprawdz czy jakikolwiek sygnał istnieje
if (sygnal == NULL)
{
printf("Brak wygenerowanego sygnalu do zapisu! Najpierw wykonaj Opcje 1.\n");
break;
}
int pod_opcja;
printf("\nKtory sygnal chcesz zapisac?\n");
printf("1. Sygnal podstawowy\n");
printf("2. Sygnal zaszumiony\n");
printf("3. Sygnal odfiltrowany\n");
printf("4. Sygnal obciety\n");
printf("Wybor: ");
scanf("%d", &pod_opcja);
if (pod_opcja == 1)
{
zapiszsygnal("sygnal_podstawowy.csv", n, sygnal);
}
else if (pod_opcja == 2)
{
if (!czy_szum)
{
printf("Blad: Szum nie zostal jeszcze wygenerowany (Opcja 2)!\n");
}
else
{
zapiszsygnal("sygnal_zaszumiony.csv", n, zaszumiony);
}
}
else if (pod_opcja == 3)
{
if (!czy_filtr)
{
printf("Blad: Sygnal nie zostal jeszcze odfiltrowany (Opcja 4)!\n");
}
else
{
zapiszsygnal("sygnal_odfiltrowany.csv", n, odfiltrowany);
}
}
else if (pod_opcja == 4)
{
if (!czy_obciety)
{
printf("Blad: Sygnal nie zostal jeszcze obciety (Opcja 5)!\n");
}
else
{
zapiszsygnal("sygnal_obciety.csv", n_skrocony, skrocony);
}
}
else
{
printf("Nieprawidlowy wybor!\n");
}
break;
case 4:
// Zabezpieczenie: sprawdzamy czy istnieje sygnał zaszumiony do filtracji
if (sygnal == NULL)
{
printf("Najpierw wygeneruj sygnal podstawowy (Opcja 1)!\n");
break;
}
if (!czy_szum)
{
printf("Najpierw wprowadz szum do sygnalu (Opcja 2)!\n");
break;
}
int opcja_filtru;
printf("\n--- Wybierz metode filtracji ---\n");
printf("1. Filtr medianowy\n");
printf("2. Filtr sredniej ruchomej\n");
printf("3. Filtracja sekwencyjna (medianowy + srednia ruchoma)\n");
printf("Wybor: ");
scanf("%d", &opcja_filtru);
if (opcja_filtru == 1)
{
filtr_medianowy(n, zaszumiony, odfiltrowany, 2); // okno 5 próbek (k=2)
czy_filtr = 1;
printf("Sygnal zostal pomyslnie odfiltrowany filtrem medianowym.\n");
}
else if (opcja_filtru == 2)
{
filtr_sredniej_ruchomej(n, zaszumiony, odfiltrowany, 2); // okno 5 próbek (k=2)
czy_filtr = 1;
printf("Sygnal zostal pomyslnie odfiltrowany filtrem sredniej ruchomej.\n");
}
else if (opcja_filtru == 3)
{
filtr_medianowy(n, zaszumiony, odfiltrowany, 2);
filtr_sredniej_ruchomej(n, odfiltrowany, odfiltrowany, 2);
czy_filtr = 1;
printf("Sygnal zostal pomyslnie odfiltrowany sekwencyjnie (medianowy -> srednia ruchoma).\n");
}
else
{
printf("Nieprawidlowa opcja filtracji!\n");
}
czy_obciety = 0; // po nowej filtracji stary obciety sygnal jest nieaktualny
break;
case 5:
if (!czy_filtr)
{
printf("Najpierw odfiltruj sygnal (Opcja 4)!\n");
break;
}
else
{
int N;
int nowy_n = 0;
printf("Podaj N - numer pierwszej probki do zachowania (0 - %d): \n", n - 1);
scanf("%d", &N);
double* nowy = obetnijsygnal(n, odfiltrowany, N, &nowy_n);
if (nowy != NULL)
{
if (skrocony != NULL) free(skrocony);
skrocony = nowy;
n_skrocony = nowy_n;
czy_obciety = 1;
printf("Sygnal obcieto. Nowy rozmiar: %d probek (od nr.%d do nr.%d).\n", n_skrocony, N, n - 1);
}
}
break;
case 0:
printf("Zakonczenie programu.\n");
break;
default:
printf("Nieprawidlowa opcja, sprobuj ponownie.\n");
break;
}
}
if (sygnal != NULL) free(sygnal);
if (zaszumiony != NULL) free(zaszumiony);
if (odfiltrowany != NULL) free(odfiltrowany);
if (skrocony != NULL) free(skrocony);
return 0;
} |