view tools/scale.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

/*
  scale.c       shift and scale a data stream by given constants or to
  -------       fit a given range (top - bottom).

  Shifting and scaling is done for all input x using the formula:
	y = ( x - shift ) * scale

  If only a shift term   is given, then the default scale is 1.0
  If only a scale factor is given, then the default shift is 0.

  If neither shift nor scale are given, then appropriate values are
  chosen so that the output fits the range specified by `top' and `bottom'.
  For an input which ranges between extreme values of `max' and `min', the
  shift and scale factors to give a required range between `top' and `bottom'
  are found by simultaneously solving:
	top    = ( max - shift ) * scale
	bottom = ( min - shift ) * scale

  If top < bottom then the input is inverted in the resulting range.

  The input stream depends upon the `type' option. The output datatype is
  the same as that selected for input.
  With no filename arguments, data is expected on the stdin, and the
  scaled result is written on the stdout. Otherwise each given filename is
  processed in turn. When the `output' option is "off" output overwrites the
  respective input file. (The respective output for the stdin is the stdout).
  Otherwise all scaled input files are written to the given output file
  (which is the stdout by default).

  The `range' option sets the start and duration of the process.
  Its arguments are of the form: range=a-b (where start=a and duration=b-a+1)
			    or: range=a   (where start=a and duration=1    )
  The arguments can be in time units (ms, s) or samples (no units), and both
  "min" (start of file) and "max" (end of file) are recognised.
  Samples in a file are numbered 0,1,2,...,max.

  Examples:

1. Invert the range of a given pulse train to obtain negative-going pulses.
   (Two ways):

ptrain amp=512 | scale top=-512 bot=0 | x11plot
ptrain amp=512 | scale scale=-1       | x11plot

*/


#include <stdio.h>
#include <math.h>
#include "options.h"
#include "units.h"
#include "strmatch.h"

char applic[]     = "waveform shifting and scaling:  y = (x - shift) * scale" ;

static char *helpstr,   *debugstr,  *sampstr,   *rangestr,  *outstr     ;
static char *topstr,    *botstr,    *scalestr,  *typestr,   *sizestr    ;
static char *shiftstr,  *normstr                                        ;

static Options option[] = {
    {   "help"      ,   "off"       ,  &helpstr     ,   "help"                          , DEBUG   },
    {   "debug"     ,   "off"       ,  &debugstr    ,   "debugging switch"              , DEBUG   },
    {   "samplerate",   "20kHz"     ,  &sampstr     ,   "samplerate "                   , VAL     },
    {   "range"     ,   "0-max"     ,  &rangestr    ,   "start-finish limits in data"   , VAL     },
    {   "top"       ,   "1000"      ,  &topstr      ,   "max of scaled data"            , VAL     },
    {   "bottom"    ,   "-1000"     ,  &botstr      ,   "min of scaled data"            , VAL     },
    {   "shift"     ,   "off"       ,  &shiftstr    ,   "shift term"                    , VAL     },
    {   "scale"     ,   "off"       ,  &scalestr    ,   "scale factor"                  , VAL     },
    {   "normalize" ,   "off"       ,  &normstr     ,   "set zero mean and unit std dev", VAL     },
    {   "type"      ,   "short"     ,  &typestr     ,   "datatype"                      , VAL     },
    {   "output"    ,   "stdout"    ,  &outstr      ,   "output filename (off = overwrite input)"   , VAL     },
    {   "SIZE"      ,   "262144p"   ,  &sizestr     ,   "buffer size (s, ms, or p)"     , SVAL    },
   ( char * ) 0 } ;


int    samplerate  ;
int    type        ;    /* datatype index */
int    bytes       ;
int    SIZE        ;    /* buffer size    */

int    FIT_TO_RANGE = 0 ;
int    NORMALIZE    = 0 ;

float  shift, scale ;

float *data  ;

FILE  *ofp   ;

main (argc, argv)
int     argc;
char  **argv;
{
    FILE   *fp ;
    int     i, j, a, b, n ;

    i = getopts( option, argc, argv ) ;
    if ( !isoff( helpstr ) )
	helpopts( helpstr, argv[0], applic, option ) ;

    samplerate = to_Hz( sampstr ) ;
    SIZE       = to_p( sizestr, samplerate ) ;

    if ( ( type = typeindex( typestr ) ) < 0 ) {
	fprintf( stderr, "scale: bad type [%s]\n", typestr ) ;
	exit( 1 ) ;
    }
    bytes = typebytes( type ) ;

    if ( range( rangestr, &a, &b, samplerate ) == 0 ) {
	fprintf(stderr,"scale: bad range [%s]\n", rangestr ) ;
	exit( 1 ) ;
    }


    if ( ison( normstr ) )  NORMALIZE = 1 ;
    else if ( isoff( shiftstr ) && isoff( scalestr ) ) FIT_TO_RANGE = 1 ;
    else if ( isoff( shiftstr ) ) {
	shift = 0  ;
	scale = atof( scalestr ) ;
    }
    else if ( isoff( scalestr ) ) {
	shift = atof( shiftstr ) ;
	scale = 1. ;
    }
    else {
	shift = atof( shiftstr ) ;
	scale = atof( scalestr ) ;
    }

    if ( ( data = (float *)malloc( SIZE * sizeof(float) ) ) == NULL ) {
	fprintf( stderr, "malloc out of space\n" ) ;
	exit( 1 ) ;
    }


    do {

	if ( i == 0 ) fp = stdin ;
	else if ( ( fp = fopen( argv[argc-i], "r" ) ) == (FILE *)0 ) {
	    fprintf( stderr,"scale: can't open %s\n", argv[argc-i] ) ;
	    exit( 1 ) ;
	}

	if ( seekstart( a, bytes, fp ) < a ) {
	    fprintf( stderr,"scale: insufficient data in file\n" ) ;
	    exit( 1 ) ;
	}

	for ( j = a, n = 0 ; ( j <= b || b == (-1) ) && n < SIZE && readitem( &data[n], type, 1, fp ) ; j++, n++ )
	    ;
	if ( n == SIZE )
	    fprintf( stderr, "scale warning: file %s exceeded buffer size\n",  argv[argc-i] ) ;

	fclose( fp ) ;


	if ( NORMALIZE )
	    getnorm( data, n, &shift, &scale ) ;
	else if ( FIT_TO_RANGE )
	    getrange( data, n, atof( topstr ), atof( botstr ), &shift, &scale ) ;


	if ( isstr( outstr, "print" ) )
	    printf( "%8.3f  %8.3f \n", shift, scale ) ;
	else {
	    open_output( argc, argv , i ) ;
	    for ( j = 0 ; j < n ; j++ ) {
		data[j] = ( data[j] - shift ) * scale ;
		writeitem( &data[j], type, 1, ofp ) ;
	    }
	}

    } while ( --i > 0 ) ;

    fclose( ofp ) ;
}


/*
Open ouput file pointer, ofp.
Use the input filename (argv[argc-i]) if outstr is "off", otherwise use
the given name outstr.
*/

open_output( argc, argv , i )
int     argc ;
char  **argv ;
int     i    ;
{
    static int first = 1 ;

    if ( first ) {

	if ( isoff( outstr ) ) {
	    if ( i == 0 ) ofp = stdout ;
	    else if ( ( ofp = fopen( argv[argc-i], "w" ) ) == (FILE *)0 ) {
		fprintf( stderr,"scale: can't create %s\n", argv[argc-i] ) ;
		exit( 1 ) ;
	    }
	}
	else if ( isstr( outstr, "stdout") ) ofp = stdout ;
	else if ( ( ofp = fopen( outstr, "w" ) ) == (FILE *)0 ) {
	    fprintf( stderr,"scale: can't create %s\n", outstr ) ;
	    exit( 1 ) ;
	}
	first = 0 ;
    }

    else {
	if ( isoff( outstr ) ) {
	    fclose ( ofp ) ;
	    if ( i == 0 ) ofp = stdout ;
	    else if ( ( ofp = fopen( argv[argc-i], "w" ) ) == (FILE *)0 ) {
		fprintf( stderr,"scale: can't create %s\n", argv[argc-i] ) ;
		exit( 1 ) ;
	    }
	}
    }
}


/*
Return parameters `shift' and `scale' to normalize the data for zero mean
and unit std dev:
	shift = mean
	scale = 1 / sqrt(variance)
*/

getnorm( data, n, shift, scale )
float *data ;
int    n    ;
float *shift, *scale  ;
{
    int    i ;
    float  sum = 0, sumsq = 0 ;

    for ( i = 0 ; i < n ; i++ ) {
	sum   += data[i] ;
	sumsq += data[i] * data[i] ;
    }

    *shift = sum / n ;
    *scale = 1. / sqrt( sumsq / n - *shift * *shift ) ;
}


/*
Return parameters `shift' and `scale' to fit the given float data into the
amplitude range delimited by `top' and `bottom'.
*/

getrange( data, n, top, bottom, shift, scale )
float *data ;
int    n    ;
float  top,    bottom ;
float *shift, *scale  ;
{
    float  min = 1e+8, max = (-1e+8) ;
    int    i ;

    for ( i = 0 ; i < n ; i++ ) {
	if ( data[i] > max ) max = data[i] ;
	if ( data[i] < min ) min = data[i] ;
    }

    *scale = ( top - bottom ) / ( max - min ) ;
    *shift = ( min * top - max * bottom ) / ( top - bottom ) ;
}