#include <stdio.h>
#include <math.h>
#include "rle.h"

Include dependency graph for fant.c:

Data Structures
struct	point

Macros
#define	MAXCHAN 256

#define	PI 3.14159265358979323846

#define	H_PASS 0

#define	V_PASS 1

#define	FRAC(x) ((x) - ((int) floor(x)))

#define	ROUND(x) ((int)((x) + 0.5))

#define	DEG(x) ((x) * PI / 180.0)

#define	EPSILON .0001

#define	MIN(x, y) ((x) < (y) ? (x) : (y))

#define	MAX(x, y) ((x) > (y) ? (x) : (y))

#define	SHIFT 16

#define	SCALE (1 << SHIFT)

Typedefs
typedef struct point	point

Functions
void *	mallocNd ()

void	interp_row ()

void	fast_interp_row ()

void	general_interp_row ()

void	getraster ()

void	xform_image ()

void	putraster ()

void	clear_raster ()

void	xform_points ()

void	main (int argc, argv)

void	xform_image (point *p, double blur)

void	xform_points (point *p, double xscale, double yscale, double angle, double xtrans, double ytrans)

void	interp_row (double sizefac, double blur, int inmin, double real_outpos, int inmax, int outmax)

void	general_interp_row (rle_pixel pin, int inlen, rle_pixel pout, int stride, int xmin, int xmax, double pos, double radius, double delta)

void	fast_interp_row (rle_pixel pin, int inlen, rle_pixel pout, int stride, int xmin, int xmax, double pos, double delta)

void	getraster (rle_pixel ***ras_ptrs)

void	putraster (rle_pixel ***ras_ptrs)

void	clear_raster (rle_pixel ***ras_ptr)

Variables
rle_pixel ***	rast

rle_pixel *	bufin

int	const_ind

int	cur_chan

int	pass

rle_hdr	in_hdr

rle_hdr	out_hdr

int	nchan

int	array_width

int	outlinewidth

int	array_lines

int	verboseflag

int	originflag

int	X_origin

int	Y_origin

int	vpassonlyflag

Macro Definition Documentation

#define DEG ( x ) ((x) * PI / 180.0)

Definition at line 79 of file fant.c.

#define EPSILON .0001

Definition at line 80 of file fant.c.

#define FRAC ( x ) ((x) - ((int) floor(x)))

Definition at line 77 of file fant.c.

#define H_PASS 0

Definition at line 72 of file fant.c.

#define MAX	(	x,
		y
	)	((x) > (y) ? (x) : (y))

Definition at line 83 of file fant.c.

#define MAXCHAN 256

Definition at line 65 of file fant.c.

#define MIN	(	x,
		y
	)	((x) < (y) ? (x) : (y))

Definition at line 82 of file fant.c.

#define PI 3.14159265358979323846

Definition at line 68 of file fant.c.

#define ROUND ( x ) ((int)((x) + 0.5))

Definition at line 78 of file fant.c.

#define SCALE (1 << SHIFT)

Definition at line 469 of file fant.c.

#define SHIFT 16

Definition at line 468 of file fant.c.

#define V_PASS 1

Definition at line 73 of file fant.c.

Typedef Documentation

typedef struct point point

Function Documentation

void clear_raster ( )

void clear_raster ( rle_pixel *** ras_ptr )

Definition at line 747 of file fant.c.

 {
     bzero( &(ras_ptr[cur_chan][0][0]), array_width * array_lines );
 }

void fast_interp_row ( )

void fast_interp_row	(	rle_pixel *	pin,
		int	inlen,
		rle_pixel *	pout,
		int	stride,
		int	xmin,
		int	xmax,
		double	pos,
		double	delta
	)

Definition at line 629 of file fant.c.

 {
     register long pv, nv, inseg;
     register long rdelta;
     register rle_pixel *pend;
     long rpos;
     int i;
     
     rpos = (long) (pos*SCALE + 0.5); /* fixed point forms */
     rdelta = (long) (delta*SCALE + 0.5);
     
     /* find starting point in input array */
     rpos -= SCALE/2; 
     i  = (rpos  >> SHIFT); 
     inseg = (rpos - (i << SHIFT));
     if (inseg < 0)  {  i++;   inseg += SCALE;   }
     if (i > 0)  pin+= i;
 
     /* Lookup initial pixel values */
     if (i < 0 || i >= inlen)  pv = 0;  else { pv = *pin; pin++; }
     i++;
     if (i < 0 || i >= inlen)  nv = 0;  else { nv = *pin; pin++; }
 
     /* Loop over output pixels */
     pend = pout + (xmax-xmin)*stride + 1;
     while (pout < pend)
     {
     /* Simple linear interpolation */
     *pout = (pv*(SCALE-inseg) + nv*inseg + SCALE/2) >> SHIFT;
     
     /* advance to next input pixel (in src coordinates) */
     inseg += rdelta;
     if (inseg > SCALE)
     {
         pv = nv;
         i++;
         if (i < 0 || i >= inlen)  
           nv = 0;  
         else 
           { nv = *pin; pin++; }
         inseg -= SCALE;
     }
     pout += stride;
     }
 }

void general_interp_row ( )

void general_interp_row	(	rle_pixel *	pin,
		int	inlen,
		rle_pixel *	pout,
		int	stride,
		int	xmin,
		int	xmax,
		double	pos,
		double	radius,
		double	delta
	)

Definition at line 562 of file fant.c.

 {
     register long pxl, fpos, weight, sum, accum;
     register int i, i0, i1, x;
     long rpos, rradius, rdelta ;
     
 
     /* This is the general case.  We walk through all the output points.
      * for each output point we map back into the input coordinate system
      * to figure out which pixels affect it.  We sum over all input pixels
      * that overlap the filter support.  A triangle filter is hardwired at
      * present for speed.
      */
     
     rpos = (long) (pos*SCALE + 0.5); /* fixed point forms */
     rradius = (long) (radius*SCALE + 0.5);
     rdelta = (long) (delta*SCALE + 0.5);
 
     
     /* For each output pixel */
     for (x=xmin; x<=xmax; x++)
     {  
     /* find bounds in input array */
     
     i0 = (rpos - rradius + SCALE/2) >>SHIFT; /* floor(pos -radius +0.5); */
     i1 = (rpos + rradius - SCALE/2) >>SHIFT; /* floor(pos +radius -0.5); */
     
     /* sum over each input pixel which effects this output pixel
          * weights are taken from a triangle filter of width radius.
          */
     sum = accum = 0;
     for(i=i0; i<=i1; i++)
     {
         /* lookup input pixel (zero's at boundaries) */
         pxl = (i < 0 || i >= inlen) ? 0 :  pin[i];
 
         /* map to filter coordinate system */
         fpos = (i<<SHIFT) + SCALE/2 - rpos; /* fabs(i+0.5-pos); */
         if (fpos < 0) fpos = -fpos;
 
         weight = rradius - fpos;
         accum += pxl * weight;
         sum += weight;
     }
     if (sum > 0) 
       *pout = accum/sum;
     
     /* advance to next input pixel (in src coordinates) */
     rpos +=  rdelta;        /* pos += delta */
     pout += stride;
     }
 }

void getraster ( )

void getraster ( rle_pixel *** ras_ptrs )

Definition at line 688 of file fant.c.

 {
     int i, chan;
     rle_pixel *ptrs[MAXCHAN];
     rle_pixel *rows[MAXCHAN];   /* Pointers for getrow/putrow */
     
     for ( chan = 0; chan < nchan; chan++ )
       ptrs[chan] = ras_ptrs[chan][0];
     
     for (i = in_hdr.ymin; i <= in_hdr.ymax; i++)
     {
     for ( chan = 0; chan < nchan; chan++ )
       rows[chan] = ptrs[chan];
     rle_getrow( &in_hdr, &(rows[in_hdr.alpha]) );
     
     
     /* Bump pointers */
     for ( chan = 0; chan < nchan; chan++ )
       ptrs[chan] += array_width;
     }
 }

void interp_row ( )

void interp_row	(	double	sizefac,
		double	blur,
		int	inmin,
		double	real_outpos,
		int	inmax,
		int	outmax
	)

Definition at line 472 of file fant.c.

 {
     double pos,         /* input coordinate of first output point */
            delta,       /* delta (in input coords) between output points */
            radius;      /* filter radius (in input coords) */
     int    xmin, xmax,          /* index bounds in output array */
            stride,      /* stride between output array positions */
            inlen;       /* length of input buffer; */
     register rle_pixel *pin, *pout, *pend, *p;
 
 
     delta  = 1/sizefac;
 
     radius = (sizefac > 1.0) ? 1.0 : delta; /* filter radius */
     radius *= blur;
     /* clamp the filter radius on the bottom end to make sure we get complete
        coverage.  */
     if (radius < 0.5+EPSILON) radius = 0.5+EPSILON; 
 
 
     /*
      *  Find the bounds in the output array
      */
                 /* min in output coords */
     xmin = (int) floor((-radius)*sizefac + real_outpos);
     if (xmin < 0)      xmin = 0;
     if (xmin > outmax) xmin = outmax;
     xmax = floor(inmax - inmin + 1.0 + radius); /* max in input coordinates */
     xmax = floor((xmax + 0.5)*sizefac + real_outpos); /* -> output coords */
     if (xmax < 0)      xmax = 0;
     if (xmax > outmax) xmax = outmax;
     
     inlen = inmax - inmin + 1;
     if (pass == V_PASS)
     {
     pin  = rast[cur_chan][inmin]+const_ind;
     pout = rast[cur_chan][0]+const_ind;
     stride = array_width;
     }
     else
     {
     pin  = rast[cur_chan][const_ind] + inmin;
     pout = rast[cur_chan][const_ind] + 0;
     stride = 1;
     }
     
 
     /*  
      *  Copy the input into a row buffer. This saves us some memory so
      *  we don't need a separate output array for the whole image.
      */
     p = bufin;
     pend = bufin + inlen;
     while (p < pend)
       {
     *p++ = *pin;
     pin += stride;
       }
     pin = bufin;
     
     /* zero out the part of the output array we aren't going to touch */
     p = pout;
     pend = p + stride*xmin;
     while (p < pend)
       { *p = 0; p += stride; }
     p = pout + stride*(xmax+1);
     pend = pout + stride*(outmax+1);
     while (p < pend)
       { *p = 0; p += stride; }
     pout += stride*xmin;
 
     /* input coordinate of first output pixel center */
     pos = (xmin + 0.5 - real_outpos)*delta;
     
     if (radius != 1.0)
       general_interp_row(pin,inlen,pout,stride,xmin,xmax,pos,radius,delta);
     else
       fast_interp_row(pin,inlen,pout,stride,xmin,xmax, pos,delta);
 }

void main	(	int	argc,
		argv
	)

Definition at line 120 of file fant.c.

 {
     char     *infilename = NULL,
                  *out_fname = NULL;
     int      oflag = 0;
     int      rle_cnt;
     int      scaleflag = 0,
                  sizeflag = 0,
              centerflag = 0,
                  angleflag = 0,
              translateflag = 0,
                  blurflag = 0;
     double   xscale = 1.0,
                  yscale = 1.0,
                  xsize,
                  ysize,
                  blur = 1.0,
              angle = 0.0,
              xtrans = 0.0,
              ytrans = 0.0;
     FILE     *outfile = stdout;
     int          rle_err;
     int          i, i1, i2;
     point        p[5];      /* "5" so we can use 1-4 indices Fant does. */ 
     int          dims[3];
    
     
     X_origin = 0;
     Y_origin = 0;
     verboseflag = 0;
     originflag = 0;
     vpassonlyflag = 0;
     
     if (scanargs( argc, argv, 
 "% s%-xscale!Fyscale!F S%-xsize!Fysize!F c%- a%-angle!F b%-blur!F v%- \
 p%-xorg!dyorg!d t%-xoff!Fyoff!F \to%-outfile!s infile%s",
                  &scaleflag, &xscale, &yscale, 
          &sizeflag, &xsize, &ysize, &centerflag,
          &angleflag, &angle,
          &blurflag,  &blur,
                  &verboseflag, &originflag, &X_origin, &Y_origin,
          &translateflag, &xtrans, &ytrans,
          &oflag, &out_fname, &infilename ) == 0)
       exit(-1);
     
     in_hdr = *rle_hdr_init( NULL );
     out_hdr = *rle_hdr_init( NULL );
 
     in_hdr.rle_file = rle_open_f(cmd_name( argv ), infilename, "r");
     rle_names( &in_hdr, cmd_name( argv ), infilename, 0 );
     rle_names( &out_hdr, in_hdr.cmd, out_fname, 0 );
     
     if (fabs(angle) > 45.0)
       fprintf(stderr,
           "fant: Warning: angle larger than 45 degrees, image will blur.\n");
     
     if (sizeflag && (angleflag || scaleflag || originflag || translateflag))
     {
     fprintf( stderr, 
   "%s: size option (-S) is incompatible with the angle (-a), scale (-s),\n\
    \ttranslate (-t) and origin (-p) options\n",
          cmd_name( argv ) );
     exit(-1);
     }
     if ( !sizeflag && centerflag )
     fprintf( stderr,
          "%s: center option (-c) ignored without size option (-S)\n",
          cmd_name( argv ) );
     
     if (blur < 0)
     {
     fprintf( stderr, "fant: blur factor must be positive\n" );
     exit(-1);
     }
 
     if ((scaleflag && xscale == 1.0) && (angle == 0.0))
     {
     vpassonlyflag = 1;
     if (verboseflag)
       fprintf(stderr, "fant: Only performing vertical pass\n");
     }
     
     for ( rle_cnt = 0;
      (rle_err = rle_get_setup( &in_hdr )) == RLE_SUCCESS;
      rle_cnt++ )
     {
     nchan = in_hdr.ncolors + in_hdr.alpha;
     
     (void)rle_hdr_cp( &in_hdr, &out_hdr );
     if ( rle_cnt == 0 )
       outfile = rle_open_f( cmd_name( argv ), out_fname, "w" );
     out_hdr.rle_file = outfile;
     
     rle_addhist( argv, &in_hdr, &out_hdr );
     
     /*
      * To define the output rectangle, we start with a set of points
      * defined by the original image, and then rotate and scale them
      * as desired.  Note that we use a continuous coordinate system:
          * min to max+1  with pixel centers at the midpoints of each unit
          * square.  
          *
          *  Mapping between coordinate systems:
      * if c = continuous coord and d = discrete coord, then
      *  c = d+.5
      *  d = floor(c)
      */
     p[1].x = in_hdr.xmin;       p[1].y = in_hdr.ymin;
     p[2].x = in_hdr.xmax+1;     p[2].y = in_hdr.ymin;
     p[3].x = in_hdr.xmax+1;         p[3].y = in_hdr.ymax+1;
     p[4].x = in_hdr.xmin;       p[4].y = in_hdr.ymax+1;
     
     if (sizeflag)
     {  
           /* Compute the scale factors from the desired destination size*/
         xscale = xsize / (p[2].x - p[1].x);
         yscale = ysize / (p[3].y - p[2].y);
         X_origin = p[1].x;
         Y_origin = p[1].y;
         /* If centering, adjust scale factors and origin. */
         if ( centerflag )
         {
         if ( xscale < yscale )
         {
             yscale = xscale;
             xtrans = 0;
             ytrans = (ysize - (p[3].y - p[2].y) * yscale) / 2;  
         }
         else
         {
             xscale = yscale;
             xtrans = (xsize - (p[2].x - p[1].x) * xscale) / 2;
             ytrans = 0;
         }
         }
         originflag = 1;
     }
     xform_points(p, xscale, yscale, angle, xtrans, ytrans );
     
     
     
     /* Map the continous coordinates back to discrete coordinates to 
          * determine the output image size.  We only output a pixel if it's
          * a least partially covered.  Partial, for us, means at least
          * EPSILON coverage.  This is a little arbitrary but ensures that
          * extra pixels aren't included on the ends.
          */
       
       
     i1 = (int) (p[1].x + EPSILON);
     i2 = (int) (p[4].x + EPSILON);
     out_hdr.xmin = MAX(0,MIN(i1,i2));
     
     i1 = (int) (p[1].y + EPSILON);
     i2 = (int) (p[2].y + EPSILON);
     out_hdr.ymin = MAX(0,MIN(i1,i2));
     
     i1 = (int) (p[2].x - EPSILON);
     i2 = (int) (p[3].x - EPSILON);
     out_hdr.xmax = MAX(i1,i2);
     
     i1 = (int) (p[3].y - EPSILON);
     i2 = (int) (p[4].y - EPSILON);
     out_hdr.ymax = MAX(i1,i2);
 
     
     /*
      * Need to grab the largest dimensions so the buffers will hold the
      * picture.  The arrays for storing the pictures extend from 0
          * to xmax in width and from ymin to ymax in height.  
      */
     array_width = MAX( out_hdr.xmax, in_hdr.xmax) +1;
     array_lines = MAX(out_hdr.ymax,in_hdr.ymax) - 
                   MIN(out_hdr.ymin,in_hdr.ymin) + 1;
     outlinewidth = out_hdr.xmax - out_hdr.xmin + 1;
     
     /*
      * Since the array begins at ymin, the four output corner points must be
      * translated to this coordinate system.
      */
     for (i = 1; i <= 4; i++)
       p[i].y -= MIN(out_hdr.ymin,in_hdr.ymin);
     
     /* Oink. */
 
     dims[0] = nchan;
     dims[1] = array_lines;
     dims[2] = array_width;
     rast = (rle_pixel ***) mallocNd(3,dims,sizeof(rle_pixel));
     bufin = (rle_pixel *) 
       malloc(MAX(array_lines,array_width)*sizeof(rle_pixel));
     RLE_CHECK_ALLOC( cmd_name( argv ), rast && bufin, "raster" );
     
     getraster(rast);
     
     /* Transform each channel */
     cur_chan = 0;
     for (cur_chan = 0; cur_chan < nchan; cur_chan++) 
       xform_image(p,blur);
     
     putraster(rast);
     
     rle_puteof( &out_hdr );
     free(rast);
     free(bufin);
     }
     
     if ( rle_cnt == 0 || (rle_err != RLE_EOF && rle_err != RLE_EMPTY) )
       rle_get_error( rle_err, cmd_name( argv ), infilename );
     exit( 0 );
 }

void* mallocNd ( )

void putraster ( )

void putraster ( rle_pixel *** ras_ptrs )

Definition at line 713 of file fant.c.

 {
     int i, chan;
     rle_pixel *ptrs[MAXCHAN];
     rle_pixel *rows[MAXCHAN];   /* Pointers for getrow/putrow */
     
     rle_put_setup( &out_hdr );
 
     /* 
      * If the output image is smaller than the input, we must offset
      * into the pixel array by the difference between the two.
      */
     if (in_hdr.ymin < out_hdr.ymin)
       for ( chan = 0; chan < nchan; chan++ )
     ptrs[chan] = ras_ptrs[chan][(out_hdr.ymin - in_hdr.ymin)];
     else 
       for ( chan = 0; chan < nchan; chan++ )
     ptrs[chan] = ras_ptrs[chan][0];
     
     for (i = out_hdr.ymin; i <= out_hdr.ymax; i++)
     {
     for ( chan = 0; chan < nchan; chan++ )
       rows[chan] = &((ptrs[chan])[out_hdr.xmin]);
     rle_putrow( &(rows[out_hdr.alpha]), outlinewidth, &out_hdr );
     
     /* Bump pointers */
     for ( chan = 0; chan < nchan; chan++ )
       ptrs[chan] += array_width;
     }
 }

void xform_image ( )

void xform_image	(	point *	p,
		double	blur
	)

Definition at line 340 of file fant.c.

 {
     double real_outpos, sizefac, delta;
     int i1, i2, ystart, yend;
     int xinlen = in_hdr.xmax - in_hdr.xmin + 1;
     int yinlen = in_hdr.ymax - in_hdr.ymin + 1;
     
     if (verboseflag)
       fprintf(stderr, "transforming channel %d...\n",
           cur_chan - in_hdr.alpha);
     
     /* Vertical pass */
     pass = V_PASS;
 /*     clear_raster( rast ); */
     
     real_outpos = p[1].y;
     
     sizefac = (p[4].y-p[1].y) / (yinlen);
     delta = (p[2].y - p[1].y) / (xinlen);
     
     for ( const_ind = in_hdr.xmin;
      const_ind <= in_hdr.xmax; const_ind++ )
     {
     interp_row( sizefac, blur, 0, real_outpos,
               in_hdr.ymax - in_hdr.ymin ,
               array_lines-1  );
     real_outpos += delta;
     }
     
     if (! vpassonlyflag )
     {
     /* Horizontal pass */
     pass = H_PASS;
     
     real_outpos = ( ((p[2].y - p[4].y) * (p[1].x - p[4].x))
                / (p[1].y - p[4].y) ) + p[4].x;
     sizefac = (p[2].x - real_outpos) / (xinlen);
     delta = (p[4].x - real_outpos) 
       / ((double) ((int) p[4].y) - ((int) p[2].y)); 
     
     /* If we're moving backwards, start at p1 (needs more thought...) */
     if (delta < 0)
       real_outpos = p[1].x;
 
     i1 = (int) (p[1].y + EPSILON);
     i2 = (int) (p[2].y + EPSILON);
     ystart = MIN(i1,i2);
     
     i1 = (int) (p[3].y - EPSILON);
     i2 = (int) (p[4].y - EPSILON);
     yend = MAX(i1,i2);
 
     if (ystart < 0)     /* Ensure start isn't negative */
     {
         real_outpos += delta * abs(ystart);
         ystart = 0;
     }
     
     for ( const_ind = ystart; const_ind <= yend; const_ind++ )
     {
         interp_row( sizefac, blur, in_hdr.xmin, real_outpos,
               in_hdr.xmax,
               out_hdr.xmax );
         real_outpos += delta;
     }
     }
 }

void xform_points ( )

void xform_points	(	point *	p,
		double	xscale,
		double	yscale,
		double	angle,
		double	xtrans,
		double	ytrans
	)

Definition at line 417 of file fant.c.

 {
     double s, c, xoff, yoff;        
     double tmp;
     int i;
     
     /* Sleazy - should build real matrix */
     
     c = cos(DEG(angle));
     s = sin(DEG(angle));
     if (!originflag)
     {
     xoff =  ((double) (in_hdr.xmax - in_hdr.xmin + 1) / 2.0
          + in_hdr.xmin);
     yoff =  ((double) (in_hdr.ymax - in_hdr.ymin + 1) / 2.0
          + in_hdr.ymin);
     }
     else
     {
     xoff = X_origin;
     yoff = Y_origin;
     }
     if (verboseflag)
       fprintf(stderr, "Output rectangle:\n");
     
     for ( i = 1; i <= 4; i++ )
     {
     p[i].x -= xoff;     /* translate to origin */
     p[i].y -= yoff;
     
     tmp = p[i].x * c + p[i].y * s; /* Rotate... */
     p[i].y = -p[i].x * s + p[i].y * c;
     p[i].x = tmp;
     
     p[i].x *= xscale;   /* Scale */
     p[i].y *= yscale;
     
     p[i].x += ( xoff + xtrans );    /* translate back from origin */
     p[i].y += ( yoff + ytrans );
     
     if (verboseflag)
       fprintf(stderr, "  %4.1f\t%4.1f\n", p[i].x, p[i].y);
     }
 }

Variable Documentation

int array_lines

Definition at line 106 of file fant.c.

int array_width

Definition at line 105 of file fant.c.

rle_pixel* bufin

Definition at line 98 of file fant.c.

int const_ind

Definition at line 100 of file fant.c.

int cur_chan

Definition at line 101 of file fant.c.

rle_hdr in_hdr

Definition at line 103 of file fant.c.

int nchan

Definition at line 104 of file fant.c.

int originflag

Definition at line 108 of file fant.c.

rle_hdr out_hdr

Definition at line 103 of file fant.c.

int outlinewidth

Definition at line 106 of file fant.c.

int pass

Definition at line 102 of file fant.c.

rle_pixel*** rast

Definition at line 97 of file fant.c.

int verboseflag

Definition at line 107 of file fant.c.

int vpassonlyflag

Definition at line 110 of file fant.c.

int X_origin

Definition at line 109 of file fant.c.

int Y_origin

Definition at line 109 of file fant.c.

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation