dec.c

a small program by Yuval Fisher that has gone a long way to revealing some of the secrets of fracal

/**************************************************************************/
/* Decode an image encoded with a quadtree partition based fractal scheme */
/*                                                                        */
/*       Copyright 1993,1994 Yuval Fisher. All rights reserved.           */
/*                                                                        */
/* Version 0.04 3/14/94                                                   */
/**************************************************************************/

/* The following belong in a encdec.h file, but nevermind...              */
/* -----------------------------------------------------------------------*/
#include <stdio.h>
#include <math.h>

#define DEBUG 0
#define GREY_LEVELS 255

#define IMAGE_TYPE unsigned char /* may be different in some applications */

/* The following #define allocates an hsize x vsize  matrix of type type */
#define matrix_allocate(matrix, hsize,vsize, TYPE) {\
    TYPE *imptr; \
    int _i; \
    matrix = (TYPE **)malloc(vsize*sizeof(TYPE *));\
    imptr = (TYPE*)malloc((long)hsize*(long)vsize*sizeof(TYPE));\
    if (imptr == NULL) \
        fatal("\nNo memory in matrix allocate."); \
    for (_i = 0; _i<vsize; ++_i, imptr += hsize) \
        matrix[_i] = imptr; \
 }

#define bound(a)   ((a) < 0.0 ? 0 : ((a)>255.0? 255 : a))

/* various function declarations to keep compiler warnings away           */
void fatal();
char *malloc();
char *strcpy(); 

/* ---------------------------------------------------------------------- */

IMAGE_TYPE **image,*imptr,**image1; 
                             /* The input image data and a dummy         */ 

double max_scale = 1.0;      /* maximum allowable grey level scale factor */

int    s_bits = 5,           /* number of bits used to store scale factor */
       o_bits = 7,           /* number of bits used to store offset       */
       hsize = -1,           /* The horizontal size of the input image    */
       vsize = -1,           /* The vertical size                         */
       scaledhsize,          /* hsize*scalefactor                         */
       scaledvsize,          /* vsize*scalefactor                         */
       size,                 /* largest square image that fits in image   */
       min_part = 3,         /* min and max _part determine a range of    */
       max_part = 4,         /* Range sizes from hsize>>min to hsize>>max */
       dom_step = 4,         /* Density of domains relative to size       */
       dom_step_type = 0,    /* Flag for dom_step a multiplier or divisor */
       dom_type = 0,         /* Method of generating domain pool 0,1,2..  */
       post_process = 1,     /* Flag for postprocessing.                  */
       num_iterations= 10,   /* Number of decoding iterations used.       */
       *no_h_domains,        /* Number of horizontal domains.             */
       *domain_hstep,        /* Domain density step size.                 */
       *domain_vstep,        /* Domain density step size.                 */
       *bits_needed,         /* Number of bits to encode domain position. */
       zero_ialpha,          /* the const ialpha when alpha = 0           */
       output_partition=0,   /* A flag for outputing the partition        */
       max_exponent;         /* The max power of 2 side of square image   */
                             /* that fits in our input image.             */

struct transformation_node {
       int rx,ry,            /* The range position and size in a trans.   */
              xsize, ysize,  
              rrx,rry,
              dx,dy;         /* The domain position.                      */
       int sym_op;           /* The symmetry operation used in the trans. */
       int depth;            /* The depth in the quadtree partition.      */
       double scale, offset; /* scalling and offset values.               */
       struct transformation_node *next;       /* The next trans. in list */
} transformations, *trans; 

FILE *input,*output,*other_input; 


/* fatal is for when there is a fatal error... print a message and exit */
void fatal(s)
char *s;
{
     printf("\n%s\n",s);
     exit(-1);
}

/* ************************************************************ */
/* unpack value using size bits read from fin.                  */
/* ************************************************************ */
long unpack(size, fin)
int size;
FILE *fin;
{
    int i;
    int value = 0;
    static int ptr = 1; /* how many bits are packed in sum so far */
    static int sum; 


    /* size == -2 means we initialize things */
    if (size == -2) {
        sum = fgetc(fin);
        sum <<= 1;
        return((long)0);
    }

    /* size == -1 means we want to peek at the next bit without */
    /* advancing the pointer */
    if (size == -1)
        return((long)((sum&256)>>8));

     for (i=0; i<size; ++i, ++ptr,  sum <<= 1) {
        if (sum & 256) value |= 1<<i;

         if (ptr == 8) {
            sum = getc(fin);
            ptr=0;
        }
     }
    return((long)value);
}

main(argc,argv)
int argc;
char **argv;
{
    /* Defaults are set initially */
    double         scalefactor = 1.0;           /* Scale factor for output */
    char           inputfilename[200];
    char           outputfilename[200];
    char           other_input_file[200];
    int            i,j, x_exponent, y_exponent;
    int            domain_size, no_domains;

 
    inputfilename[0] = 1;    /* We initially set the input to this and */
    outputfilename[0] = 1;   /* then check if the input/output names   */
    other_input_file[0] = 1; /* have been set below.                   */

    /* scan through the input line and read in the arguments */
    for (i=1; i<argc; ++i) 
       if (argv[i][0] != '-' ) 
            if (inputfilename[0] == 1)
                strcpy(inputfilename, argv[i]);
            else if (outputfilename[0] == 1)
                strcpy(outputfilename, argv[i]);
            else;
       else { /* we have a flag */
            if (strlen(argv[i]) == 1) break;
            switch(argv[i][1]) {
               case 'i': strcpy(other_input_file,argv[++i]); 
                         break;
               case 'n': num_iterations = atoi(argv[++i]);
                         break;
               case 'f': scalefactor = atof(argv[++i]);
                         break;
               case 'P': output_partition = 1;
                         break;
               case 'p': post_process = 0;
                         break;
               case 's': s_bits = atoi(argv[++i]);
                         break;
               case 'o': o_bits = atoi(argv[++i]);
                         break;
               case 'N': max_scale = atof(argv[++i]);
                         break;
               case '?':
               case 'H':
               default:
		   printf("\nUsage: dec -[options] [inputfile [outputfile]]");
		   printf("\nOptions are: (# = number), defaults show in ()");
		   printf("\n  -f # scale factor of output size. (%lf)", scalefactor);
		   printf("\n  -i file name. An initial image to iteration from.");
		   printf("\n  -n # no. of decoding iterations. (%d)", num_iterations);
		   printf("\n  -N # maximum allowed scaling. (%lf)",max_scale);
		   printf("\n  -s # number of scaling quantizing bits. (%d)",s_bits);
		   printf("\n  -o # number of offset quantizing bits. (%d)",o_bits);
		   printf("\n  -P   output the partition into the output file. (off)");
		   printf("\n  -p   supress artifact postprocessing. (off)");
           fatal(" ");
            }
       }

    if (inputfilename[0] == 1) strcpy(inputfilename, "lenna.trn");
    if (outputfilename[0] == 1) strcpy(outputfilename, "lenna.out");

    if ((input = fopen(inputfilename, "r")) == NULL)
        fatal("Can't open input file.");
        
    unpack(-2,input); /* initialize the unpacking routine */

	/* read the header data from the input file. This should probably */
    /* be put into one read which reads a structure with the info     */
    min_part = (int)unpack(4,input);
    max_part = (int)unpack(4,input);
    dom_step = (int)unpack(4,input);
    dom_step_type = (int)unpack(1,input);
    dom_type = (int)unpack(2,input);
    hsize = (int)unpack(12,input);
    vsize = (int)unpack(12,input);

    /* we now compute size */
    x_exponent = (int)floor(log((double)hsize)/log(2.0));
    y_exponent = (int)floor(log((double)vsize)/log(2.0));
   
    /* exponent is min of x_ and y_ exponent */
    max_exponent = (x_exponent > y_exponent ? y_exponent : x_exponent);
    /* size is the size of the largest square that fits in the image */
    /* It is used to compute the domain and range sizes.             */
    size =  1<<max_exponent; 

    /* This is the quantized value of zero scaling */
    zero_ialpha = 0.5 + (max_scale)/(2.0*max_scale)*(1<<s_bits);

    /* allocate memory for the output image. Allocating one chunck saves  */
    /* work and time later.                                              */
	scaledhsize = (int)(scalefactor*hsize);
	scaledvsize = (int)(scalefactor*vsize);
    matrix_allocate(image, scaledhsize,scaledvsize, IMAGE_TYPE);
    matrix_allocate(image1, scaledhsize, scaledvsize, IMAGE_TYPE);

    if (other_input_file[0] != 1) {
        other_input = fopen(other_input_file, "r");
        i = fread(image[0], sizeof(IMAGE_TYPE), 
				scaledhsize*scaledvsize, other_input);
        if (i < scaledhsize*scaledvsize) 
           fatal("Couldn't read input... not enough data.");
        else
            printf("\n%d pixels read from %s.\n", i,other_input_file);
        fclose(other_input);
    }
          
    /* since max_ and min_ part are variable, these must be allocated */
    i = max_part - min_part + 1;
    bits_needed = (int *)malloc(sizeof(int)*i);
    no_h_domains = (int *)malloc(sizeof(int)*i);
    domain_hstep = (int *)malloc(sizeof(int)*i);
    domain_vstep = (int *)malloc(sizeof(int)*i);
    
    /* compute bits needed to read each domain type */
    for (i=0; i <= max_part-min_part; ++i) {
       /* first compute how many domains there are horizontally */
       domain_size = size >> (min_part+i-1);
       if (dom_type == 2) 
             domain_hstep[i] = dom_step; 
       else if (dom_type == 1)
             if (dom_step_type ==1)
                domain_hstep[i] = (size >> (max_part - i-1))*dom_step;
             else 
                domain_hstep[i] = (size >> (max_part - i-1))/dom_step;
       else 
             if (dom_step_type ==1)
                domain_hstep[i] = domain_size*dom_step;
             else 
                domain_hstep[i] = domain_size/dom_step;

       no_h_domains[i] = 1+(hsize-domain_size)/domain_hstep[i];
       /* bits_needed[i][0] = ceil(log(no_domains)/log(2));  */

       /* now compute how many domains there are vertically */
       if (dom_type == 2) 
             domain_vstep[i] = dom_step; 
       else if (dom_type == 1)
             if (dom_step_type ==1)
             domain_vstep[i] = (size >> (max_part - i-1))*dom_step;
             else 
             domain_vstep[i] = (size >> (max_part - i-1))/dom_step;
       else 
             if (dom_step_type ==1)
                domain_vstep[i] = domain_size*dom_step;
             else 
                domain_vstep[i] = domain_size/dom_step;

       no_domains = 1+(vsize-domain_size)/domain_vstep[i];
       bits_needed[i] = ceil(log((double)no_domains*(double)no_h_domains[i])/
                           log(2.0)); 
     }

    if ((output = fopen(outputfilename, "w")) == NULL)
            fatal("Can't open output file.");

    /* Read in the transformation data */