xplot_data.c

speech signal process tools

/*
 * This material contains unpublished, proprietary software of 
 * Entropic Research Laboratory, Inc. Any reproduction, distribution, 
 * or publication of this work must be authorized in writing by Entropic 
 * Research Laboratory, Inc., and must bear the notice: 
 *
 *    "Copyright (c) 1987-1990  AT&T, Inc.
 *    "Copyright (c) 1986-1990  Entropic Speech, Inc. 
 *    "Copyright (c) 1990-1996  Entropic Research Laboratory, Inc. 
 *                   All rights reserved"
 *
 * The copyright notice above does not evidence any actual or intended 
 * publication of this source code.     
 *
 * Written by:  David Talkin
 *
 * plot_data.c
 * display methods for all supported data types
 */

static char *sccs_id = "@(#)xplot_data.c	1.16 9/5/97 ERL";

#include <sys/file.h>
#include <esps/esps.h>
#include <esps/fea.h>
#include <esps/feaspec.h>
#include <Objects.h>
#include <xview/font.h>
#include <Xp_pw.h>

extern int	generic_ord_to_y();
extern double	generic_y_to_yval();

extern int debug_level;
extern Xv_Font def_font;
extern int     def_font_height, def_font_width;

extern int doing_print_graphic, print_only_plot;

#define scoff(x) ((int)(yoffs + ((double)(x) * scale)))
#define ALMOST 0.95
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
double 
fmod(num,den)
     register double num, den;
{
  register int q;

  q = num/den;
  return( num - ((double)q)*den);
}

/*********************************************************************/
int 
plot_reticles(v)
     View *v;
{
  int i;

  if (!v || !(v->canvas)) return(FALSE);
  for (i = 0; i < v->dims; ++i)
    if (v->reticle_on[i] && v->ret[i])
      draw_reticle(v->canvas,v->ret[i]);
}


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
print_y(v)
     register View *v;
{
  register int	i, elem, dim, index, slen, w;
  register List	*l, *l2;
  double	time, scale, yoffs;
  char		tmp[100];
  Pixwin	*pw;
  Signal	*sig;
  extern 	View *focus_view;

  if (doing_print_graphic && print_only_plot)
    	return(TRUE);

  if (v && (sig = v->sig)) {

    if (!IS_GENERIC(sig->type)) return(FALSE);

    time = v->cursor_time;
    if (time < v->start_time) time = v->start_time;
    if (time > (scale = ET(v)))   time = scale;

    if((index=time_to_index(sig, time)) > sig->buff_size - 1
       || index < 0
       || (v->dims > 0 && !sig->data))
      return(FALSE);

    w = def_font_width;

    pw = canvas_pixwin(v->canvas);

    for(dim=0; dim < v->dims; dim++) { /* for each dimension... */
      if(v->show_vals[dim]) {
	double offs, scl;

	elem = v->elements[dim];

	if(v->show_labels[dim] && (l = sig->idents)) {
	  /* find the element's ident. string */
	  for(i = 0, l2 = l; i < elem; i++)
	    if(l2->next)
	      l2 = l2->next;
	  slen = strlen(l2->str); /* offset at which to print numeric value */
	} else slen = 0;
	offs = v->val_offset[elem];
	scl = v->val_scale[elem];

	switch (sig->type & VECTOR_SIGNALS) {
	case P_CHARS:
	case P_UCHARS:
	  {
	    char *s_data = ((char **) sig->data)[elem];

	    if (!s_data)
	      return FALSE;
	    sprintf(tmp,"%4.0f",offs + (scl * s_data[index]));
	  } break;
	case P_SHORTS:
	case P_USHORTS:
	  {
	    short *s_data = ((short **) sig->data)[elem];

	    if (!s_data)
	      return FALSE;
	    sprintf(tmp,"%6.0f",offs + (scl * s_data[index]));
	  } break;
	case P_INTS:
	case P_UINTS:
	  {
	    int *s_data = ((int **) sig->data)[elem];

	    if (!s_data)
	      return FALSE;
	    sprintf(tmp,"%12.0f",offs + (scl * s_data[index]));
	  } break;
	case P_FLOATS:
	  {
	    float *s_data = ((float **) sig->data)[elem];

	    if (!s_data)
	      return FALSE;
	    sprintf(tmp,"%13.6e",offs + (scl * s_data[index]));
	  } break;
	case P_DOUBLES:
	  {
	    double *s_data = ((double **) sig->data)[elem];

	    if (!s_data)
	      return FALSE;
	    sprintf(tmp,"%13.6e",offs + (scl * s_data[index]));
	  } break;
	case P_MIXED:
	  {
	    caddr_t s_data = ((caddr_t *) sig->data)[elem];

	    if (!s_data)
	      return FALSE;

	    switch (sig->types[elem])
	    {
	    case P_CHARS:
	    case P_UCHARS:
	      sprintf(tmp,"%4.0f",offs + (scl * ((char *) s_data)[index]));
	      break;
	    case P_SHORTS:
	    case P_USHORTS:
	      sprintf(tmp,"%6.0f",offs + (scl * ((short *) s_data)[index]));
	      break;
	    case P_INTS:
	    case P_UINTS:
	      sprintf(tmp,"%12.0f",offs + (scl * ((int *) s_data)[index]));
	      break;
	    case P_FLOATS:
	      sprintf(tmp,"%13.6e",offs + (scl * ((float *) s_data)[index]));
	      break;
	    case P_DOUBLES:
	      sprintf(tmp,"%13.6e",offs + (scl * ((double *) s_data)[index]));
	      break;
	    default:
	      return(FALSE);
	    }
	  } break;
	default:
	  return(FALSE);
	}

	/*      sigmin = v->sig->smin[v->elements[dim]];
		
		if (plot_min != 0)
		sigmin = plot_min;
		
		if (v->sig->smax[v->elements[dim]] - sigmin == 0.0)
		sigmin -= 0.5; */ /* Cf. line in scale_for_canvas setting
		* dtm = 1.0 when maxval - minval == 0.0.
		* The adjustment here is to keep the baseline
		* of the at the bottom of the allotted strip,
		* rather than the center, when the data are
		* constant
		*/


	scale = - PIX_PER_CM/v->y_scale[dim];
	yoffs = .5 + (double)v->y_offset[dim];
        if (v->show_current_chan && focus_view == v && dim == v->cursor_channel)
	   pw_text(pw, *(v->x_offset) + (slen*w), scoff(v->plot_min[dim]),
		PIX_SRC|PIX_COLOR(YA2_COLOR), def_font, tmp);
        else
	   pw_text(pw, *(v->x_offset) + (slen*w), scoff(v->plot_min[dim]),
		PIX_SRC|PIX_COLOR(TEXT_COLOR), def_font, tmp);
      }
    }
  }
  return(TRUE);
}


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
file_print_x(v,x)
     register View *v;
     int x;
{
  Xv_Window	pw;
  Rect	*rec;
  char	mes[50];
  double	time, sig_dur, fract;
  int		w_msg, w_win;
  
  if (doing_print_graphic && print_only_plot)
    	return(TRUE);

  if (!v || !v->canvas || !v->sig) return FALSE;

  x -= *(v->x_offset);
  if(x < 0) x = 0;
  fract = ((double)x)/(v->width - *(v->x_offset));
  sig_dur = SIG_DURATION(v->sig);
  time = v->sig->start_time + (sig_dur * fract);
  pw = canvas_paint_window(v->canvas);
  rec = (Rect *) xv_get(pw, WIN_RECT);
  w_win = rec->r_width;

  sprintf(mes, "Time(f):%9.5fsec", time);
  w_msg = strlen(mes)*def_font_width;

  x = (w_win/3 >= w_msg) ? w_win/3 - w_msg
    : 0;			/* Move time msg left in small windows to
				   postpone overlap with D: L: R: F: msg
				   (see plot_markers in xcursors.c). */
  pw_text(pw, x, 14,
	  PIX_SRC|PIX_COLOR(FOREGROUND_COLOR), def_font, mes);
    
  return(TRUE);
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
print_x(v)
    register View *v;
{
    Xv_Window	pw;
    Rect	*rec;
    char	mes[50];
    double	time, t;
    int		w_msg, w_win, x;
  
    if (!v || !v->canvas) return FALSE;
    if (doing_print_graphic && print_only_plot)
    	return(TRUE);

    time = v->cursor_time;
    if (time < v->start_time) time = v->start_time;
    if (time > (t = ET(v)))   time = t;

    pw = canvas_paint_window(v->canvas);
    rec = (Rect *) xv_get(pw, WIN_RECT);
    w_win = rec->r_width;

    sprintf(mes, "   Time:%9.5fsec", time);
    w_msg = strlen(mes)*def_font_width;

    x = (w_win/3 >= w_msg) ? w_win/3 - w_msg
	: 0;			/* Move time msg left in small windows to
				   postpone overlap with D: L: R: F: msg
				   (see plot_markers in xcursors.c). */
    pw_text(pw, x, 14,
	    PIX_SRC|PIX_COLOR(FOREGROUND_COLOR), def_font, mes);
    
    return(TRUE);
}

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* Periodic vector and scalar signals are plotted using a connect-the-dots
   algorithm.  Arbitrary x-axis scaling, y_offsets and y-axis scaling are
   supported. */
plot_waves(view)
  register View *view;
{
  register int y, y2, j, k, npix;
  int index, nsam, maxdim;
  int val, dim, its_an_overlay = FALSE;
  register View *vh;
  Pixwin    *pw;
  Signal    *sig;
  Canvas    canvas;
  double    end, fxoff;
  register double scale, incr, x, yoffs, sump;
/*  double	sigmin; */
  struct rect	*rect;
  extern int	show_labels;
  List *l, *l2;

  if(view && (sig = view->sig) && sig->type) {

    if (IS_GENERIC(sig->type))
    {

      /* Is this an overlaid signal? */
      if(!((view->extra_type & VIEW_OVERLAY) && (vh = (View*)view->extra)))
	vh = view;
      else
	its_an_overlay = TRUE;

      canvas = vh->canvas;
      pw = canvas_pixwin(canvas); /* get the pixwin to write to */

      rect = (struct rect*)xv_get(canvas, WIN_RECT);
  
      /* Determine the number of waveform samples to plot */
      if(vh->start_time < (end = BUF_END_TIME(sig))) {
	if(vh->start_time >= BUF_START_TIME(sig))
	  nsam = (end - vh->start_time) * sig->freq;
	else
	  nsam = sig->buff_size;
      } else {
	return(FALSE);
      }
	
      /* get x-displacement per waveform sample */
      incr = (PIX_PER_CM / *(vh->x_scale))/sig->freq;

      /*compute the number of  pixels in the x-direction */
      npix = (incr * nsam);

      /* clip to size of canvas */
      npix = (npix > (rect->r_width - *(vh->x_offset))) ?
	rect->r_width - *(vh->x_offset) : npix;
      nsam = .5 + (((double)npix)/incr);

      /* Clear window if data is NOT plotted as an overlay. */
      if(!its_an_overlay && !doing_print_graphic)
	pw_write(pw,0,0,rect->r_width,rect->r_height,
		 PIX_COLOR(vh->background)|PIX_SRC,NULL,0,0);

      /* deternine starting sample in the waveform */
      index = time_to_index(sig,vh->start_time);
      /* determine x offset due to initial sample time re view start */
      fxoff = 0.5 + (PIX_PER_CM * (BUF_START_TIME(sig) -
	   vh->start_time + ((double)index)/sig->freq) / *(vh->x_scale));
  
#define PLOT_TYPE(the_type)	{ \
    register the_type *q, *r, *p, imax, imin; \
    int k1=0; \
     \
    if (!s_data) return FALSE; \
     \
    val = view->colors[dim]; \
     \
    scale = - PIX_PER_CM/vh->y_scale[dim]; \
     \
    yoffs = .5 + (double)vh->y_offset[dim]; /* precompute for speed */ \
     \
    switch(view->line_types[dim]) { \
    case 1:			/* standard solid line type */ \
    default: \
      if(incr < 1.0){	/* must do max-min computation? */ \
        register int y2; \
	for(k=0, j = *(vh->x_offset) + fxoff, sump=0.0, \
	    p = (the_type *) s_data + index ;    k < npix; \
	    j++, k++, sump -= 1.0) { \
	      for(imax = imin = *p; sump < 1.0; sump += incr ) { \
                if (++k1 == nsam) break; \
		if(*++p > imax)imax = *p; \
		else \
		  if(*p < imin)imin = *p;\
	      } \
              y = scoff(imax); \
	      y2 = scoff(imin); \
	      if(y2 != y) \
                 pw_vector(pw, j, y, j, y2, \
			PIX_COLOR(val)|PIX_SRC, val); \
              else \
                 pw_vector(pw, j, y, j+1, y2, \
			PIX_COLOR(val)|PIX_SRC, val); \
	    } \
      } else {		/* no need for max-min */ \
	for(k = *(vh->x_offset) + fxoff, x = fxoff + *(vh->x_offset) + incr, \
	    p = (the_type *) s_data + index, \
	    r = p + 1,  q = p + nsam - 1; p < q; x += incr) { \
	      j = x; \
	      pw_vector(pw, k, scoff(*p++), j, scoff(*r++), \
			PIX_COLOR(val)|PIX_SRC, val); \
	      k = j; \
	    } \
      } \
      break; \
    case 2:			/* histogram-style */ \
      if(incr < 1.0){	/* must do max-min computation? */ \
	for(k=0, j = *(vh->x_offset) + fxoff, sump=0.0, \
	    y = scoff(sig->smin[vh->elements[dim]]), \
	    p = (the_type *) s_data + index ;    k < npix; \
	    j++, k++, sump -= 1.0) { \
	      for(imax = *p; sump < 1.0; sump += incr ) {\
                if(++k1 == nsam) break; \
		if(*++p > imax)imax = *p; \
              } \
	      pw_vector(pw, j, scoff(imax), j, y, \
			PIX_COLOR(val)|PIX_SRC, val); \
	    } \
      } else {		/* no need for max-min */ \
	for(k = *(vh->x_offset) + fxoff, x = fxoff + *(vh->x_offset) + incr, \
	    y2 = scoff(sig->smin[vh->elements[dim]]), \
	    p = (the_type *) s_data + index, \
	    r = p + 1,  q = p + nsam; p < q; x += incr) { \
	      j = x; \
	      pw_vector(pw, k, (y = scoff(*p++)), j, scoff(*r++), \
			PIX_COLOR(val)|PIX_SRC, val); \
	      pw_vector(pw, k, y, k, y2, PIX_COLOR(val)|PIX_SRC, val); \
	      k = j; \
	    } \
      } \
      break; \
    case 3:			/* DSP-style */ \
    case 4:		/* DSP-style with connect-the-dots*/ \
      if(incr < 1.0){	/* must do max-min computation? */ \
	for(k=0, j = *(vh->x_offset) + fxoff, sump=0.0, \
	    y = scoff(0.0), \
	    p = (the_type *) s_data + index ;    k < npix; \
	    j++, k++, sump -= 1.0) { \
	      for(imax = imin = *p; sump < 1.0; sump += incr ) { \
                if (++k1 == nsam) break; \
		if(*++p > imax)imax = *p; \
		else \
		  if(*p < imin)imin = *p; \
	      } \
	      if(imax > 0.0) \
		pw_vector(pw, j, scoff(imax), j, y, \
			PIX_COLOR(val)|PIX_SRC, val); \
	      if(imin < 0.0) \
		pw_vector(pw, j, scoff(imin), j, y, \
			PIX_COLOR(val)|PIX_SRC, val); \
	    } \
      } else {		/* no need for max-min */ \
	for(k = *(vh->x_offset) + fxoff, x = fxoff + *(vh->x_offset) + incr, \
	    y2 = scoff(0.0), \
	    p = (the_type *) s_data + index, \
	    r = p + 1,  q = p + nsam; p < q; x += incr) { \
	      j = x; \
	      y = scoff(*p++); \
	      if(view->line_types[dim] == 4) \
		pw_vector(pw, k, y, j, scoff(*r++), \
			PIX_COLOR(val)|PIX_SRC, val); \
	      pw_vector(pw, k, y, k, y2, PIX_COLOR(val)|PIX_SRC, val); \
	      k = j; \
	    } \
      } \
      break; \
    } \
}
  /* >>>  END of PLOT_TYPE() definition  <<< */

      if (nsam > 0)
      {
	  maxdim = (vh->dims > view->dims) ? view->dims : vh->dims;

	  if (maxdim > 0 && !sig->data)
	      return FALSE;

	  for (dim=0; dim < maxdim; dim++) /* for each dimension... */
	      switch(sig->type & VECTOR_SIGNALS)
	      {
	      case P_CHARS:
	      case P_UCHARS:
		{
		    char    *s_data = ((char **) sig->data)[vh->elements[dim]];