sys/src/cmd/grap/ticks.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <math.h>
   5 #include "grap.h"
   6 #include "y.tab.h"
   7
   8 #define MAXTICK 200
   9 int     ntick   = 0;
  10 double  tickval[MAXTICK];       /* tick values (one axis at a time */
  11 char    *tickstr[MAXTICK];      /* and labels */
  12
  13 int     tside   = 0;
  14 int     tlist   = 0;            /* 1 => explicit values given */
  15 int     toffside = 0;           /* no ticks on these sides */
  16 int     goffside = 0;           /* no ticks on grid on these sides */
  17 int     tick_dir = OUT;
  18 double  ticklen = TICKLEN;      /* default tick length */
  19 int     autoticks = LEFT|BOT;
  20 int     autodir = 0;            /* set LEFT, etc. if automatic ticks go in */
  21
  22 void savetick(double f, char *s)        /* remember tick location and label */
  23 {
  24         if (ntick >= MAXTICK)
  25                 ERROR "too many ticks (%d)", MAXTICK FATAL;
  26         tickval[ntick] = f;
  27         tickstr[ntick] = s;
  28         ntick++;
  29 }
  30
  31 void dflt_tick(double f)
  32 {
  33         if (f >= 0.0)
  34                 savetick(f, tostring("%g"));
  35         else
  36                 savetick(f, tostring("\\%g"));
  37 }
  38
  39 void tickside(int n)    /* remember which side these ticks/gridlines go on */
  40 {
  41         tside |= n;
  42 }
  43
  44 void tickoff(int side)  /* remember explicit sides */
  45 {
  46         toffside |= side;
  47 }
  48
  49 void gridtickoff(void)  /* turn grid ticks off on the side previously specified (ugh) */
  50 {
  51         goffside = tside;
  52 }
  53
  54 void setlist(void)      /* remember that there was an explicit list */
  55 {
  56         tlist = 1;
  57 }
  58
  59 void tickdir(int dir, double val, int explicit) /* remember in/out [expr] */
  60 {
  61         tick_dir = dir;
  62         if (explicit)
  63                 ticklen = val;
  64 }
  65
  66 void ticks(void)                /* set autoticks after ticks statement */
  67 {
  68         /* was there an explicit "ticks [side] off"? */
  69         if (toffside)
  70                 autoticks &= ~toffside;
  71         /* was there an explicit list? (eg "ticks at ..." or "ticks from ...") */
  72         if (tlist) {
  73                 if (tside & (BOT|TOP))
  74                         autoticks &= ~(BOT|TOP);
  75                 if (tside & (LEFT|RIGHT))
  76                         autoticks &= ~(LEFT|RIGHT);
  77         }
  78         /* was there a side without a list? (eg "ticks left in") */
  79         if (tside && !tlist) {
  80                 if (tick_dir == IN)
  81                         autodir |= tside;
  82                 if (tside & (BOT|TOP))
  83                         autoticks = (autoticks & ~(BOT|TOP)) | (tside & (BOT|TOP));
  84                 if (tside & (LEFT|RIGHT))
  85                         autoticks = (autoticks & ~(LEFT|RIGHT)) | (tside & (LEFT|RIGHT));
  86         }
  87         tlist = tside = toffside = goffside = 0;
  88         tick_dir = OUT;
  89 }
  90
  91 double modfloor(double f, double t)
  92 {
  93         t = fabs(t);
  94         return floor(f/t) * t;
  95 }
  96
  97 double modceil(double f, double t)
  98 {
  99         t = fabs(t);
 100         return ceil(f/t) * t;
 101 }
 102
 103 double  xtmin, xtmax;   /* range of ticks */
 104 double  ytmin, ytmax;
 105 double  xquant, xmult;  /* quantization & scale for auto x ticks */
 106 double  yquant, ymult;
 107 double  lograt = 5;
 108
 109 void do_autoticks(Obj *p)       /* make set of ticks for default coord only */
 110 {
 111         double x, xl, xu, q;
 112
 113         if (p == NULL)
 114                 return;
 115         fprintf(tfd, "Autoticks:\t# x %g..%g, y %g..%g",
 116                 p->pt.x, p->pt1.x, p->pt.y, p->pt1.y);
 117         fprintf(tfd, ";   xt %g,%g, yt %g,%g, xq,xm = %g,%g, yq,ym = %g,%g\n",
 118                 xtmin, xtmax, ytmin, ytmax, xquant, xmult, yquant, ymult);
 119         if ((autoticks & (BOT|TOP)) && p->pt1.x >= p->pt.x) {   /* make x ticks */
 120                 q = xquant;
 121                 xl = p->pt.x;
 122                 xu = p->pt1.x;
 123                 if (xl >= xu)
 124                         dflt_tick(xl);
 125                 else if ((p->log & XFLAG) && xu/xl >= lograt) {
 126                         for (x = q; x < xu; x *= 10) {
 127                                 logtick(x, xl, xu);
 128                                 if (xu/xl <= 100) {
 129                                         logtick(2*x, xl, xu);
 130                                         logtick(5*x, xl, xu);
 131                                 }
 132                         }
 133                 } else {
 134                         xl = modceil(xtmin - q/100, q);
 135                         xu = modfloor(xtmax + q/100, q) + q/2;
 136                         for (x = xl; x <= xu; x += q)
 137                                 dflt_tick(x);
 138                 }
 139                 tside = autoticks & (BOT|TOP);
 140                 ticklist(p, 0);
 141         }
 142         if ((autoticks & (LEFT|RIGHT)) && p->pt1.y >= p->pt.y) {        /* make y ticks */
 143                 q = yquant;
 144                 xl = p->pt.y;
 145                 xu = p->pt1.y;
 146                 if (xl >= xu)
 147                         dflt_tick(xl);
 148                 else if ((p->log & YFLAG) && xu/xl >= lograt) {
 149                         for (x = q; x < xu; x *= 10) {
 150                                 logtick(x, xl, xu);
 151                                 if (xu/xl <= 100) {
 152                                         logtick(2*x, xl, xu);
 153                                         logtick(5*x, xl, xu);
 154                                 }
 155                         }
 156                 } else {
 157                         xl = modceil(ytmin - q/100, q);
 158                         xu = modfloor(ytmax + q/100, q) + q/2;
 159                         for (x = xl; x <= xu; x += q)
 160                                 dflt_tick(x);
 161                 }
 162                 tside = autoticks & (LEFT|RIGHT);
 163                 ticklist(p, 0);
 164         }
 165 }
 166
 167 void logtick(double v, double lb, double ub)
 168 {
 169         float slop = 1.0;       /* was 1.001 */
 170
 171         if (slop * lb <= v && ub >= slop * v)
 172                 dflt_tick(v);
 173 }
 174
 175 Obj *setauto(void)      /* compute new min,max, and quant & mult */
 176 {
 177         Obj *p, *q;
 178
 179         if ((q = lookup("lograt",0)) != NULL)
 180                 lograt = q->fval;
 181         for (p = objlist; p; p = p->next)
 182                 if (p->type == NAME && strcmp(p->name,dflt_coord) == 0)
 183                         break;
 184         if (p) {
 185                 if ((p->log & XFLAG) && p->pt1.x/p->pt.x >= lograt)
 186                         autolog(p, 'x');
 187                 else
 188                         autoside(p, 'x');
 189                 if ((p->log & YFLAG) && p->pt1.y/p->pt.y >= lograt)
 190                         autolog(p, 'y');
 191                 else
 192                         autoside(p, 'y');
 193         }
 194         return p;
 195 }
 196
 197 void autoside(Obj *p, int side)
 198 {
 199         double r, s, d, ub, lb;
 200
 201         if (side == 'x') {
 202                 xtmin = lb = p->pt.x;
 203                 xtmax = ub = p->pt1.x;
 204         } else {
 205                 ytmin = lb = p->pt.y;
 206                 ytmax = ub = p->pt1.y;
 207         }
 208         if (ub <= lb)
 209                 return; /* cop out on little ranges */
 210         d = ub - lb;
 211         r = s = 1;
 212         while (d * s < 10)
 213                 s *= 10;
 214         d *= s;
 215         while (10 * r < d)
 216                 r *= 10;
 217         if (r > d/3)
 218                 r /= 2;
 219         else if (r <= d/6)
 220                 r *= 2;
 221         if (side == 'x') {
 222                 xquant = r / s;
 223         } else {
 224                 yquant = r / s;
 225         }
 226 }
 227
 228 void autolog(Obj *p, int side)
 229 {
 230         double r, s, t, ub, lb;
 231         int flg;
 232
 233         if (side == 'x') {
 234                 xtmin = lb = p->pt.x;
 235                 xtmax = ub = p->pt1.x;
 236                 flg = p->coord & XFLAG;
 237         } else {
 238                 ytmin = lb = p->pt.y;
 239                 ytmax = ub = p->pt1.y;
 240                 flg = p->coord & YFLAG;
 241         }
 242         for (s = 1; lb * s < 1; s *= 10)
 243                 ;
 244         lb *= s;
 245         ub *= s;
 246         for (r = 1; 10 * r < lb; r *= 10)
 247                 ;
 248         for (t = 1; t < ub; t *= 10)
 249                 ;
 250         if (side == 'x')
 251                 xquant = r / s;
 252         else
 253                 yquant = r / s;
 254         if (flg)
 255                 return;
 256         if (ub / lb < 100) {
 257                 if (lb >= 5 * r)
 258                         r *= 5;
 259                 else if (lb >= 2 * r)
 260                         r *= 2;
 261                 if (ub * 5 <= t)
 262                         t /= 5;
 263                 else if (ub * 2 <= t)
 264                         t /= 2;
 265                 if (side == 'x') {
 266                         xtmin = r / s;
 267                         xtmax = t / s;
 268                 } else {
 269                         ytmin = r / s;
 270                         ytmax = t / s;
 271                 }
 272         }
 273 }
 274
 275 void iterator(double from, double to, int op, double by, char *fmt)     /* create an iterator */
 276 {
 277         double x;
 278
 279         /* should validate limits, etc. */
 280         /* punt for now */
 281
 282         dprintf("iterate from %g to %g by %g, op = %c, fmt=%s\n",
 283                 from, to, by, op, fmt ? fmt : "");
 284         switch (op) {
 285         case '+':
 286         case ' ':
 287                 for (x = from; x <= to + (SLOP-1) * by; x += by)
 288                         if (fmt)
 289                                 savetick(x, tostring(fmt));
 290                         else
 291                                 dflt_tick(x);
 292                 break;
 293         case '-':
 294                 for (x = from; x >= to; x -= by)
 295                         if (fmt)
 296                                 savetick(x, tostring(fmt));
 297                         else
 298                                 dflt_tick(x);
 299                 break;
 300         case '*':
 301                 for (x = from; x <= SLOP * to; x *= by)
 302                         if (fmt)
 303                                 savetick(x, tostring(fmt));
 304                         else
 305                                 dflt_tick(x);
 306                 break;
 307         case '/':
 308                 for (x = from; x >= to; x /= by)
 309                         if (fmt)
 310                                 savetick(x, tostring(fmt));
 311                         else
 312                                 dflt_tick(x);
 313                 break;
 314         }
 315         if (fmt)
 316                 free(fmt);
 317 }
 318
 319 void ticklist(Obj *p, int explicit)     /* fire out the accumulated ticks */
 320                                         /* 1 => list, 0 => auto */
 321 {
 322         if (p == NULL)
 323                 return;
 324         fprintf(tfd, "Ticks_%s:\n\tticklen = %g\n", p->name, ticklen);
 325         print_ticks(TICKS, explicit, p, "ticklen", "");
 326 }
 327
 328 void print_ticks(int type, int explicit, Obj *p, char *lenstr, char *descstr)
 329 {
 330         int i, logflag, inside;
 331         char buf[100];
 332         double tv;
 333
 334         for (i = 0; i < ntick; i++)     /* any ticks given explicitly? */
 335                 if (tickstr[i] != NULL)
 336                         break;
 337         if (i >= ntick && type == TICKS)        /* no, so use values */
 338                 for (i = 0; i < ntick; i++) {
 339                         if (tickval[i] >= 0.0)
 340                                 sprintf(buf, "%g", tickval[i]);
 341                         else
 342                                 sprintf(buf, "\\-%g", -tickval[i]);
 343                         tickstr[i] = tostring(buf);
 344                 }
 345         else
 346                 for (i = 0; i < ntick; i++) {
 347                         if (tickstr[i] != NULL) {
 348                                 sprintf(buf, tickstr[i], tickval[i]);
 349                                 free(tickstr[i]);
 350                                 tickstr[i] = tostring(buf);
 351                         }
 352                 }
 353         logflag = sidelog(p->log, tside);
 354         for (i = 0; i < ntick; i++) {
 355                 tv = tickval[i];
 356                 halfrange(p, tside, tv);
 357                 if (logflag) {
 358                         if (tv <= 0.0)
 359                                 ERROR "can't take log of tick value %g", tv FATAL;
 360                         logit(tv);
 361                 }
 362                 if (type == GRID)
 363                         inside = LEFT|RIGHT|TOP|BOT;
 364                 else if (explicit)
 365                         inside = (tick_dir == IN) ? tside : 0;
 366                 else
 367                         inside = autodir;
 368                 if (tside & BOT)
 369                         maketick(type, p->name, BOT, inside, tv, tickstr[i], lenstr, descstr);
 370                 if (tside & TOP)
 371                         maketick(type, p->name, TOP, inside, tv, tickstr[i], lenstr, descstr);
 372                 if (tside & LEFT)
 373                         maketick(type, p->name, LEFT, inside, tv, tickstr[i], lenstr, descstr);
 374                 if (tside & RIGHT)
 375                         maketick(type, p->name, RIGHT, inside, tv, tickstr[i], lenstr, descstr);
 376                 if (tickstr[i]) {
 377                         free(tickstr[i]);
 378                         tickstr[i] = NULL;
 379                 }
 380         }
 381         ntick = 0;
 382 }
 383
 384 void maketick(int type, char *name, int side, int inflag, double val, char *lab, char *lenstr, char *descstr)
 385 {
 386         char *sidestr, *td;
 387
 388         fprintf(tfd, "\tline %s ", descstr);
 389         inflag &= side;
 390         switch (side) {
 391         case BOT:
 392         case 0:
 393                 td = inflag ? "up" : "down";
 394                 fprintf(tfd, "%s %s from (x_%s(%g),0)", td, lenstr, name, val);
 395                 break;
 396         case TOP:
 397                 td = inflag ? "down" : "up";
 398                 fprintf(tfd, "%s %s from (x_%s(%g),frameht)", td, lenstr, name, val);
 399                 break;
 400         case LEFT:
 401                 td = inflag ? "right" : "left";
 402                 fprintf(tfd, "%s %s from (0,y_%s(%g))", td, lenstr, name, val);
 403                 break;
 404         case RIGHT:
 405                 td = inflag ? "left" : "right";
 406                 fprintf(tfd, "%s %s from (framewid,y_%s(%g))", td, lenstr, name, val);
 407                 break;
 408         }
 409         fprintf(tfd, "\n");
 410         if (type == GRID && (side & goffside))  /* wanted no ticks on grid */
 411                 return;
 412         sidestr = tick_dir == IN ? "start" : "end";
 413         if (lab != NULL) {
 414                 /* BUG: should fix size of lab here */
 415                 double wid = strlen(lab)/7.5 + (tick_dir == IN ? 0 : 0.1);      /* estimate width at 15 chars/inch */
 416                 switch (side) {
 417                 case BOT: case 0:
 418                         /* can drop "box invis" with new pic */
 419                         fprintf(tfd, "\tbox invis \"%s\" ht .25 wid 0 with .n at last line.%s",
 420                                 lab, sidestr);
 421                         break;
 422                 case TOP:
 423                         fprintf(tfd, "\tbox invis \"%s\" ht .2 wid 0 with .s at last line.%s",
 424                                 lab, sidestr);
 425                         break;
 426                 case LEFT:
 427                         fprintf(tfd, "\t\"%s \" wid %.2f rjust at last line.%s",
 428                                 lab, wid, sidestr);
 429                         break;
 430                 case RIGHT:
 431                         fprintf(tfd, "\t\" %s\" wid %.2f ljust at last line.%s",
 432                                 lab, wid, sidestr);
 433                         break;
 434                 }
 435                 /* BUG: works only if "down x" comes before "at wherever" */
 436                 lab_adjust();
 437                 fprintf(tfd, "\n");
 438         }
 439 }
 440
 441 Attr    *grid_desc      = 0;
 442
 443 void griddesc(Attr *a)
 444 {
 445         grid_desc = a;
 446 }
 447
 448 void gridlist(Obj *p)
 449 {
 450         char *framestr;
 451
 452         if ((tside & (BOT|TOP)) || tside == 0)
 453                 framestr = "frameht";
 454         else
 455                 framestr = "framewid";
 456         fprintf(tfd, "Grid_%s:\n", p->name);
 457         tick_dir = IN;
 458         print_ticks(GRID, 0, p, framestr, desc_str(grid_desc));
 459         if (grid_desc) {
 460                 freeattr(grid_desc);
 461                 grid_desc = 0;
 462         }
 463 }
 464
 465 char *desc_str(Attr *a) /* convert DOT to "dotted", etc. */
 466 {
 467         static char buf[50], *p;
 468
 469         if (a == NULL)
 470                 return p = "";
 471         switch (a->type) {
 472         case DOT:       p = "dotted"; break;
 473         case DASH:      p = "dashed"; break;
 474         case INVIS:     p = "invis"; break;
 475         default:        p = "";
 476         }
 477         if (a->fval != 0.0) {
 478                 sprintf(buf, "%s %g", p, a->fval);
 479                 return buf;
 480         } else
 481                 return p;
 482 }
 483
 484 sidelog(int logflag, int side)  /* figure out whether to scale a side */
 485 {
 486         if ((logflag & XFLAG) && ((side & (BOT|TOP)) || side == 0))
 487                 return 1;
 488         else if ((logflag & YFLAG) && (side & (LEFT|RIGHT)))
 489                 return 1;
 490         else
 491                 return 0;
 492 }