xcmap.c

speech signal process tools

	    if (fgets(line, 120, fd) == NULL) break;
	    sscanf(line, "%d%d%d", &r, &g, &b);
	    colors[i].red = r;
	    colors[i].green = g;
	    colors[i].blue = b;
	}
	fclose(fd);
	reset_colormap();
	redraw_colormap();
    } else
	printf("Can't open %s for input\n", name);
}

/*************************************************************************/
static void 
quit_proc(item, val, event)
    Panel_item	item;
    int		val;
    Event	*event;
{
    exit(0);
}

/*************************************************************************/
get_rgb(x,y,r,g,b)
     int x, y;
     u_char *r,*g,*b;
{
  double dr, db, dg, euclid(), rad, amax;
  int rx0, bx0, gx0, ry0, by0, gy0;

  rad = RADIUS;
  rx0 = tox;
  ry0 = toy;
  bx0 = tox + .5 + (rad/2);
  by0 = toy + .5 + ((sqrt(3.0)*rad)/2.0);
  gx0 = tox + rad;
  gy0 = toy;
  dr = euclid(rx0,ry0,x,y);
  dg = euclid(gx0,gy0,x,y);
  db = euclid(bx0,by0,x,y);
  if((dr <= rad) && (db <= rad) && (dg <= rad)) {
    dr = rad - dr;
    dg = rad - dg;
    db = rad - db;
    if(dr > dg) {
      if(dr > db) amax = dr;
      else  amax = db;
    } else {
      if(dg > db) amax = dg;
      else amax = db;
    }
    amax = 255.0/amax;
    *r = .5 + (dr*amax);
    *b = .5 + (db*amax);
    *g = .5 + (dg*amax);
    return(TRUE);
  }
  return(FALSE);
}

/*************************************************************************/
double 
euclid(x,y,x1,y1)
     int x,y,x1,y1;
{
  int xd, yd;

  xd = x - x1;
  yd = y - y1;
  return(sqrt((double)((xd*xd) + (yd*yd))));
}

/*************************************************************************/
Cbreak *
get_nearest_cb(x)
     int x;
{
  int xi;
  Cbreak *cb;

  xi = (x-bstart)/bwidth;
  if((xi < 0) || (xi > CM_SIZE)) return(NULL);

  cb = &cb0;
  while(cb->next) {
    if((cb->where <= xi) && (cb->next->where >= xi)) {
      if((xi - cb->where) < (cb->next->where - xi)) return(cb);
      else return(cb->next);
    }
    cb = cb->next;
  }
  return(cb);
}
  
/*************************************************************************/
kill_cb(cb)
     Cbreak *cb;
{
  int amax;
  
  if((cb == &cb0) || (cb == &cb1)) return;

  cb->prev->next = cb->next;
  cb->next->prev = cb->prev;
  if(cbp == cb) cbp = cb->next;
  reset_current_color(cbp->r,cbp->g,cbp->b);
  free(cb);
  
}

/*************************************************************************/
reset_current_color(r,g,b)
     u_char r,g,b;
{
  int amax;
  
  if(r > g) {
    if(r > b) amax = r;
    else  amax = b;
  } else {
    if(g > b) amax = g;
    else amax = b;
  }
  intensity = (1000 * amax)/255;
  if(amax) {
    curg = ((int)g * 255)/amax;
    curb = ((int)b * 255)/amax;
    curr = ((int)r * 255)/amax;
  } else curg = curb = curr = 255;
/*  printf("r%d g%d b%d cr%d cg%d cb%d amax%d int%d\n",(int)r,(int)g,(int)b,
	 (int)curr, (int)curg, (int)curb, amax, intensity);
	 */
  
  xv_set(slider,	PANEL_VALUE,		    intensity,
			0);
}

/*************************************************************************/
static void 
doit(pw, event, arg)
  Xv_window *pw;
  Event	    *event;
  caddr_t   arg;
{
  Rect *rec;
  int x, y, xi;
  u_char r, b, g;
  int e = event_id(event);
  Cbreak *cb;

  x = event_x(event);
  y = event_y(event);
  switch(e) {
  case MS_MIDDLE:
    if(event_is_up(event)) return;
    if((y > bheight) && ( y < (bheight << 1))) {
      if(cb = get_nearest_cb(x)) {
	kill_cb(cb);
	redraw_colormap();
	plot_bp();
      }
    }
    break;
    
  case MS_LEFT:
    if(event_is_up(event)) return;
    /* FALL THROUGH */
  case LOC_DRAG:
    if(y < bheight) {
      xi = (x - bstart)/bwidth;
      if (xi < 0 || xi >= CM_SIZE) return;
      cbp = new_cbreak(xi, colors[xi].red, colors[xi].green, colors[xi].blue);
      reset_current_color(cbp->r,cbp->g,cbp->b);
      plot_bp();
      return;
    }
    if((y > bheight) && ( y < (bheight << 1))) {
      if(cb = get_nearest_cb(x)) {
	cbp = cb;
	reset_current_color(cb->r,cb->g,cb->b);
	plot_bp();
      }
      return;
    }
    if(get_rgb(x,y,&r,&g,&b)){
      curr = r;
      curb = b;
      curg = g;
      redraw_colormap();
      return;
    }

  case LOC_MOVE:
    if(y < (bheight << 1)) {
      if((x >= bstart) && (x <= CM_WIDTH)) {
	char str[100];
	
	xi = (x-bstart)/bwidth;
	sprintf(str,"Level:%3d  R:%3d  G:%3d  B:%3d",
		xi, colors[xi].red, colors[xi].green, colors[xi].blue);
	pw_text(pw, cwidth/2, cheight-5, PIX_SRC, font, str);
      }
    }
    break;
	
  default:
    break;
  }
  return;
}

/*************************************************************************/
plot_bp()
{
  Pixwin *pw;
  Rect * rec;
  Cbreak *cb;
  int x, y1;
  char str[100];

  pw = canvas_pixwin(canvas);
  rec = (Rect*)xv_get(canvas,WIN_RECT);
  pw_rop(pw,bstart,bheight,CM_WIDTH,bheight,
	   PIX_SRC|PIX_COLOR(0),NULL,0,0);

  cb = &cb0;
  y1 = 2 * bheight/3;
  while(cb) {
    x = (cb->where * bwidth) + bwidth/2;
    pw_rop(pw,x,bheight,bwidth>>2,y1,
	   PIX_SRC|PIX_COLOR(cb->where),NULL,0,0);
    cb = cb->next;
  }
  x = (cbp->where * bwidth);
  pw_rop(pw,x,bheight,bwidth,bheight,
	 PIX_SRC|PIX_COLOR(cbp->where),NULL,0,0);
  print_maplevel(cbp);
}

/*************************************************************************/
static void 
intensity_proc(item, val, event)
     Panel_item item;
     int val;
     Event *event;
{

  intensity = val;
  redraw_colormap();

}
  
/*************************************************************************/
print_maplevel(cbp)
  Cbreak *cbp;
{
  Pixwin *pw;
  char str[100];
    
  sprintf(str,"Level:%3d  R:%3d  G:%3d  B:%3d",cbp->where,cbp->r,cbp->g,cbp->b);
  pw = canvas_pixwin(canvas);
  pw_text(pw, cwidth/2, cheight-5, PIX_SRC, font, str);
  return;
}

/*************************************************************************/
redraw_colormap()
{
  register int i, j,k, n;
  double r, b, g, rs, bs, gs;
  Cbreak *cb, *nb;
  char str[100];
  Pixwin *pw = canvas_pixwin(canvas);

  cbp->r = (.5 + ((double)curr * intensity)/1000.0);
  cbp->b = (.5 + ((double)curb * intensity)/1000.0);
  cbp->g = (.5 + ((double)curg * intensity)/1000.0);
  print_maplevel(cbp);
  cb = &cb0;
  nb = cb->next;
  while(nb) {
    r = cb->r;
    g = cb->g;
    b = cb->b;
    n = nb->where - cb->where;
    rs = ((double)(nb->r - r))/n;
    bs = ((double)(nb->b - b))/n;
    gs = ((double)(nb->g - g))/n;
    for(i = cb->where, j=nb->where; i < j; i++) {
      colors[i].red = r + .5;
      colors[i].green = g + .5;
      colors[i].blue = b + .5;
      r += rs;
      g += gs;
      b += bs;
    }
    cb = nb;
    nb = cb->next;
  }

  xv_set(cms,		CMS_COLORS,		colors,
			0);
  xv_set(canvas_paint_window(canvas),
			WIN_CMS,		cms,
			0);
}

/*************************************************************************/
reset_colormap()
{
  register int i, j,k, n;

  for (i = 0; i < CM_SIZE; i++) {
    if(! new_cbreak(i, colors[i].red, colors[i].green, colors[i].blue))
    {
      printf("Problems setting up new cbreaks in reset_colormap()\n");
      exit(-1);
    }
  }
  plot_bp();
}

/*************************************************************************/
draw_colorboxes()
{
  Pixwin *pw;
  int i, loc, k;

  pw = canvas_pixwin(canvas);
  for(i=0, loc=bstart ;i < CM_SIZE; i++, loc += bwidth)
    pw_rop(pw,loc,0,bwidth,bheight,PIX_SRC|PIX_COLOR(i),NULL,0,0);
}