Standard Przetwarzanie Obrazów 2 PWR Problem obrazki większe niż 512

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h> 
#define DL_LINII 80

/* Wczytywanie obrazu */
typedef struct {
    int wymx;
    int wymy;
    int ** obraz_pgm;
    float ** G, ** amp;
    int szarosci;
} rys, rys1;

int czytaj( FILE * p, rys * obraz ) {
    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 bya 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", &( obraz->wymx ), &( obraz->wymy ), &( obraz->szarosci ) ) != 3 ) {
        fprintf( stderr, "Blad: Brak wymiarow obrazu lub liczby stopni szarosci\n" );
        return( 0 );
    }
    obraz->obraz_pgm =( int ** ) malloc( obraz->wymy * obraz->wymx * sizeof( int * ) );
    for( i = 0; i < obraz->wymy; ++i )
    { obraz->obraz_pgm[ i ] =( int * ) malloc( obraz->wymx * obraz->wymy * sizeof( int ) ); }
    obraz->G =( float ** ) malloc( obraz->wymy * sizeof( float * ) );
    for( i = 0; i < obraz->wymy; ++i )
    { obraz->G[ i ] =( float * ) malloc( obraz->wymx * sizeof( float ) ); }
    obraz->amp =( float ** ) malloc( obraz->wymy * sizeof( float * ) );
    for( i = 0; i < obraz->wymy; ++i )
    { obraz->amp[ i ] =( float * ) malloc( obraz->wymx * sizeof( float ) ); }
    /* Pobranie obrazu i zapisanie w tablicy obraz_pgm*/
    for( j = 0; j <( obraz->wymy ); j++ ) {
        for( i = 0; i <( obraz->wymx ); i++ ) {
            if( fscanf( p, "%d", &( obraz->obraz_pgm[ i ][ j ] ) ) != 1 ) {
                fprintf( stderr, "Blad: Niewlasciwe wymiary obrazu\n" );
                return( 0 );
            }
        }
    }
    return obraz->wymx * obraz->wymy;
}
/* Zapisywanie obrazu */
int zapisz( FILE * p, rys * obraz ) {
    int j, i;
   
    /*sprawdzenie czy podano prawid3owy uchwyt pliku */
    if( p == NULL ) {
        fprintf( stderr, "Blad: Nie podano uchwytu do pliku\n" );
        return( 0 );
    }
    fprintf( p, "P2 \n" );
    fprintf( p, "#negatyw \n" );
    fprintf( p, "%d %d %d \n",( obraz->wymx ),( obraz->wymy ),( obraz->szarosci ) );
    for( j = 0; j < obraz->wymy; j++ ) {
        for( i = 0; i < obraz->wymx; i++ ) {
            fprintf( p, "%d ", obraz->obraz_pgm[ i ][ j ] );
           
        }
    }
    fclose( p );
    return obraz->wymx * obraz->wymy;
}
/*funkcja negatyw*/
void negatyw( rys * obraz ) {
    int i, j;
    for( j = 0; j < obraz->wymy; j++ ) {
        for( i = 0; i < obraz->wymx; i++ ) {
            ( obraz->obraz_pgm[ i ][ j ] ) =( obraz->szarosci ) -( obraz->obraz_pgm[ i ][ j ] );
        }
    }
}
void gamas( rys * obraz, int a ) {
    int i, j;
    float gah;
    gah =( float ) obraz->szarosci;
    float c, b, d;
    b =( float ) a;
    for( j = 0; j < obraz->wymy; j++ ) {
        for( i = 0; i < obraz->wymx; i++ ) {
            c =( float ) obraz->obraz_pgm[ i ][ j ];
            d =( pow( c / gah, 1 / b ) ) * gah;
            obraz->obraz_pgm[ i ][ j ] =( int ) d; } } }
void konturowanie( rys * obraz, int a ) {
    int i, j, k, m, ws, pn, zc, pl;
    switch( a )
    {
    case 2:
        {
            zc = 1; ws = 1; pl = 0; pn = 0;
            for( j = 0; j < obraz->wymy; j++ ) {
                for( i = 1; i < obraz->wymx - 1; i++ ) {
                    obraz->G[ i ][ j ] =( float )( obraz->obraz_pgm[ i - 1 ][ j ] + obraz->obraz_pgm[ i ][ j ] + obraz->obraz_pgm[ i + 1 ][ j ] ) / 3;
                }
            }
        } break;
    case 1:
        {
            zc = 0; ws = 1; pl = 1; pn = 0;
            for( j = 0; j < obraz->wymy - 1; j++ ) {
                for( i = 0; i < obraz->wymx - 1; i++ ) {
                    obraz->G[ i ][ j ] =( float )( abs( obraz->obraz_pgm[ i + 1 ][ j ] - obraz->obraz_pgm[ i ][ j ] ) + abs( obraz->obraz_pgm[ i ][ j + 1 ] - obraz->obraz_pgm[ i ][ j ] ) );
                }
            }
        } break;
    case 3:
        {
            zc = 0; ws = 0; pl = 1; pn = 1;
            for( j = 1; j < obraz->wymy - 1; j++ ) {
                for( i = 0; i < obraz->wymx; i++ ) {
                    obraz->G[ i ][ j ] =( float )( obraz->obraz_pgm[ i ][ j - 1 ] + obraz->obraz_pgm[ i ][ j ] + obraz->obraz_pgm[ i ][ j + 1 ] ) / 3;
                }
            }
        } break;
    }
    for( k = 0; k < obraz->wymy - 1; k++ ) {
        for( m = 0; m < obraz->wymx - 1; m++ ) {
            obraz->obraz_pgm[ m ][ k ] =( int ) obraz->G[ m ][ k ];
        }
    }
    if( ws == 1 ) {
        for( k = pn; k < obraz->wymy - pl; k++ )
        {
            m = obraz->wymx - 1;
            obraz->obraz_pgm[ m ][ k ] =( int ) obraz->G[ m - 1 ][ k ];
        } }
    if( zc == 1 ) {
        for( k = pn; k < obraz->wymy - pl; k++ )
        {
            m = 0;
            obraz->obraz_pgm[ m ][ k ] =( int ) obraz->G[ m + 1 ][ k ];
        } }
    if( pl == 1 ) {
        for( m = zc; m < obraz->wymx - ws; m++ )
        {
            k = obraz->wymy - 1;
            obraz->obraz_pgm[ m ][ k ] =( int ) obraz->G[ m ][ k - 1 ];
        } }
    if( pn == 1 ) { for( m = zc; m < obraz->wymx - ws; m++ )
        {
            k = 0;
            obraz->obraz_pgm[ m ][ k ] =( int ) obraz->G[ m ][ k + 1 ];
        } }
    if( ws == 1 && pl == 1 ) {
        obraz->obraz_pgm[ obraz->wymx - 1 ][ obraz->wymy - 1 ] =( int ) obraz->G[ obraz->wymx - 2 ][ obraz->wymy - 2 ]; } }
/*funkcja Progowanie*/
void progowanie( rys * obraz, int prog ) {
    int i, j;
    for( j = 0; j < obraz->wymy; j++ ) {
        for( i = 0; i < obraz->wymx; i++ ) {
            if( obraz->obraz_pgm[ i ][ j ] <= prog ) obraz->obraz_pgm[ i ][ j ] = 0;
            else obraz->obraz_pgm[ i ][ j ] = obraz->szarosci;
           
        }
    }
}
int progowaniea( rys * obraz, int prog ) {
    int i, j;
    for( j = 0; j < obraz->wymy; j++ ) {
        for( i = 0; i < obraz->wymx; i++ ) {
            if( obraz->obraz_pgm[ i ][ j ] <= prog ) obraz->obraz_pgm[ i ][ j ] = 0;
           
        } } }

void progowanieb( rys * obraz, int prog ) {
    int i, j;
    for( j = 0; j < obraz->wymy; j++ ) {
        for( i = 0; i < obraz->wymx; i++ ) {
            if( obraz->obraz_pgm[ i ][ j ] > prog ) obraz->obraz_pgm[ i ][ j ] = obraz->szarosci;
           
        } } }
void poziomy( rys * obraz, int biel, int czern ) {
    int i, j, k, m;
    float a, b, c, d;
    b =( float ) obraz->szarosci;
    c =( float ) czern;
    d =( float ) biel;
    for( j = 0; j < obraz->wymy; j++ ) {
        for( i = 0; i < obraz->wymx; i++ ) {
            a =( float ) obraz->obraz_pgm[ i ][ j ];
            if( obraz->obraz_pgm[ i ][ j ] > czern && obraz->obraz_pgm[ i ][ j ] < biel ) obraz->G[ i ][ j ] =( a - c ) * b /( d - c );
           
            if( obraz->obraz_pgm[ i ][ j ] <= czern ) { obraz->G[ i ][ j ] = 0; }
            if( obraz->obraz_pgm[ i ][ j ] >= biel ) { obraz->G[ i ][ j ] = b; }
        }
    }
    for( m = 0; m < obraz->wymy; m++ ) {
        for( k = 0; k < obraz->wymx; k++ ) {
            obraz->obraz_pgm[ k ][ m ] =( int ) obraz->G[ k ][ m ]; } }
}
void global( rys * obraz ) {
    int i, j;
    int minimum, maximum;
    minimum = obraz->szarosci;
    maximum = 0;
    for( i = 0; i < obraz->wymx; i++ ) {
        for( j = 0; j < obraz->wymy; j++ ) {
            if( obraz->obraz_pgm[ i ][ j ] < minimum ) minimum = obraz->obraz_pgm[ i ][ j ];
           
            if( obraz->obraz_pgm[ i ][ j ] > maximum ) maximum = obraz->obraz_pgm[ i ][ j ];
           
        } }
    for( i = 0; i < obraz->wymx; i++ ) { for( j = 0; j < obraz->wymy; j++ ) {
            obraz->obraz_pgm[ i ][ j ] =( obraz->obraz_pgm[ i ][ j ] - minimum ) * obraz->szarosci /( maximum - minimum ); } } }

void matryca( int w[ 9 ], rys * obraz ) {
    /*PRE: Jest to matryca filtracji splotu */
    int i, j; /*zmienne steruj�ce p�tl�*/
    float minimum, maximum; /*zmienne przechowuj�ce maksymaln� i minimaln� warto�� piksela
                    na potrzeby normalizacji */
    minimum = 0; /*W odróżniieniu do poprzedniej funkcji lepiej rozpoczac od wyzej wymienionych wartosci niz od minimum=szarosci*/
    maximum = obraz->szarosci; /*tymczasowa tablica w kt�rej b�dzie przechowywany zmieniony obraz*/
    for( i = 0; i < obraz->wymx; i++ ) {
        for( j = 0; j < obraz->wymy; j++ ) {
            obraz->amp[ i ][ j ] =( float ) obraz->obraz_pgm[ i ][ j ]; } }
    for( i = 1; i < obraz->wymx - 1; i++ ) {
        for( j = 1; j < obraz->wymy - 1; j++ ) {
            /*wykonywanie operacji filtracji po dodaniu abs na poczatku operacji mozemy uzyskac efekt przyblizony do zwyklego konturowania jak w przypadku case   itp*/
            obraz->G[ i ][ j ] = /*abs(*/ obraz->amp[ i - 1 ][ j - 1 ] * w[ 0 ] + obraz->amp[ i - 1 ][ j ] * w[ 1 ] + obraz->amp[ i - 1 ][ j + 1 ] * w[ 2 ] +
            obraz->amp[ i ][ j - 1 ] * w[ 3 ] + obraz->amp[ i ][ j ] * w[ 4 ] + obraz->amp[ i ][ j + 1 ] * w[ 5 ] +
            obraz->amp[ i + 1 ][ j - 1 ] * w[ 6 ] + obraz->amp[ i + 1 ][ j ] * w[ 7 ] + obraz->amp[ i + 1 ][ j + 1 ] * w[ 8 ] /*)*/;
            /*wykrywanie minimum i maximum*/
            if( obraz->G[ i ][ j ] < minimum ) { minimum = obraz->G[ i ][ j ]; }
            if( obraz->G[ i ][ j ] > maximum ) { maximum = obraz->G[ i ][ j ]; }
        }
    }
    for( i = 1; i <( obraz->wymx - 1 ); i++ ) {
        for( j = 1; j <( obraz->wymy - 1 ); j++ ) {
            obraz->G[ i ][ j ] =( obraz->G[ i ][ j ] - minimum ) * obraz->szarosci /( maximum - minimum );
            obraz->obraz_pgm[ i ][ j ] =( int ) obraz->G[ i ][ j ];
        }
    }
    for( i = 1; i < obraz->wymx - 1; i++ ) {
        obraz->obraz_pgm[ i ][ 0 ] =( int ) obraz->G[ i ][ 1 ];
        obraz->obraz_pgm[ i ][ obraz->wymy - 1 ] =( int ) obraz->G[ i ][ obraz->wymy - 2 ];
    }
    for( j = 1; j < obraz->wymy - 1; j++ ) {
        obraz->obraz_pgm[ 0 ][ j ] =( int ) obraz->G[ 1 ][ j ];
        obraz->obraz_pgm[ obraz->wymx - 1 ][ j ] =( int ) obraz->G[ obraz->wymx - 2 ][ j ];
    }
    obraz->obraz_pgm[ 0 ][ 0 ] =( int ) obraz->G[ 1 ][ 1 ];
    obraz->obraz_pgm[ obraz->wymx - 1 ][ obraz->wymy - 1 ] =( int ) obraz->G[ obraz->wymx - 2 ][ obraz->wymy - 2 ];
    obraz->obraz_pgm[ 0 ][ obraz->wymy - 1 ] =( int ) obraz->G[ 1 ][ obraz->wymy - 2 ];
    obraz->obraz_pgm[ obraz->wymx - 1 ][ 0 ] =( int ) obraz->G[ obraz->wymx - 2 ][ 1 ];
}
void wyswietl( char * n_pliku ) {
    /* Wyswietlenie obrazu o zadanej nazwie
         za pomoca programu "display"   */
    char polecenie[ 1024 ];
    strcpy( polecenie, "display " );
    strcat( polecenie, n_pliku );
    strcat( polecenie, " &" );
    printf( "%s\n", polecenie );
    system( polecenie );
}
int main()
{
   
    int beta;
    printf( "***************************************\n" );
    printf( "*             MENU                    *\n" );
    printf( "*                                     *\n" );
    printf( "*  1. Wczytaj                         *\n" );
    printf( "*  2. Zapisz                          *\n" );
    printf( "*  3. Negatyw                         *\n" );
    printf( "*  4. Progowanie                      *\n" );
    printf( "*  5. Polprogowanie czerni            *\n" );
    printf( "*  6. Polprogowanie bieli             *\n" );
    printf( "*  7. Konturowanie                    *\n" );
    printf( "*  8. Filtr usredniajacy              *\n" );
    printf( "*  9. Filtr usredniajacy wzmocniony   *\n" );
    printf( "*  10. Gradient Robertsa              *\n" );
    printf( "*  11. Pozioma maska Prewitta         *\n" );
    printf( "*  12. Maska Sobela                   *\n" );
    printf( "*  13. Maska wykrywajaca narozniki    *\n" );
    printf( "* 14. Laplasjan 1                     *\n" );
    printf( "* 15. Laplasjan 2                     *\n" );
    printf( "* 16. Laplasjan 3                     *\n" );
    printf( "* 17. Prog Progowania                 *\n" );
    printf( "* 18. Wlasna matryca splotu           *\n" );
    printf( "* 19. Konturowanie splot              *\n" );
    printf( "* 20. Rozmywanie poziome              *\n" );
    printf( "* 21. Rozmywanie pionowe              *\n" );
    printf( "* 22. Korekcja gamma                  *\n" );
    printf( "* 23. Zmiana poziomow                 *\n" );
    printf( "* 24. Zmiana globalna                 *\n" );
    printf( "* 99. Wyjscie                         *\n" );
    printf( "***************************************\n" );
   
    printf( "Podaj numer menu\n" );
    int a;
    FILE * plik;
    char nazwa[ 500 ];
    FILE * plik1;
    char nazwa1[ 500 ];
    rys * obraz;
    obraz =( rys * ) malloc( sizeof( rys ) );
    do {
       
        scanf( "%d", & beta );
       
       
        switch( beta )
        {
        case 1:
            {
                printf( "Podaj nazwe pliku do wczytania:\n" );
                scanf( "%s", nazwa );
                plik = fopen( nazwa, "r" );
               
                czytaj( plik, obraz );
            }
            break;
        case 2:
            {
                printf( "Podaj nazwe pliku do zapisania:\n" );
                scanf( "%s", nazwa1 );
                plik1 = fopen( nazwa1, "w+" );
                zapisz( plik1, obraz );
            } break;
        case 3:
            {
                negatyw( obraz );
            } break;
        case 4:
            {
                progowanie( obraz, a );
            } break;
        case 5:
            {
                progowaniea( obraz, a );
            } break;
        case 6:
            {
                progowanieb( obraz, a );
            } break;
        case 7:
            {
                konturowanie( obraz, 1 );
            } break;
        case 8:
            {
                int w[ 9 ] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
                matryca( w, obraz );
            } break;
        case 9:
            { int w[ 9 ] = { 1, 1, 1, 1, 2, 1, 1, 1, 1 };
                matryca( w, obraz );
            } break;
        case 10:
            { int w[ 9 ] = { 0, 0, 0, - 1, 0, 0, 0, 1, 0 };
                matryca( w, obraz );
            } break;
        case 11:
            { int w[ 9 ] = { - 1, - 1, - 1, 0, 0, 0, 1, 1, 1 };
                matryca( w, obraz );
            } break;
        case 12:
            { int w[ 9 ] = { - 1, - 2, - 1, 0, 0, 0, 1, 2, 1 };
                matryca( w, obraz );
            } break;
        case 13:
            { int w[ 9 ] = { 1, 1, 1, - 1, - 2, 1, - 1, - 1, 1 };
                matryca( w, obraz );
            } break;
        case 14:
            { int w[ 9 ] = { 0, - 1, 0, - 1, 4, - 1, 0, - 1, 0 };
                matryca( w, obraz );
            } break;
        case 15:
            { int w[ 9 ] = { - 1, - 1, - 1, - 1, 8, - 1, - 1, - 1, - 1 };
                matryca( w, obraz );
            } break;
        case 16:
            { int w[ 9 ] = { 1, - 2, 1, - 2, 4, - 2, 1, - 2, 1 };
                matryca( w, obraz );
            } break;
        case 17:
            {
                printf( "Podaj poziom progowania z liczb pomiedzy 0, a 255\n" );
                scanf( "%d", & a );
                if( a != 0 && beta == 17 )
                     printf( "Podany prog wynosi tyle %d\n", a );
               
            } break;
        case 18:
            { int w[ 9 ] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                int i;
                printf( "Podaj wlasny splot sk�adaj�cy sie z 9 cyfr, najlepiej mniejszych od 10" );
                for( i = 0; i < 9; i++ )
                {
                    scanf( "%d", & w[ i ] );
                    if( w[ i ] > 10 || w[ i ] <- 10 )
                    { w[ i ] = 0, i--; }
                }
                matryca( w, obraz );
            } break;
        case 19:
            { int w[ 9 ] = { 0, 0, 0, 0, - 2, 1, 0, 1, 0 };
                matryca( w, obraz );
            } break;
        case 20:
            {
                konturowanie( obraz, 2 );
            } break;
        case 21:
            {
                konturowanie( obraz, 3 );
            } break;
        case 22:
            { int rozm;
                printf( "Podaj parametr gamma\n" );
                scanf( "%d", & rozm ); gamas( obraz, rozm );
            } break;
        case 23:
            { int czern, biel, a;
                a = 1;
                switch( a ) {
                case 1: {
                        { do {
                               
                                printf( "Podaj progi wartosc czern musi byc mniejsza od biel i obie musza sie znajdowac od 0 do 255\n" );
                                printf( "podaj wartosc czerni\n" );
                                scanf( "%d", & czern );
                                printf( "podaj wartosc bieli\n" );
                                scanf( "%d", & biel ); } while( czern > biel ); } }
                case 2: { poziomy( obraz, czern, biel );
                    } break; } }
        case 24:
            {
                global( obraz );
            } break;
           
        case 99: break;
        default:;
        }
    } while( beta != 99 );
   
}