code/mkCAvid/makeCAvid.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>


#define IMAGE_DIRECTORY "images.temp"
#define PGM_FILE_PATTERN "step_%i.pgm"
#define JPG_FILE_PATTERN "step_%i.jpg"
#define VIDEO_FILENAME "CA.avi"
#define CA_ITERATIONS 2000

typedef struct{
    int size;
    int*** grid;
} CA;


int removePGMs = 1;


void createVideo( int width , int height );
void simulate( CA* ca , int* rule );
void outputImages( CA* ca , int nimage );
int* getRule( char* file );
CA* getInitCA( char* file , int size );
void usage();
CA* createCA( int size );
void printInternalCA( CA* ca );
void printCA( CA* ca );
int step( CA* curr , CA* next , int* rule );
void toPGM( CA* ca , char* file );
int finished( CA* ca );


int main( int argc , char** argv ){
    // check the arguments validity
    if( argc != 4 && argc != 5 ){
        usage();
    }
    else if( argc == 5 ){
        removePGMs = 0;
    }

    
    // get the size
    printf( "getting size...\n" );fflush( stdout );
    int size = atoi( argv[1] );


    // the rule
    printf( "getting rule...\n" );fflush( stdout );
    int* rule = getRule( argv[2] );


    // the initial CA
    printf( "getting initial CA...\n" );fflush( stdout );
    CA* ca = getInitCA( argv[3] , size );
    //printInternalCA(ca);

    // get the current working directory and change to the images directory,
    // that we create here... mencoder apparently works better in the directory
    // in which the images are
    mkdir( IMAGE_DIRECTORY , 0777 );
    char cwd[256];
    if( getcwd(cwd,256) == NULL )
        printf( "couldn't get working directory" );
    chdir( strcat(strcat(cwd,"/"),IMAGE_DIRECTORY)  );

    
    // run the simulation
    printf( "simulating...\n" );fflush( stdout );
    simulate( ca , rule );


    // make the video
    printf( "creating video...\n" );fflush( stdout );
    createVideo( ca->size , ca->size );
 

    // free and return
    free( rule );
    free( ca );
    return 0;
}


void
simulate( CA* ca , int* rule ){
    // allocate
    void* temp;
    int nones, nimages = 100000;
    //printInternalCA(ca);
    CA* nextca = createCA( ca->size );

    // run the simulation
    while( nones != 0 && nones != ca->size*ca->size ){
        outputImages( ca , nimages++ );
        nones = step( ca , nextca , rule );
        temp = ca;
        ca = nextca;
        nextca = temp;
        if( nimages-100000 == CA_ITERATIONS )
            break;
    }
    outputImages( ca , nimages );

    // free and move back to old directory
    free( nextca );
}


void
createVideo( int width , int height ){
    // allocate
    char dimensions[256];
    sprintf( dimensions, "w=%i:h=%i:fps=4:type=jpg", width , height );
    char* mencoder_args[] = { "mencoder" , "mf://*.jpg" , "-mf" , dimensions
                            , "-ovc" , "lavc" , "-lavcopts"
                            , "vcodec=mpeg4:mbd=2:trell" , "-oac" , "copy"
                            , "-o" , VIDEO_FILENAME , NULL };

    // make the video
    if( !fork() ){
        if( !fork() ){
            execvp( "mencoder" , mencoder_args );
        }
        wait(NULL);
        execlp( "mv" , "mv" , VIDEO_FILENAME , ".." , NULL );
    }
    wait(NULL);
}


void
outputImages( CA* ca , int nimage ){
    // allocate
    char pgm[256];
    sprintf( pgm , PGM_FILE_PATTERN , nimage );
    char jpg[256];
    sprintf( jpg , JPG_FILE_PATTERN , nimage );

    // set the values
    toPGM( ca , pgm );
    if( !fork() ){
        if( !fork() ){
            execlp( "convert" , "convert" , pgm , jpg , NULL );
        }
        wait(NULL);
        if( removePGMs ){
            execlp( "rm" , "rm" , pgm , NULL );
        }
        else{
            exit(0);
        }
    }
}


int*
getRule( char* file ){
    // allocate
    int* rule = (int*) calloc( 512 , sizeof(int) );
    char rawrule[512];
    FILE* rawrule_fp;
    
    // get the data
    if( (rawrule_fp = fopen(file,"r")) == NULL )
        perror( "fopen of raw rule file failed\n" );
    if( fgets(rawrule,513,rawrule_fp) == NULL )
        perror( "getline of raw rule failed\n" );
    fclose( rawrule_fp );

    // make the rule
    int i;
    for( i=0 ; i<512 ; i++ ){
        rule[i] = rawrule[i] == '1';
    }

    // free and return
    return rule;
}


CA*
getInitCA( char* file , int size ){
    // allocate
    int length = size*size;
    char rawCA[length];
    CA* ca = createCA( size );
    FILE* rawCA_fp;

    // the data
    if( (rawCA_fp = fopen(file,"r")) == NULL )
        perror( "getInitCA(): fopen of rawCA file failed" );
    if( fgets(rawCA,length+1,rawCA_fp) == NULL )
        perror( "getInitCA(): getline of rawCA file failed" );
    fclose( rawCA_fp );

    // set the values in the grid
    int r, c;
    for( r=1 ; r<=size ; r++ ){
        for( c=1 ; c<=size ; c++ ){
            *ca->grid[r][c] = rawCA[size*(r-1)+(c-1)] == '1';
        }
    }

    // free and return
    return ca;
}


void
usage(){
    printf( "USAGE: mkvid SIZE RULE INITCA\n" );
    printf( "    The function requires 3 arguments, where SIZE is the \n" );
    printf( "    value of one of the sides of the CA, RULE is a file \n" );
    printf( "    containing one line of ones and zeros that is the rule \n" );
    printf( "    in question, and similarly, INITCA is a file that has \n" );
    printf( "    one line that is the CA with which to start.\n" );
    exit(0);
}


int
finished( CA* ca ){
    int r, c, sum = 0;
    for( r=1 ; r<=ca->size ; r++ ){
        for( c=1 ; c<=ca->size ; c++ ){
            sum += *ca->grid[r][c];
        }
    }

    return sum == 0 || sum == ca->size*ca->size;
}


CA*
createCA( int size ){
    // the easy allocation
    CA* ca = (CA*) malloc( sizeof(CA) );
    ca->size = size;

    // the innards
    int row, col;
    ca->grid = (int***) calloc( size+2 , sizeof(int**) );
    for( row = 0 ; row < size+2 ; row++ ){
        ca->grid[row] = (int**) calloc( size+2 , sizeof(int*) );
        for( col = 1 ; col <= size ; col++ ){
            ca->grid[row][col] = (int*) malloc( sizeof(int) );
        }
    }

    // the outtards
    int i;
    for( i=1 ; i<=size ; i++ ){
        ca->grid[i][0]      = ca->grid[i][size]; // left side wrap-around
        ca->grid[i][size+1] = ca->grid[i][1];    // right side wrap-around
        ca->grid[0][i]      = ca->grid[size][i]; // top wrap-around
        ca->grid[size+1][i] = ca->grid[1][i];    // bottom wrap-around
    }

    // the corners
    ca->grid[0][0]           = ca->grid[size][size];
    ca->grid[0][size+1]      = ca->grid[size][1];
    ca->grid[size+1][0]      = ca->grid[1][size];
    ca->grid[size+1][size+1] = ca->grid[1][1];

    return ca;
}


void
printInternalCA( CA* ca ){
    int r,c;
    for( r = 0 ; r < ca->size+2 ; r++ ){
        for( c = 0 ; c < ca->size+2 ; c++ ){
            printf( "%i " , *(ca->grid[r][c]) );
        }
        printf( "\n" );
    }
    printf( "\n" );
}


void
printCA( CA* ca ){
    int r,c;
    for( r = 1 ; r <= ca->size ; r++ ){
        for( c = 1 ; c <= ca->size ; c++ ){
            printf( "%i " , *(ca->grid[r][c]) );
        }
        printf( "\n" );
    }
    printf( "\n" );
}



int
step( CA* curr , CA* next , int* rules ){
    int r, c, rule, sum = 0;
    for( r = 1 ; r <= curr->size ; r++ ){
        for( c = 1 ; c <= curr->size ; c++ ){
            rule  =   1 * *curr->grid[r-1][c-1]
                  +   2 * *curr->grid[r-1][ c ]
                  +   4 * *curr->grid[r-1][c+1]
                  +   8 * *curr->grid[ r ][c-1]
                  +  16 * *curr->grid[ r ][ c ]
                  +  32 * *curr->grid[ r ][c+1]
                  +  64 * *curr->grid[r+1][c-1]
                  + 128 * *curr->grid[r+1][ c ]
                  + 256 * *curr->grid[r+1][c+1];
            *next->grid[r][c] = rules[rule];
            sum += rules[rule];
        }
    }
    next->size = curr->size;
    return sum;
}


void
toPGM( CA* ca , char* file ){
    FILE* fp = fopen( file , "w" );

    // header information
    fprintf( fp , "P2\n" );
    fprintf( fp , "%i %i\n" , ca->size , ca->size );
    fprintf( fp , "1\n" );

    // the image
    int r, c;
    for( r=1 ; r<=ca->size ; r++ ){
        for( c=1 ; c<=ca->size ; c++ ){
            fprintf( fp , "%i " , *ca->grid[r][c] );
        }
        fprintf( fp , "\n" );
    }

    fclose( fp );
}

---