Tablica dynaiczna C

0

Piszę program który ma się zajmować edycją obrazów .pgm. Mam problem z dynaiczną tablicą do przechowywania obrazu. Proszę o wskazanie błędu.

Błąd jest w tym fragmencie:

 tab=(int(*))malloc(sizeof(int)*(*wymx)*(*wymy));
  int (*piksele)[*wymx];
  	      piksele=(int(*)[*wymy])tab;
  /* Pobranie obrazu i zapisanie w tablicy obraz_pgm*/
  for (j=0;j<*wymy;j++) {
    for (i=0;i<*wymx;i++) {
      fscanf(p,"%d",&piksele[i][j]);
  /*sprawdzenie czy pobrany obraz ma wlasciwe wymiary*/
      if(i>=MAX||j>=MAX) {/*mala zmiana w stosunku do oryginalu*/
	fprintf(stderr,"Blad: Niewlasciwe wymiary obrazu\n");
	return(0); 

A to jest cały kod. na początku chcę wczytać i zapisać obraz.

 #include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>

/*maksymalny rozmiar obrazka w pikselach
  okresla MAX*/
#define MAX 512
#define DL_LINII 80



int czytaj(FILE *p, int *tab,int *wymx,int *wymy,int *szarosci);
void zapisz(int *wymx,int *wymy,int *tab,int *szarosci,char komentarz[]);
 /*void wyswietl();
 int negatyw(int *wymx,int *wymy,int obraz_pgm[][MAX],int *szarosci);
 int progowanie(int *wymx,int *wymy,int obraz_pgm[][MAX],int *szarosci);
 int konturowanie(int *wymx,int *wymy,int obraz_pgm[][MAX]);
 int splot(int *wymx,int *wymy,int tab[][MAX]);
 int normalizacja(int *wymx,int *wymy,int obraz_pgm[][MAX],int *szarosci);
*/

/*zmienna pomocnicza do okreslenia czy zostal wczytany jakis plik,
jesli nie to program odmowi wykonania opcji zapisu, oraz funkcji przetwarzania*/

typedef struct obraz_pgm{
	char nazwa;
	FILE *plik;
	int wymx,wymy,odcieni;
	int *tab;
}obrazy;

/**********************************MAIN***************************/
/*Glowna czesc programu z menu uzytkownika i wywolaniami funkcji*/
int main()
{
  int plikwczytany=0;
  char *rozszerzenie=".pgm";
  //int x;
  /*x-zmienna pomocnicza do MENU
  c-zmienne pomocnicza do MENU2*/
  int wymx,wymy,odcieni,obraz[MAX][MAX];
  //FILE *plik;
  char nazwa_odczyt[100];
  obrazy *a;
  a=(obrazy*)malloc(sizeof(obrazy));
 printf("Wybrales odczyt,podaj nazwe pliku\n\n");
    printf("Podaj sama nazwe pliku bez jego rozszerzenia (rozszerzenie domyslne .pgm):\n");
    scanf("%s",&(a->nazwa));
    /*dodajemy koncowke .pgm do nazwa_odczyt,ta sama koncowka co w funkcji zapisz*/

    strncat(&a->nazwa,rozszerzenie,sizeof nazwa_odczyt-1);
    puts(&a->nazwa);
    a->plik=fopen(&a->nazwa,"r");
    /*wywolanie funkcji czytaj*/
    czytaj(a->plik,a->tab,&a->wymx,&a->wymy,&a->odcieni);
    plikwczytany=1;
    char komentarz[69];
    if(plikwczytany==0){
    printf("!!Nie wczytales zadnego pliku do pamieci!!\n");
    }
    printf("%d \n %d",a->wymx, a->wymy);
    /*wywolanie funkcji zapisz*/
    zapisz(&a->wymx,&a->wymy,a->tab,&a->odcieni,komentarz);
    return 0;
    }
/****************************CZYTAJ*********************************/

/*funkcja do odczytu pliku o podanej nazwie udostepniona na stornie kursu*/
int czytaj(FILE *p,int *tab,int *wymx,int *wymy,int *szarosci) {
  char s[DL_LINII];
  int znak,koniec=0,i,j;

/*sprawdzenie czy podano prawidlowy uchwyt pliku */
  if (p==NULL) {
    fprintf(stderr,"Blad: Nie podano uchwytu do pliku\n");
    return(0);
  }
  if (fgets(s,DL_LINII,p)==NULL) koniec=1;
  /* Sprawdzenie "numeru magicznego - powinien być P2 */
  if ( (s[0]!='P') || (s[1]!='2') || koniec) {
    fprintf(stderr,"Blad: To nie jest plik PGM\n");
    return(0);
  }
  /* Pominiecie komentarzy */
  do {
    if ((znak=fgetc(p))=='#') {
      if (fgets(s,DL_LINII,p)==NULL) koniec=1;
    }  else {
      ungetc(znak,p);
    }
  } while (! koniec && znak=='#');
  /* Pobranie wymiarow i liczby odcieni szarosci */
  if (fscanf(p,"%d %d %d",wymx,wymy,szarosci)!=3) {
    fprintf(stderr,"Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n");
    return(0);
  }
  printf("%d \n %d",*wymx, *wymy);
  tab=(int(*))malloc(sizeof(int)*(*wymx)*(*wymy));
  int (*piksele)[*wymx];
  	      piksele=(int(*)[*wymy])tab;
  /* Pobranie obrazu i zapisanie w tablicy obraz_pgm*/
  for (j=0;j<*wymy;j++) {
    for (i=0;i<*wymx;i++) {
      fscanf(p,"%d",&piksele[i][j]);
  /*sprawdzenie czy pobrany obraz ma wlasciwe wymiary*/
      if(i>=MAX||j>=MAX) {/*mala zmiana w stosunku do oryginalu*/
	fprintf(stderr,"Blad: Niewlasciwe wymiary obrazu\n");
	return(0);
      }
    }
  }
  return *wymx**wymy;
}
/*******************************************************************************************************/

/***************************************ZAPISZ******************************************/
/*funkcja do zapisywania pliku pod zadana nazwa*/
void zapisz(int *wymx,int *wymy,int *tab,int *szarosci,char komentarz[])
{
	int (*piksele)[*wymx];
	      piksele=(int(*)[*wymy])tab;
  char *rozszerzenie=".pgm";
    int i=0,j=0;
    FILE *plik2;
    char nazwazapis_pgm[100];
    /*if(pr==1){*szarosci=1;}*/
    printf("%d \n %d",*wymx, *wymy);
    /*wczytanie nazwy pliku bez dodawania rozszerzenia .pgm*/
    printf("Podaj nazwe pliku bez dopisywania rozszerzenia:\n");
    scanf("%s",nazwazapis_pgm);
              printf("Trwa zapisywanie \n");
    /*do wczytanej nawzwy dopisujemy koncowke rozszerzenia ".pgm"*/

    strncat(nazwazapis_pgm,rozszerzenie,sizeof nazwazapis_pgm-1);
    printf("\n");
    puts(nazwazapis_pgm);/*wyswietl nazwe zapisywanego pliku*/
    printf("%d \n %d",*wymx, *wymy);
    plik2=fopen(nazwazapis_pgm,"w"); /*tworzymy plik o podanej nazwie*/
    printf("%d \n %d",*wymx, *wymy);
    fprintf(plik2,"P2\n");/*dodajemy numer magiczny:) P2*/
    fprintf(plik2,"\n%d %d\n",*wymx,*wymy);/*wpisujemy wymiary tablicy zawierajacej obraz pgm*/
    fprintf(plik2,"%d\n",*szarosci);/*wpisujemy liczbe oznaczajaca maksymalna szarosc*/


    /*dwie petle for wypisuja wartosci z tablicy*/
    for(j=0;j<*wymy;++j)
    {
                     for(i=0;i<*wymx;++i){printf("%d ",piksele[i][j]);}
    }
    fclose(plik2);/*zamykamy plik*/
    printf("Obraz zostal zapisany do pliku\n");/*dajemy komunikat o poprawnie wykonanym poleceniu*/
}

program się sypie i wyświetla błąd:Segmentation fault (core dumped).

0

int (*piksele)[*wymx];
Tak nie można, w [] zawsze musi być stała

0

A mógł byś mi doradzić jak napisać obsługe tego fragmentu?

0
  tab=(int(*))malloc(sizeof(int)*(*wymx)*(*wymy));
  for (j=0;j<*wymy;++j)
    for (i=0;i<*wymx;++i)
      fscanf(p,"%d",tab+j*wymx+i);
0

ok wprowadziłem zmiany i teraz program przepisuje obraz pgm do tablicy. Ale sypie się w funkcji zapisz.
Segmentation fault (core dumped)
Domyślam sie że najprawdopodobniej gubię adres tablicy ale nie mogę zrozumieć w którym miejscu programu.

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>

/*maksymalny rozmiar obrazka w pikselach
  okresla MAX*/
#define MAX 512
#define DL_LINII 80



int czytaj(FILE *p,int *tab,int *wymx,int *wymy,int *szarosci);
void zapisz(int *wymx,int *wymy,int *tab,int *szarosci,char komentarz[]);
 /*void wyswietl();
 int negatyw(int *wymx,int *wymy,int obraz_pgm[][MAX],int *szarosci);
 int progowanie(int *wymx,int *wymy,int obraz_pgm[][MAX],int *szarosci);
 int konturowanie(int *wymx,int *wymy,int obraz_pgm[][MAX]);
 int splot(int *wymx,int *wymy,int tab[][MAX]);
 int normalizacja(int *wymx,int *wymy,int obraz_pgm[][MAX],int *szarosci);
*/

/*zmienna pomocnicza do okreslenia czy zostal wczytany jakis plik,
jesli nie to program odmowi wykonania opcji zapisu, oraz funkcji przetwarzania*/

typedef struct obraz_pgm{
	char nazwa;
	FILE *plik;
	int wymx,wymy,odcieni;
	int *tab;
}obrazy;

/**********************************MAIN***************************/
/*Glowna czesc programu z menu uzytkownika i wywolaniami funkcji*/
int main()
{
  int plikwczytany=0;
  char *rozszerzenie=".pgm";
  //int x;
  /*x-zmienna pomocnicza do MENU
  c-zmienne pomocnicza do MENU2*/

  //FILE *plik;
  char nazwa_odczyt[100];
  obrazy *a;
  a=(obrazy*)malloc(sizeof(obrazy));
 printf("Wybrales odczyt,podaj nazwe pliku\n\n");
    printf("Podaj sama nazwe pliku bez jego rozszerzenia (rozszerzenie domyslne .pgm):\n");
    scanf("%s",&(a->nazwa));
    /*dodajemy koncowke .pgm do nazwa_odczyt,ta sama koncowka co w funkcji zapisz*/

    strncat(&a->nazwa,rozszerzenie,sizeof nazwa_odczyt-1);
    puts(&a->nazwa);
    a->plik=fopen(&a->nazwa,"r");
    /*wywolanie funkcji czytaj*/
    czytaj(a->plik,a->tab,&a->wymx,&a->wymy,&a->odcieni);
    plikwczytany=1;

    char komentarz[69];
    if(plikwczytany==0){
    printf("!!Nie wczytales zadnego pliku do pamieci!!\n");
    }
    /*wywolanie funkcji zapisz*/
    zapisz(&a->wymx,&a->wymy,a->tab,&a->odcieni,komentarz);

    return 0;
    }
/****************************CZYTAJ*********************************/

/*funkcja do odczytu pliku o podanej nazwie udostepniona na stornie kursu*/
int czytaj(FILE *p,int *tab,int *wymx,int *wymy,int *szarosci) {
  char s[DL_LINII];
  int znak,koniec=0,i,j;

/*sprawdzenie czy podano prawidlowy uchwyt pliku */
  if (p==NULL) {
    fprintf(stderr,"Blad: Nie podano uchwytu do pliku\n");
    return(0);
  }
  if (fgets(s,DL_LINII,p)==NULL) koniec=1;
  /* Sprawdzenie "numeru magicznego - powinien być P2 */
  if ( (s[0]!='P') || (s[1]!='2') || koniec) {
    fprintf(stderr,"Blad: To nie jest plik PGM\n");
    return(0);
  }
  /* Pominiecie komentarzy */
  do {
    if ((znak=fgetc(p))=='#') {
      if (fgets(s,DL_LINII,p)==NULL) koniec=1;
    }  else {
      ungetc(znak,p);
    }
  } while (! koniec && znak=='#');
  /* Pobranie wymiarow i liczby odcieni szarosci */
  if (fscanf(p,"%d %d %d",wymx,wymy,szarosci)!=3) {
    fprintf(stderr,"Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n");
    return(0);

  }


  tab=(int(*))malloc(sizeof(int)*(*wymx)*(*wymy));
    for (j=0;j<*wymy;++j)
      for (i=0;i<*wymx;++i)

  /* Pobranie obrazu i zapisanie w tablicy obraz_pgm*/
  for (j=0;j<(*wymy);j++) {
    for (i=0;i<(*wymx);i++) {
    	fscanf(p,"%d",tab+j*(*wymx)+i);
  /*sprawdzenie czy pobrany obraz ma wlasciwe wymiary*/
    }
  }

  return *wymx**wymy;
}
/*******************************************************************************************************/

/***************************************ZAPISZ******************************************/
/*funkcja do zapisywania pliku pod zadana nazwa*/
void zapisz(int *wymx,int *wymy,int *tab,int *szarosci,char komentarz[])
{
  char *rozszerzenie=".pgm";
    int i=0,j=0;
    FILE *plik2;
    char nazwazapis_pgm[100];
    /*if(pr==1){*szarosci=1;}*/

    /*wczytanie nazwy pliku bez dodawania rozszerzenia .pgm*/
    printf("Podaj nazwe pliku bez dopisywania rozszerzenia:\n");
    scanf("%s",nazwazapis_pgm);
              printf("Trwa zapisywanie \n");
    /*do wczytanej nawzwy dopisujemy koncowke rozszerzenia ".pgm"*/

    strncat(nazwazapis_pgm,rozszerzenie,sizeof nazwazapis_pgm-1);
    printf("\n");
    puts(nazwazapis_pgm);/*wyswietl nazwe zapisywanego pliku*/

    plik2=fopen(nazwazapis_pgm,"w"); /*tworzymy plik o podanej nazwie*/
    fprintf(plik2,"P2\n");/*dodajemy numer magiczny:) P2*/
    fprintf(plik2,"\n%d %d\n",*wymx,*wymy);/*wpisujemy wymiary tablicy zawierajacej obraz pgm*/
    fprintf(plik2,"%d\n",*szarosci);/*wpisujemy liczbe oznaczajaca maksymalna szarosc*/

    /*dwie petle for wypisuja wartosci z tablicy*/

    for (j=0;j<(*wymy);j++)
    {
       for (i=0;i<(*wymx);i++)
       {
       	fprintf(plik2,"%d",*(tab+j*(*wymx)+i));
     /*sprawdzenie czy pobrany obraz ma wlasciwe wymiary*/
       }
     }

    fclose(plik2);/*zamykamy plik*/
    printf("Obraz zostal zapisany do pliku\n");/*dajemy komunikat o poprawnie wykonanym poleceniu*/
}

 
0

gubisz w funkcji czytaj, w main'ie do czytaj przekazujesz a->tab, owszem wewnątrz zmieniasz tą wartość ale po powrocie nadal masz tą co była czyli jakieś śmieci.

0

A mógłbyś mi podowiedzieć jak temu zapobiec. Bo chyba tworzenie zmiennej globalnej jest gupim pomysłem w tym przypadku.

0

nie przekazuj osobno:
czytaj(a->plik,a->tab,&a->wymx,&a->wymy,&a->odcieni);
przekaż razem:
czytaj(a);

0

Dzięki za pomoc. Funkcja zapisz i czytaj jest już gotowa. Wszystko szło obrze do momentu gdy w funkcji progowanie muszę zmniejszyć wymiary obrazu oraz wart piksela zależy od dwóch sąsiednich
pikseli.

Problem pojawia sie w tym fragmencie. *wymyy-1 powoduje pojawienie się ukośnych lini a
tab[i+1][j] nałożenie się konturów.

 
for(i=0;i<*wymx-1;++i)
   {
	   for(j=0;j<*wymy-1;++j)
           {
		   tab[i][j]=fabs(tab[i+1][j]-tab[i][j])+fabs(tab[i][j]-tab[i][j+1]);
           }
   }
 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>

/*maksymalny rozmiar obrazka w pikselach
  okresla MAX*/
#define MAX 512
#define DL_LINII 80

typedef struct obraz_pgm{
	int wymx,wymy,odcieni;
	int **tab;
}obrazy;

int czytaj(obrazy *a);
void zapisz(int *wymx,int *wymy,int **tab,int *szarosci);
 //void wyswietl();
 int negatyw(int *wymx,int *wymy,int **tab,int *szarosci);
 int progowanie(int *wymx,int *wymy,int **,int *szarosci);
 int konturowanie(int *wymx,int *wymy,int **tab);
 int splot(int *wymx,int *wymy,int **tab);
 int normalizacja(int *wymx,int *wymy,int *tab,int *szarosci);


/*zmienna pomocnicza do okreslenia czy zostal wczytany jakis plik,
jesli nie to program odmowi wykonania opcji zapisu, oraz funkcji przetwarzania*/



/**********************************MAIN***************************/
/*Glowna czesc programu z menu uzytkownika i wywolaniami funkcji*/
int main()
{
  int plikwczytany=0;


  obrazy *a;/*inicjalizacja struktury*/
  a=(obrazy*)malloc(sizeof(obrazy));

    plikwczytany=czytaj(a);
    if(plikwczytany==0){
    printf("!!Nie wczytales zadnego pliku do pamieci!!\n");
    }

    konturowanie(&a->wymx,&a->wymy,a->tab);
    /*wywolanie funkcji zapisz*/
    zapisz(&a->wymx,&a->wymy,a->tab,&a->odcieni);

    return 0;
    }
/****************************CZYTAJ*********************************/

/*funkcja do odczytu pliku o podanej nazwie udostepniona na stornie kursu*/
int czytaj(obrazy *a) {
  char s[DL_LINII];
  int **wsk;
  int znak,koniec=0,i,j;/*zmienne pomocnicze*/
  FILE *p;/*uchwyt pliku*/
  char nazwa;
  char *rozszerzenie=".pgm";
  char nazwa_odczyt[100];
  printf("Wybrales odczyt,podaj nazwe pliku\n\n");
      printf("Podaj sama nazwe pliku bez jego rozszerzenia (rozszerzenie domyslne .pgm):\n");
      scanf("%s",&nazwa);
      /*dodajemy koncowke .pgm do nazwa_odczyt,ta sama koncowka co w funkcji zapisz*/

      strncat(&nazwa,rozszerzenie,sizeof nazwa_odczyt-1);
      puts(&nazwa);
      p=fopen(&nazwa,"r");

/*sprawdzenie czy podano prawidlowy uchwyt pliku */
  if (p==NULL) {
    fprintf(stderr,"Blad: Nie podano uchwytu do pliku\n");
    return(0);
  }
  if (fgets(s,DL_LINII,p)==NULL) koniec=1;
  /* Sprawdzenie "numeru magicznego - powinien być P2 */
  if ( (s[0]!='P') || (s[1]!='2') || koniec) {
    fprintf(stderr,"Blad: To nie jest plik PGM\n");
    return(0);
  }
  /* Pominiecie komentarzy */
  do {
    if ((znak=fgetc(p))=='#') {
      if (fgets(s,DL_LINII,p)==NULL) koniec=1;
    }  else {
      ungetc(znak,p);
    }
  } while (! koniec && znak=='#');
  /* Pobranie wymiarow i liczby odcieni szarosci */
  if (fscanf(p,"%d %d %d",&a->wymx,&a->wymy,&a->odcieni)!=3) {
    fprintf(stderr,"Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n");
    return(0);

  }

  wsk=(int**)malloc(a->wymx*sizeof(int*)); // tworzymy dynamicznie wiersze tablicy.

  for(i=0; i<a->wymx; i++){ //tworzymy dynamicznie kolumny tablicy.


       *(wsk+i)=(int*)malloc(a->wymy*sizeof(int));

  }
  /* Pobranie obrazu i zapisanie w tablicy obraz_pgm*/
  for (i=0;i<(a->wymx);i++) {
    for (j=0;j<(a->wymy);j++) {
    	fscanf(p,"%d",&(wsk[i][j]));
    }
  }
  a->tab=wsk;
  return 1;
}
/*******************************************************************************************************/

/***************************************ZAPISZ******************************************/
/*funkcja do zapisywania pliku pod zadana nazwa*/
void zapisz(int *wymx,int *wymy,int **tab,int *szarosci)
{
  char *rozszerzenie=".pgm";
    int i=0,j=0;
    FILE *plik2;
    char nazwazapis_pgm[100];
    /*if(pr==1){*szarosci=1;}*/

    /*wczytanie nazwy pliku bez dodawania rozszerzenia .pgm*/
    printf("Podaj nazwe pliku bez dopisywania rozszerzenia:\n");
    scanf("%s",nazwazapis_pgm);
              printf("Trwa zapisywanie \n");
    /*do wczytanej nawzwy dopisujemy koncowke rozszerzenia ".pgm"*/

    strncat(nazwazapis_pgm,rozszerzenie,sizeof nazwazapis_pgm-1);
    printf("\n");
    puts(nazwazapis_pgm);/*wyswietl nazwe zapisywanego pliku*/

    plik2=fopen(nazwazapis_pgm,"w"); /*tworzymy plik o podanej nazwie*/
    fprintf(plik2,"P2\n");/*dodajemy numer magiczny:) P2*/
    fprintf(plik2,"\n%d %d\n",*wymx,*wymy);/*wpisujemy wymiary tablicy zawierajacej obraz pgm*/
    fprintf(plik2,"%d\n",*szarosci);/*wpisujemy liczbe oznaczajaca maksymalna szarosc*/

    /*dwie petle for wypisuja wartosci z tablicy*/

    for (i=0;i<(*wymx);i++) {
        for (j=0;j<(*wymy);j++) {
        	fprintf(plik2,"%d ",(tab[i][j]));
        }
      }

    fclose(plik2);/*zamykamy plik*/
    printf("Obraz zostal zapisany do pliku\n");/*dajemy komunikat o poprawnie wykonanym poleceniu*/
}
/******************************KOTUROWANIE*******************************/
int konturowanie(int *wymx,int *wymy,int **tab)
{
   int i,j;/* i,j-zmienne pomocnicze do petli for*/

   for(i=0;i<*wymx-1;++i)
   {
	   for(j=0;j<*wymy-1;++j)
           {
		   tab[i][j]=fabs(tab[i+1][j]-tab[i][j])+fabs(tab[i][j]-tab[i][j+1]);
           }
   }
   wymx-=1;
     wymy-=1;
  printf("Obraz zostal pomyslnie przetworzony na negatyw\n");
   return 0;
}
/*************************************************************/

Program działał poprawnie na tablicy dwuwymiarowej statycznej. Więc teoretycznie i na dynamicznej powinien działać. Proszę o pomoc.
W załączniku dodałem wynik działania programu.

0

Masz bajzel nie z tej ziemi, do jednych funkcji przekazujesz całe a, w drugich fragmentami z int **tab, w trzecich int *tab. Zrób jednolicie inaczej będziesz miał kłopoty, ba już masz i właśnie przez to.

0

Całe a przekazuję tylko do funkcji zapisz ponieważ w niej zmieniam wartość adresu wskaźnika. Do pozostałych funkcji przesyłam już tylko wskaxniki na poszczególne części struktury. Do funkcji normalizacja jeszce nie doszedłem i z tąd tam *tab a nie **tab. Mógłbyś mi powiedzieć czy zadeklarowaną w ten sposób tablicą dynamiczną posługuje się w ten sam sposób co normalną statyczną? Spędziłem już nad szukaniem tego błędu pół dnia.

0

a przekazuję do funkcji odczyt pomyliłem.

0

Troche to ogarnołem żeby faktyczniej łatwiej można było to ogarnąć ale nadal problem jest z tablicą w funkcji konturowanie.

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>

/maksymalny rozmiar obrazka w pikselach
okresla MAX
/
#define MAX 512
#define DL_LINII 80

typedef struct obraz_pgm{
int wymx,wymy,odcieni;
int **tab;
}obrazy;

int czytaj(obrazy *a);
void zapisz(obrazy *a);
//void wyswietl();
//int negatyw(int *wymx,int *wymy,int **tab,int *szarosci);
//int progowanie(int *wymx,int *wymy,int **,int *szarosci);
int konturowanie(obrazy *a);
//int splot(int *wymx,int *wymy,int **tab);
//int normalizacja(int *wymx,int *wymy,int **tab,int *szarosci);

/zmienna pomocnicza do okreslenia czy zostal wczytany jakis plik,
jesli nie to program odmowi wykonania opcji zapisu, oraz funkcji przetwarzania
/

/*******MAIN/
/Glowna czesc programu z menu uzytkownika i wywolaniami funkcji/
int main()
{
int plikwczytany=0;

obrazy a;/inicjalizacja struktury/
a=(obrazy
)malloc(sizeof(obrazy));

plikwczytany=czytaj(a);
if(plikwczytany==0){
printf("!!Nie wczytales zadnego pliku do pamieci!!\n");
}

konturowanie(a);
/*wywolanie funkcji zapisz*/
zapisz(a);

return 0;
}

/CZYTAJ*****/

/funkcja do odczytu pliku o podanej nazwie udostepniona na stornie kursu/

/inicjalizacja zmiennych/
int czytaj(obrazy *a) {
char s[DL_LINII];
int **wsk;
int znak,koniec=0,i,j;/zmienne pomocnicze/
FILE *p;/uchwyt pliku/
char nazwa;
char *rozszerzenie=".pgm";
char nazwa_odczyt[100];

/*pobieranie danych */
printf("Wybrales odczyt,podaj nazwe pliku\n\n");
printf("Podaj sama nazwe pliku bez jego rozszerzenia (rozszerzenie domyslne .pgm):\n");
scanf("%s",&nazwa);
/dodajemy koncowke .pgm do nazwa_odczyt,ta sama koncowka co w funkcji zapisz/

  strncat(&nazwa,rozszerzenie,sizeof nazwa_odczyt-1);
  puts(&nazwa);
  p=fopen(&nazwa,"r");

/*sprawdzenie czy podano prawidlowy uchwyt pliku /
if (p==NULL) {
fprintf(stderr,"Blad: Nie podano uchwytu do pliku\n");
return(0);
}
if (fgets(s,DL_LINII,p)==NULL) koniec=1;
/
Sprawdzenie "numeru magicznego - powinien być P2 /
if ( (s[0]!='P') || (s[1]!='2') || koniec) {
fprintf(stderr,"Blad: To nie jest plik PGM\n");
return(0);
}
/
Pominiecie komentarzy /
do {
if ((znak=fgetc(p))=='#') {
if (fgets(s,DL_LINII,p)==NULL) koniec=1;
} else {
ungetc(znak,p);
}
} while (! koniec && znak=='#');
/
Pobranie wymiarow i liczby odcieni szarosci */
if (fscanf(p,"%d %d %d",&a->wymx,&a->wymy,&a->odcieni)!=3) {
fprintf(stderr,"Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n");
return(0);
}

/Dynamiczna tablica do przechowywania obrazu/
wsk=(int**)malloc(a->wymxsizeof(int)); // tworzymy dynamicznie wiersze tablicy.

for(i=0; i<a->wymx; i++){ //tworzymy dynamicznie kolumny tablicy.

   *(wsk+i)=(int*)malloc(a->wymy*sizeof(int));

}
/* Pobranie obrazu i zapisanie w tablicy obraz_pgm*/
for (i=0;i<(a->wymx);i++) {
for (j=0;j<(a->wymy);j++) {
fscanf(p,"%d",&(wsk[i][j]));
}
}
a->tab=wsk;
return 1;
}
/*******************************************************************************************************/

/ZAPISZ***/
/funkcja do zapisywania pliku pod zadana nazwa/
void zapisz(obrazy *a)
{
char *rozszerzenie=".pgm";
int i=0,j=0;
FILE *plik2;
char nazwazapis_pgm[100];
/*if(pr==1){szarosci=1;}/

/*wczytanie nazwy pliku bez dodawania rozszerzenia .pgm*/
printf("Podaj nazwe pliku bez dopisywania rozszerzenia:\n");
scanf("%s",nazwazapis_pgm);
          printf("Trwa zapisywanie \n");
/*do wczytanej nawzwy dopisujemy koncowke rozszerzenia ".pgm"*/
strncat(nazwazapis_pgm,rozszerzenie,sizeof nazwazapis_pgm-1);
printf("\n");
puts(nazwazapis_pgm);/*wyswietl nazwe zapisywanego pliku*/
plik2=fopen(nazwazapis_pgm,"w"); /*tworzymy plik o podanej nazwie*/
fprintf(plik2,"P2\n");/*dodajemy numer magiczny:) P2*/
fprintf(plik2,"\n%d %d\n",a->wymx,a->wymy);/*wpisujemy wymiary tablicy zawierajacej obraz pgm*/
fprintf(plik2,"%d\n",a->odcieni);/*wpisujemy liczbe oznaczajaca maksymalna szarosc*/



/*dwie petle for wypisuja wartosci z tablicy*/
for (i=0;i<(a->wymx);i++) {
    for (j=0;j<(a->wymy);j++) {
    	fprintf(plik2,"%d ",(a->tab[i][j]));
    }
  }

fclose(plik2);/*zamykamy plik*/
printf("Obraz zostal zapisany do pliku\n");/*dajemy komunikat o poprawnie wykonanym poleceniu*/

}
/KOTUROWANIE*/
int konturowanie(obrazy a)
{
int i,j;/
i,j-zmienne pomocnicze do petli for*/

for(i=0;i<a->wymx-1;++i)
{
for(j=0;j<a->wymy-1;++j)
{
a->tab[i][j]=fabs(a->tab[i+1][j]-a->tab[i][j])+fabs(a->tab[i][j]-a->tab[i][j+1]);
}
}
a->wymx-=1;
a->wymy-=1;
printf("Obraz zostal pomyslnie przetworzony na negatyw\n");
return 0;
}
/*************************************************************/

1 użytkowników online, w tym zalogowanych: 0, gości: 1