cmds.cc

   1 /*
   2  *      PaperJam -- Commands
   3  *
   4  *      (c) 2018 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #include <cassert>
   8 #include <cstdlib>
   9 #include <cstdio>
  10 #include <paper.h>
  11
  12 #include "jam.h"
  13
  14 /*** null ***/
  15
  16 class null_cmd : public cmd_exec {
  17 public:
  18   null_cmd(cmd *c UNUSED) { }
  19   vector<page *> process(vector<page *> &pages) override { return pages; }
  20 };
  21
  22 static const arg_def no_args[] = {
  23   { NULL,       0 }
  24 };
  25
  26 /*** Generic routines ***/
  27
  28 // Transformed page
  29
  30 class xform_page : public page {
  31   page *orig_page;
  32   pdf_matrix xform;
  33 public:
  34   void render(out_context *out, pdf_matrix xform) override;
  35   xform_page(page *p, pdf_matrix xf);
  36 };
  37
  38 xform_page::xform_page(page *p, pdf_matrix xf)
  39 {
  40   orig_page = p;
  41   index = p->index;
  42   xform = xf;
  43
  44   BBox media(p->width, p->height);
  45   media.transform(xf);
  46   width = media.width();
  47   height = media.height();
  48
  49   bbox = p->bbox;
  50   bbox.transform(xf);
  51 }
  52
  53 void xform_page::render(out_context *out, pdf_matrix parent_xform)
  54 {
  55   orig_page->render(out, xform * parent_xform);
  56 }
  57
  58 // Commands acting on individual pages
  59
  60 class cmd_exec_simple : public cmd_exec {
  61   virtual page *process_page(page *p) = 0;
  62   vector<page *> process(vector<page *> &pages) override;
  63 };
  64
  65 vector<page *> cmd_exec_simple::process(vector<page *> &pages)
  66 {
  67   vector<page *> out;
  68   for (auto p: pages)
  69     out.push_back(process_page(p));
  70   return out;
  71 }
  72
  73 // Paper specifications
  74
  75 class paper_spec {
  76 public:
  77   double w, h;
  78   paper_spec(cmd *c, bool maybe=true)
  79     {
  80       arg_val *aname = c->arg("paper");
  81       arg_val *aw = c->arg("w");
  82       arg_val *ah = c->arg("h");
  83       if (!aname->given() && !aw->given() && !ah->given() && maybe)
  84         {
  85           w = h = 0;
  86           return;
  87         }
  88       if (aw->given() != ah->given() || aname->given() == aw->given())
  89         die("Either paper format name or width and height must be given");
  90       if (aname->given())
  91         {
  92           const char *name = aname->as_string("").c_str();
  93           const paper *pap = paperinfo(name);
  94           if (!pap)
  95             die("No paper called %s is known", name);
  96           w = paperpswidth(pap);
  97           h = paperpsheight(pap);
  98         }
  99       else
 100         {
 101           w = aw->as_double(0);
 102           h = ah->as_double(0);
 103         }
 104     }
 105 };
 106
 107 #define PAPER_ARGS \
 108   { "paper",    AT_STRING | AT_POSITIONAL },    \
 109   { "w",        AT_DIMEN },                     \
 110   { "h",        AT_DIMEN }
 111
 112 // Position specification
 113
 114 class pos_spec {
 115 public:
 116   int h, v;
 117   pos_spec() { v = h = 0; }
 118   pos_spec(string s)
 119     {
 120       if (s.size() != 2)
 121         die("Value of pos must have two characters");
 122       if (s[0] == 't')
 123         v = 1;
 124       else if (s[0] == 'c')
 125         v = 0;
 126       else if (s[0] == 'b')
 127         v = -1;
 128       else
 129         die("First character of pos must be t/c/b");
 130       if (s[1] == 'l')
 131         h = -1;
 132       else if (s[1] == 'c')
 133         h = 0;
 134       else if (s[1] == 'r')
 135         h = 1;
 136       else
 137         die("Second character of pos must be l/c/r");
 138     }
 139   pos_spec(cmd *c) : pos_spec(c->arg("pos")->as_string("cc")) { }
 140   pdf_matrix place(BBox &inner, BBox &outer)
 141     {
 142       pdf_matrix m;
 143       m.shift(-inner.x_min, -inner.y_min);
 144       switch (h)
 145         {
 146         case -1:
 147           break;
 148         case 0:
 149           m.shift((outer.width() - inner.width()) / 2, 0);
 150           break;
 151         case 1:
 152           m.shift(outer.width() - inner.width(), 0);
 153           break;
 154         default:
 155           abort();
 156         }
 157       switch (v)
 158         {
 159         case -1:
 160           break;
 161         case 0:
 162           m.shift(0, (outer.height() - inner.height()) / 2);
 163           break;
 164         case 1:
 165           m.shift(0, outer.height() - inner.height());
 166           break;
 167         default:
 168           abort();
 169         }
 170       m.shift(outer.x_min, outer.y_min);
 171       return m;
 172     }
 173 };
 174
 175 #define POS_ARGS \
 176   { "pos",      AT_STRING }
 177
 178 // Margins
 179
 180 class margin_spec {
 181 public:
 182   double l, r, t, b;
 183   margin_spec(cmd *c, string basic, string sx)
 184     {
 185       double m, h, v;
 186       m = c->arg(basic)->as_double(0);
 187       h = c->arg("h" + sx)->as_double(m);
 188       v = c->arg("v" + sx)->as_double(m);
 189       l = c->arg("l" + sx)->as_double(h);
 190       r = c->arg("r" + sx)->as_double(h);
 191       t = c->arg("t" + sx)->as_double(v);
 192       b = c->arg("b" + sx)->as_double(v);
 193     }
 194   void shrink_box(BBox *bb)
 195     {
 196       bb->x_min += l;
 197       bb->x_max -= r;
 198       bb->y_min += b;
 199       bb->y_max -= t;
 200       if (bb->x_min >= bb->x_max || bb->y_min >= bb->y_max)
 201         die("Margins cannot be larger than the whole page");
 202     }
 203   void expand_box(BBox *bb)
 204     {
 205       bb->x_min -= l;
 206       bb->x_max += r;
 207       bb->y_min -= b;
 208       bb->y_max += t;
 209     }
 210 };
 211
 212 #define MARGIN_ARGS1_NAMED(name)        \
 213   { name,       AT_DIMEN }
 214
 215 #define MARGIN_ARGS1_POSNL(name)        \
 216   { name,       AT_DIMEN | AT_POSITIONAL }
 217
 218 #define MARGIN_ARGS2(sx)                \
 219   { "h" sx,     AT_DIMEN },             \
 220   { "v" sx,     AT_DIMEN },             \
 221   { "l" sx,     AT_DIMEN },             \
 222   { "r" sx,     AT_DIMEN },             \
 223   { "t" sx,     AT_DIMEN },             \
 224   { "b" sx,     AT_DIMEN }
 225
 226 // Scaling preserving aspect ratio
 227
 228 double scale_to_fit(BBox &from, BBox &to)
 229 {
 230   double fw = from.width(), fh = from.height();
 231   double tw = to.width(), th = to.height();
 232   if (is_zero(fw) || is_zero(fh) || is_zero(tw) || is_zero(th))
 233     return 1;
 234   else
 235     return min(tw/fw, th/fh);
 236 }
 237
 238 /*** move ***/
 239
 240 class move_cmd : public cmd_exec_simple {
 241   double x, y;
 242 public:
 243   move_cmd(cmd *c)
 244     {
 245       x = c->arg("x")->as_double(0);
 246       y = c->arg("y")->as_double(0);
 247     }
 248   page *process_page(page *p) override
 249     {
 250       pdf_matrix m;
 251       m.shift(x, y);
 252       return new xform_page(p, m);
 253     }
 254 };
 255
 256 static const arg_def move_args[] = {
 257   { "x",        AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
 258   { "y",        AT_DIMEN | AT_MANDATORY | AT_POSITIONAL },
 259   { NULL,       0 }
 260 };
 261
 262 /*** scale ***/
 263
 264 class scale_cmd : public cmd_exec_simple {
 265   double x_factor, y_factor;
 266 public:
 267   scale_cmd(cmd *c)
 268     {
 269       x_factor = c->arg("x")->as_double(1);
 270       y_factor = c->arg("y")->as_double(x_factor);
 271     }
 272   page *process_page(page *p) override
 273     {
 274       pdf_matrix m;
 275       m.scale(x_factor, y_factor);
 276       return new xform_page(p, m);
 277     }
 278 };
 279
 280 static const arg_def scale_args[] = {
 281   { "x",        AT_DOUBLE | AT_MANDATORY | AT_POSITIONAL },
 282   { "y",        AT_DOUBLE | AT_POSITIONAL },
 283   { NULL,       0 }
 284 };
 285
 286 /*** rotate ***/
 287
 288 class rotate_cmd : public cmd_exec_simple {
 289   int deg;
 290 public:
 291   rotate_cmd(cmd *c)
 292     {
 293       deg = c->arg("deg")->as_int(0) % 360;
 294       if (deg < 0)
 295         deg += 360;
 296       if (deg % 90)
 297         die("Rotate requires a multiple of 90 degrees");
 298     }
 299   page *process_page(page *p) override
 300     {
 301       pdf_matrix m;
 302       switch (deg)
 303         {
 304         case 0:
 305           break;
 306         case 90:
 307           m.rotate_deg(-90);
 308           m.shift(0, p->width);
 309           break;
 310         case 180:
 311           m.rotate_deg(180);
 312           m.shift(p->width, p->height);
 313           break;
 314         case 270:
 315           m.rotate_deg(90);
 316           m.shift(p->height, 0);
 317           break;
 318         default:
 319           abort();
 320         }
 321       return new xform_page(p, m);
 322     }
 323 };
 324
 325 static const arg_def rotate_args[] = {
 326   { "angle",    AT_INT | AT_MANDATORY | AT_POSITIONAL },
 327   { NULL,       0 }
 328 };
 329
 330 /*** flip ***/
 331
 332 class flip_cmd : public cmd_exec_simple {
 333   bool horizontal;
 334   bool vertical;
 335 public:
 336   flip_cmd(cmd *c)
 337     {
 338       horizontal = c->arg("h")->as_int(0);
 339       vertical = c->arg("v")->as_int(0);
 340       if (!horizontal && !vertical)
 341         die("Flip has no direction specified");
 342     }
 343   page *process_page(page *p) override
 344     {
 345       pdf_matrix m;
 346       if (vertical)
 347         {
 348           m.scale(1, -1);
 349           m.shift(0, p->height);
 350         }
 351       if (horizontal)
 352         {
 353           m.scale(-1, 1);
 354           m.shift(p->width, 0);
 355         }
 356       return new xform_page(p, m);
 357     }
 358 };
 359
 360 static const arg_def flip_args[] = {
 361   { "h",        AT_SWITCH },
 362   { "v",        AT_SWITCH },
 363   { NULL,       0 }
 364 };
 365
 366 /*** select ***/
 367
 368 class select_cmd : public cmd_exec {
 369   pipeline *pipe;
 370 public:
 371   select_cmd(cmd *c)
 372     {
 373       pipe = c->pipe;
 374     }
 375   vector<page *> process(vector<page *> &pages);
 376 };
 377
 378 static int validate_page_index(vector<page *> &pages, int idx)
 379 {
 380   if (idx >= 1 && idx <= (int) pages.size())
 381     return idx - 1;
 382   if (idx <= -1 && idx >= (int) -pages.size())
 383     return idx + pages.size();
 384   die("Page index %d out of range", idx);
 385 }
 386
 387 vector<page *> select_cmd::process(vector<page *> &pages)
 388 {
 389   vector<page *> out;
 390   for (auto pb: pipe->branches)
 391     {
 392       vector<page *> selected;
 393       for (auto ps: pb->selectors)
 394         {
 395           int f = validate_page_index(pages, ps.from);
 396           int t = validate_page_index(pages, ps.to);
 397           int step = (f <= t) ? 1 : -1;
 398           for (int i=f; f<=t; f += step)
 399             selected.push_back(pages[i]);
 400         }
 401       auto processed = run_command_list(pb->commands, selected);
 402       for (auto p: processed)
 403         out.push_back(p);
 404     }
 405   return out;
 406 }
 407
 408 /*** apply ***/
 409
 410 class apply_cmd : public cmd_exec {
 411   pipeline *pipe;
 412 public:
 413   apply_cmd(cmd *c)
 414     {
 415       pipe = c->pipe;
 416     }
 417   vector<page *> process(vector<page *> &pages);
 418 };
 419
 420 static pipeline_branch *find_branch(pipeline *pipe, vector <page *> &pages, int idx)
 421 {
 422   for (auto pb: pipe->branches)
 423     for (auto ps: pb->selectors)
 424       {
 425         int f = validate_page_index(pages, ps.from);
 426         int t = validate_page_index(pages, ps.to);
 427         if (f <= idx && idx <= t || t <= idx && idx <= f)
 428           return pb;
 429       }
 430   return NULL;
 431 }
 432
 433 vector<page *> apply_cmd::process(vector<page *> &pages)
 434 {
 435   vector<page *> out;
 436
 437   int cnt = 0;
 438   for (auto p: pages)
 439     {
 440       pipeline_branch *pb = find_branch(pipe, pages, cnt);
 441       if (pb)
 442         {
 443           vector<page *> tmp;
 444           tmp.push_back(p);
 445           auto processed = run_command_list(pb->commands, tmp);
 446           for (auto q: processed)
 447             out.push_back(q);
 448         }
 449       else
 450         out.push_back(p);
 451       cnt++;
 452     }
 453
 454   return out;
 455 }
 456
 457 /*** modulo ***/
 458
 459 class modulo_cmd : public cmd_exec {
 460   pipeline *pipe;
 461   int n;
 462 public:
 463   modulo_cmd(cmd *c)
 464     {
 465       n = c->arg("n")->as_int(0);
 466       if (n <= 0)
 467         die("Modulo must have n > 0");
 468       pipe = c->pipe;
 469     }
 470   vector<page *> process(vector<page *> &pages);
 471 };
 472
 473 vector<page *> modulo_cmd::process(vector<page *> &pages)
 474 {
 475   vector<page *> out;
 476   int tuples = ((int) pages.size() + n - 1) / n;
 477
 478   for (int tuple=0; tuple < tuples; tuple++)
 479     {
 480       debug("# Tuple %d", tuple);
 481       debug_indent += 4;
 482       for (auto pb: pipe->branches)
 483         {
 484           vector<page *> tmp;
 485           for (auto ps: pb->selectors)
 486             {
 487               int f = ps.from;
 488               int t = ps.to;
 489               int step = (f <= t) ? 1 : -1;
 490               for (int i=f; i<=t; i += step)
 491                 {
 492                   int j;
 493                   if (i > 0 && i <= n)
 494                     j = tuple*n + i - 1;
 495                   else if (i < 0 && i >= -n)
 496                     j = (tuples-1-tuple)*n + (-i) - 1;
 497                   else
 498                     die("Modulo: invalid index %d", i);
 499                   if (j < (int) pages.size())
 500                     tmp.push_back(pages[j]);
 501                   else
 502                     {
 503                       page *ref_page = pages[tuple*n];
 504                       tmp.push_back(new empty_page(ref_page->width, ref_page->height));
 505                     }
 506                 }
 507             }
 508           auto processed = run_command_list(pb->commands, tmp);
 509           for (auto q: processed)
 510             out.push_back(q);
 511         }
 512       debug_indent -= 4;
 513     }
 514
 515   return out;
 516 }
 517
 518 static const arg_def modulo_args[] = {
 519   { "n",        AT_INT | AT_MANDATORY | AT_POSITIONAL },
 520   { NULL,       0 }
 521 };
 522
 523 /*** draw_bbox ***/
 524
 525 class draw_bbox_cmd : public cmd_exec {
 526 public:
 527   draw_bbox_cmd(cmd *c UNUSED) { }
 528   vector<page *> process(vector<page *> &pages);
 529 };
 530
 531 class draw_bbox_page : public page {
 532   page *orig_page;
 533 public:
 534   void render(out_context *out, pdf_matrix xform) override;
 535   draw_bbox_page(page *p) : page(p) { orig_page = p; }
 536 };
 537
 538 void draw_bbox_page::render(out_context *out, pdf_matrix xform)
 539 {
 540   orig_page->render(out, xform);
 541   out->contents +=
 542      "q " +
 543      xform.to_string() + " cm " +
 544      "0 1 0 RG " +
 545      bbox.to_rect() + " re S " +
 546      "Q ";
 547 }
 548
 549 vector<page *> draw_bbox_cmd::process(vector<page *> &pages)
 550 {
 551   vector<page *> out;
 552   for (auto p: pages)
 553     out.push_back(new draw_bbox_page(p));
 554   return out;
 555 }
 556
 557 /*** merge ***/
 558
 559 class merge_cmd : public cmd_exec {
 560 public:
 561   merge_cmd(cmd *c UNUSED) { }
 562   vector<page *> process(vector<page *> &pages);
 563 };
 564
 565 class merge_page : public page {
 566   vector<page *> orig_pages;
 567 public:
 568   merge_page(vector<page *> &orig) : page(0, 0)
 569     {
 570       orig_pages = orig;
 571       bool first = true;
 572       for (auto p: orig)
 573         {
 574           if (first)
 575             {
 576               width = p->width;
 577               height = p->height;
 578               bbox = p->bbox;
 579               first = false;
 580             }
 581           else
 582             {
 583               if (!is_equal(width, p->width) || !is_equal(height, p->height))
 584                 die("All pages participating in a merge must have the same dimensions");
 585               bbox.join(p->bbox);
 586             }
 587         }
 588     }
 589   void render(out_context *out, pdf_matrix xform) override
 590     {
 591       for (auto p: orig_pages)
 592         p->render(out, xform);
 593     }
 594 };
 595
 596 vector<page *> merge_cmd::process(vector<page *> &pages)
 597 {
 598   vector<page *> out;
 599   if (pages.size())
 600     out.push_back(new merge_page(pages));
 601   return out;
 602 }
 603
 604 /*** paper ***/
 605
 606 class paper_cmd : public cmd_exec_simple {
 607   paper_spec paper;
 608   pos_spec pos;
 609 public:
 610   paper_cmd(cmd *c) : paper(c), pos(c) { }
 611   page *process_page(page *p) override
 612     {
 613       BBox paper_box = BBox(paper.w, paper.h);
 614       pdf_matrix xf = pos.place(p->bbox, paper_box);
 615       page *q = new xform_page(p, xf);
 616       q->width = paper.w;
 617       q->height = paper.h;
 618       return q;
 619     }
 620 };
 621
 622 static const arg_def paper_args[] = {
 623   PAPER_ARGS,
 624   POS_ARGS,
 625   { NULL,       0 }
 626 };
 627
 628 /*** scaleto ***/
 629
 630 class scaleto_cmd : public cmd_exec_simple {
 631   paper_spec paper;
 632   pos_spec pos;
 633 public:
 634   scaleto_cmd(cmd *c) : paper(c), pos(c) { }
 635   page *process_page(page *p) override
 636     {
 637       BBox orig_box = BBox(p->width, p->height);
 638       BBox paper_box = BBox(paper.w, paper.h);
 639       pdf_matrix xf;
 640       xf.scale(scale_to_fit(orig_box, paper_box));
 641       orig_box.transform(xf);
 642       xf.concat(pos.place(orig_box, paper_box));
 643       page *q = new xform_page(p, xf);
 644       q->width = paper.w;
 645       q->height = paper.h;
 646       return q;
 647     }
 648 };
 649
 650 static const arg_def scaleto_args[] = {
 651   PAPER_ARGS,
 652   POS_ARGS,
 653   { NULL,       0 }
 654 };
 655
 656 /*** fit ***/
 657
 658 class fit_cmd : public cmd_exec_simple {
 659   paper_spec paper;
 660   pos_spec pos;
 661   margin_spec marg;
 662 public:
 663   fit_cmd(cmd *c) : paper(c, true), pos(c), marg(c, "margin", "margin") { }
 664   page *process_page(page *p) override
 665     {
 666       pdf_matrix xf;
 667       page *q;
 668
 669       if (!is_zero(paper.w) && !is_zero(paper.h))
 670         {
 671           // Paper given: scale image to fit paper
 672           BBox orig_box = p->bbox;
 673           BBox paper_box = BBox(paper.w, paper.h);
 674           marg.shrink_box(&paper_box);
 675           xf.scale(scale_to_fit(orig_box, paper_box));
 676           orig_box.transform(xf);
 677           xf.concat(pos.place(orig_box, paper_box));
 678           q = new xform_page(p, xf);
 679           q->width = paper.w;
 680           q->height = paper.h;
 681         }
 682       else
 683         {
 684           // No paper given: adjust paper to fit image
 685           xf.shift(-p->bbox.x_min, -p->bbox.y_min);
 686           xf.shift(marg.l, marg.b);
 687           q = new xform_page(p, xf);
 688           q->width = p->bbox.width() + marg.l + marg.r;
 689           q->height = p->bbox.height() + marg.t + marg.b;
 690         }
 691       return q;
 692     }
 693 };
 694
 695 static const arg_def fit_args[] = {
 696   PAPER_ARGS,
 697   POS_ARGS,
 698   MARGIN_ARGS1_NAMED("margin"),
 699   MARGIN_ARGS2("margin"),
 700   { NULL,       0 }
 701 };
 702
 703 /*** expand ***/
 704
 705 class expand_cmd : public cmd_exec_simple {
 706   margin_spec marg;
 707 public:
 708   expand_cmd(cmd *c) : marg(c, "by", "") { }
 709   page *process_page(page *p) override
 710     {
 711       pdf_matrix xf;
 712       xf.shift(marg.l, marg.b);
 713       page *q = new xform_page(p, xf);
 714       q->width = p->width + marg.l + marg.r;
 715       q->height = p->height + marg.t + marg.b;
 716       if (q->width < 0.001 || q->height < 0.001)
 717         die("Expansion must result in positive page dimensions");
 718       return q;
 719     }
 720 };
 721
 722 static const arg_def expand_args[] = {
 723   MARGIN_ARGS1_POSNL("by"),
 724   MARGIN_ARGS2(""),
 725   { NULL,       0 }
 726 };
 727
 728 /*** margins ***/
 729
 730 class margins_cmd : public cmd_exec_simple {
 731   margin_spec marg;
 732 public:
 733   margins_cmd(cmd *c) : marg(c, "size", "") { }
 734   page *process_page(page *p) override
 735     {
 736       pdf_matrix xf;
 737       xf.shift(-p->bbox.x_min, -p->bbox.y_min);
 738       xf.shift(marg.l, marg.b);
 739       page *q = new xform_page(p, xf);
 740       q->width = p->bbox.width() + marg.l + marg.r;
 741       q->height = p->bbox.height() + marg.t + marg.b;
 742       if (q->width < 0.001 || q->height < 0.001)
 743         die("Margins must result in positive page dimensions");
 744       return q;
 745     }
 746 };
 747
 748 static const arg_def margins_args[] = {
 749   MARGIN_ARGS1_POSNL("size"),
 750   MARGIN_ARGS2(""),
 751   { NULL,       0 }
 752 };
 753
 754 /*** Command table ***/
 755
 756 template<typename T> cmd_exec *ctor(cmd *c) { return new T(c); }
 757
 758 const cmd_def cmd_table[] = {
 759   { "null",     no_args,        0,      &ctor<null_cmd>         },
 760   { "move",     move_args,      0,      &ctor<move_cmd>         },
 761   { "scale",    scale_args,     0,      &ctor<scale_cmd>        },
 762   { "rotate",   rotate_args,    0,      &ctor<rotate_cmd>       },
 763   { "flip",     flip_args,      0,      &ctor<flip_cmd>         },
 764   { "select",   no_args,        1,      &ctor<select_cmd>       },
 765   { "apply",    no_args,        1,      &ctor<apply_cmd>        },
 766   { "modulo",   modulo_args,    1,      &ctor<modulo_cmd>       },
 767   { "draw_bbox",no_args,        0,      &ctor<draw_bbox_cmd>    },
 768   { "merge",    no_args,        0,      &ctor<merge_cmd>        },
 769   { "paper",    paper_args,     0,      &ctor<paper_cmd>        },
 770   { "scaleto",  scaleto_args,   0,      &ctor<scaleto_cmd>      },
 771   { "fit",      fit_args,       0,      &ctor<fit_cmd>          },
 772   { "expand",   expand_args,    0,      &ctor<expand_cmd>       },
 773   { "margins",  margins_args,   0,      &ctor<margins_cmd>      },
 774   { NULL,       NULL,           0,      NULL    }
 775 };