comparison tools/sp_weights.c @ 0:5242703e91d3 tip

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

+/*************************************************************************
+ sp_weights.c   Map auditory image onto spiral sector-weights contour.
+--------------
+
+    Read auditory image frames (gensai or genspl with output set) from a
+    file or the stdin. Input must have a pipes header, (for frame dimensions).
+
+    Note, you can use either gensai or genspl output, but remember that their
+    default options are different, (particularly pwidth, nwidth, and dencf).
+
+    For each frame, (of frameheight*framewidth binary shorts),
+    write a sector-weights contour, (of m binary shorts), on the stdout.
+
+    Arguments:
+	-m      The number of sectors (default SECTORS).
+	-fA-B   Process the A'th to B'th frame inclusive,
+		(or the A'th to the eof if b=='e'), (default -o1-e).
+	-fA     Process just the A'th frame.
+
+*************************************************************************/
+
+#include <stdio.h>
+#include <math.h>
+#include "header.h"
+#include "options.h"
+#include "units.h"
+#include "strmatch.h"
+
+char applic[] = "Map auditory image frames onto spiral sector-weights contours.\n           (Input and output in binary shorts)." ;
+
+static char *helpstr, *debugstr, *infostr, *fstr, *mstr ;
+
+static Options option[] = {
+    {   "help"      ,   "off"       ,  &helpstr     ,   "help"                        , DEBUG   },
+    {   "debug"     ,   "off"       ,  &debugstr    ,   "debugging switch"            , DEBUG   },
+    {   "info"      ,   "off"       ,  &infostr     ,   "print frame size information", DEBUG   },
+    {   "frames"    ,   "1-max"     ,  &fstr        ,   "select frames inclusively"   , VAL     },
+    {   "nsectors"  ,   "64"        ,  &mstr        ,   "number of sectors"           , SVAL    },
+   ( char * ) 0 } ;
+
+
+#define log2(x)     (log((double)x)/log(2.0))
+#define round(x)    ((int)(x+0.5))
+
+int     frameheight, framewidth ;   /* Parameters read from header */
+int     frames;
+double  orig_spd ;
+
+main(argc, argv)
+int   argc ;
+char *argv[] ;
+{
+    FILE   *fp ;
+    char   *header, *val1, *val2 ;
+    char   *headeropt, *versionstr;
+    int     i, a, b;
+    int     m ;                 /* Number of sectors around spiral      */
+    int     framebytes;         /* Number of bytes in each frame        */
+    short  *frame;              /* Each frame                           */
+
+    fp = openopts( option,argc,argv ) ;
+    if ( !isoff( helpstr ) )
+	helpopts( helpstr, argv[0], applic, option ) ;
+
+    m = atoi( mstr ) ;
+
+    /* parse bounds on number of frames */
+
+    if ( getvals( fstr, &val1, &val2, "-" ) == BADVAL ) {
+	fprintf(stderr,"loudness: bad frame selector [%s]\n", fstr ) ;
+	exit( 1 ) ;
+    }
+    a = atoi( val1 ) ;
+    if ( isempty( val2 ) )    b = a ;
+    else if ( ismax( val2 ) ) b = 0 ;
+    else                      b = atoi( val2 ) ;
+
+    if (b<a && b>0) fprintf(stderr,"sp_weights warning: bad frame specifiers\n");
+
+
+
+    /* Read header to find dimensions of auditory image */
+
+    if ((header = ReadHeader(fp)) == (char *) 0 ) {
+	fprintf(stderr,"sp_weights: header not found\n");
+	exit(1);
+    }
+
+    if ( (versionstr = HeaderString( header, "Version" )) == (char *)0 ) {
+	fprintf(stderr,"sp_weights: model version-number not found in header\n");
+	exit(1);
+    }
+
+    if ( (headeropt = HeaderString( header, "frameheight" )) == (char *)0) {
+	fprintf(stderr,"sp_weights: frameheight not found in header\n");
+	exit(1);
+    }
+    else  frameheight = atoi( headeropt );
+
+    if ( (headeropt = HeaderString( header, "framewidth" )) == (char *)0) {
+	fprintf(stderr,"sp_weights: framewidth not found in header\n");
+	exit(1);
+    }
+    else  framewidth = atoi( headeropt );
+
+    if ( (headeropt = HeaderString( header, "frames" )) == (char *)0) {
+	fprintf(stderr,"sp_weights: frames not found in header\n");
+	exit(1);
+    }
+    else  frames = atoi( headeropt );
+
+    if ( (headeropt = HeaderString( header, "orig_spd" )) == (char *)0) {
+	fprintf(stderr,"sp_weights: orig_spd not found in header\n");
+	exit(1);
+    }
+    else  orig_spd = atof( headeropt );
+
+    if ( ison( debugstr ) ) {
+	printf("a=%d b=%d m=%d \n", a, b, m );
+	printf("frames=%d  frameheight=%d  framewidth=%d orig_spd=%.2f\n", frames,frameheight,framewidth,orig_spd ) ;
+	exit(0);
+    }
+
+    if ( ison( infostr ) || a==0 ) {
+	printf("sp_weights input: %s", versionstr ) ;
+	printf("                  frames=%d  frameheight=%d  framewidth=%d\n", frames,frameheight,framewidth ) ;
+	exit(0);
+    }
+
+    if (frames<=0) {
+	if (frames==0)  fprintf(stderr,"sp_weights: zero frames input\n");
+	if (frames<0)   fprintf(stderr,"sp_weights: garbled number of frames, (start set too big?)\n");
+	exit(1);
+    }
+
+    if (a>frames || b>frames)
+	fprintf(stderr,"sp_weights warning: bad frame specifiers\n");
+
+    framebytes = frameheight * framewidth * sizeof(short) ;
+
+    /* Allocate space for an auditory image frame */
+
+    if (( frame = (short *)malloc( framebytes )) == NULL)
+	    fprintf(stderr,"sp_weights: malloc out of space\n");
+
+    /* Seek past a-1 frames, then read the next b-a+1 frames, or all    */
+    /* remaining frames if b==0.                                        */
+
+    for (i=1 ; i<a  && fread(frame,framebytes,1,fp) ; i++)
+	;
+    if (b > 0)
+	for (  ; i<=b && fread(frame,framebytes,1,fp) ; i++)
+	    write_weights(frame,m);
+    else
+	while ( fread(frame,framebytes,1,fp) )
+	    write_weights(frame,m);
+
+    fclose(fp);
+}
+
+
+
+/***************************************************************************
+  Spoke sector weight routines  (originally as src/src8/spoke.c)
+
+  Write m sector weights as binary shorts on the stdout.
+***************************************************************************/
+
+write_weights(frame,m)
+short *frame;
+int    m;       /* number of sectors around the spiral plane */
+{
+    static  short *sector;
+    static  int   *logtime;
+    int     i, k, t, col;
+    double  sum;
+    static  int    first=1;     /* flag for first-call of this routine */
+
+    /* Allocate space (first-time call only). */
+    if (first) {
+	first = 0;
+	/* Allocate space and compute base-2 log time for spoke detection */
+	if ( (sector  = (short *)malloc( m*sizeof(short) ) ) == NULL)
+	    fprintf(stderr,"sp_weights: malloc out of space\n");
+	if ( (logtime = (int *)malloc( framewidth*sizeof(int) ) ) == NULL )
+	    fprintf(stderr,"sp_weights: malloc out of space\n");
+	gen_logtime(logtime,m);
+    }
+    /* clear sector bins */
+    for (i=0 ; i<m ; i++)
+	sector[i]=0;
+    /* for each time point along the SAI frame (with time origin on right) */
+    /* (exclude time-origin bin to prevent overweighting by this sample)   */
+    for (t=round(pow(2.0,orig_spd)) ; t<framewidth ; t++)  {
+	col = (framewidth-1)-t;
+	/* sum frame column (ie across all frequency channels) */
+	for (i=0, k=0, sum=0 ; i<frameheight ; i++, k+=framewidth)
+	    sum += frame[col+k];
+	/* Normalize (divide by frameheight) for average magnitude */
+	sum /= frameheight;
+	/* Accumulate sum in log-time sector bin */
+	sector[logtime[t]] += sum;
+    }
+    /* write total sum activity in spokes around the spiral from the datum */
+    /* line in an anticlockwise direction. (ie in "natural order").        */
+    for (i=0 ; i<m ; i++)
+/*        printf("%d\n", sector[i]);    */
+	fwrite(&sector[i], sizeof(short), 1, stdout);
+}
+
+/****************************************************************************
+  List the sector numbers, 0,1,...,m-1, which correspond to each time
+  t=1,2,...,framewidth-1. The return array, "logtime", maps time index onto
+  a spiral sector number.
+  (Note that since the sector width increases with radius, there is an
+  increasing number of adjacent frame indices within the sector bin).
+****************************************************************************/
+gen_logtime(logtime, m)
+int  *logtime;
+int   m;
+{
+    int     t;
+    double  theta, fptr, iptr;
+
+    logtime[0] = 0; /* special case for log(0) */
+    for (t=1 ; t<framewidth ; t++)  {
+	theta = log2(t) - orig_spd;
+	fptr = modf(theta,&iptr);       /* find fractional part of log time */
+	/* scale up to given resolution, and round */
+	logtime[t] = (int)(0.5+(fptr*m));
+    }
+}
+
+
+