pz_image_t pz_image_read_pgm (char *fName)
  { 
    unsigned NX, NY, maxVal;
    unsigned aux;

    { /* with */
      FILE *rd = open_read(txtcat(fName, ".pgm"));
      pgm_read_header(rd, &NX, &NY, &maxVal);
      affirm(maxVal <= 255, "bad maxval");
      pz_gray_pixel_t *pixels = (pz_gray_pixel_t *)malloc(NX*NY*sizeof(pz_gray_pixel_t));
      affirm(pixels != NULL, "no memory");
      pgm_image_t M = (pz_image_t){NY, NX, maxval, pixels};
      int x, y;
      for (y = NY-1; y>=0; y--)
        { for (x = 0; x<NX; x++)
            { getchar(aux,rd);
              M[y,x]= aux;
            }
        }  
      return M;
    } 
  } /* ReadPGM */
void pz_image_write_pgm(char *fName, pz_image_t *M)
  {

    { /* with */
      ??? NY = (M.nel);
      ??? NX = (M[0].nel);
      ??? wr = open_write(fName & ".pgm");
      ??? pgmWr = NEW(PGM.Writer).init(wr,NX, NY, 255, binary := TRUE);
      /* do */
      for (y = NY-1; y <= 0 BY -1 ; y++){ 
        for (x = 0; x <= NX-1 ; x++){ 
          pgmWr.put(M[y,x]);
        };
      }
      pgmWr.finish();
      fclose(wr);
    }
  } /* pz_image_write_pgm */

pz_window_t  ComputeCurveWindow(
    pz_r3_chain_t *c 
  )
  VAR w: pz_window_t;
  {
    /* Compute bounding box of all mapped curves: */
    w[X].min = (double.nel - 1); w[X].max = (-MAXDOUBLE);
    w[Y].min = (double.nel - 1); w[Y].max = (-MAXDOUBLE);
    for (i = 0; i < (c.nel ) ; i++){

      { /* with */
        ??? x = c[i][0], y = c[i][1];
        /* do */
        w[X].min = min(w[X].min, x); w[X].max = max(w[X].max, x);
        w[Y].min = min(w[Y].min, y); w[Y].max = max(w[Y].max, y);;
      };
    };
    return w
  } /* ComputeCurveWindow */
======================================================================
from pzplot.h - multi-figure page control (now in pswr.c)

/* MULTIPLE DRAWINGS PER PAGE */

/*
  The following procedures provide automatic opening and initialization
  of printable Postscript or Encapsulated Postscript plot files. 

  Programs that produce a single drawing should use them as follows: 
  
    | o = ParseDrawFormatOptions(pp, single = TRUE);
    | ...
    | VAR f: PSStream *:= NIL;
    | {
    | ...
    |   pz_plot_begin_single_drawing(f, "foo", o);
    |   DrawFoo(f, ...);
    |   pz_plot_end_single_drawing(f, o)
    | ;}
  
  In this case, the output will go to a single file "foo.ps" or "foo.eps".
  
  Programs that produce multiple drawings should use instead
  
    | o = ParseDrawFormatOptions(pp, single = FALSE);
    | ...
    | VAR 
    |   f: PSStream *= NULL;
    | {
    | ...
    |   for ( iFoo = firstFoo TO lastFoo ){
    |     if (( worthPlotting[iFoo] )){
    |       pz_plot_begin_new_drawing(f, "foo", iFoo, o, nDrawn);
    |       DrawFoo(f, ...);
    |     ;}
    |   ;};
    |   pz_plot_no_more_drawings(f, o, nDrawn)
    | ;}
     
  In this case, if {o.epsFormat == FALSE}, all drawings go to a single
  file "XXX.ps", possibly several drawings per page. If {o.epsFormat ==
  TRUE}, each drawing goes to a separate file "XXX-NNNNN.eps", where
  NNNNN is specified by the argument {iFoo}.
  
  Note that {iFoo} (the drawing's ID number) is defined entirely by
  the client, while {nDrawn} (the number of drawings in the current
  file {f}) is managed internally by the procedures.
*/

void pz_plot_begin_new_drawing
  ( PSStream *f,
    char *outName,
    char *idDrawing,
    pz_plot_draw_fmt_options_t *o,
    int *nInFile 
  );
  /*
    Opens (if necessary) file {f} and prepares it for a new drawing.
    If {o.epsFormat} is {FALSE}, the file is opened only once, with
    name "XXX.ps" where {XXX} is the value of {outName}. If
    {o.epsFormat} is true, each drawing will be written to a separate
    file, with names "XXX-NNNNN.eps", where {NNNNN} is the value of
    {iDrawing}.  The {nInFile} parameter is managed by the procedure. */

void pz_plot_no_more_drawings
  ( PSStream *f,
    pz_plot_draw_fmt_options_t *o,
    int *nInFile 
  );
  /*
    To be called once after the last drawing started with {pz_plot_begin_new_drawing}.
    Will finalize the current drawing, close the file {f}, and set {f == NULL}. */

void pz_plot_begin_single_drawing
  ( PSStream *f,
    char *outName,
    pz_plot_draw_fmt_options_t *o 
  );
  /*
    Like {pz_plot_begin_new_drawing}, but appropriate if the program will produce
    only one drawing with the given {outName}. The only difference is
    that the output file name is simply "XXX.ps" or "XXX.eps". */

void pz_plot_end_single_drawing
  ( PSStream *f,
    pz_plot_draw_fmt_options_t *o 
  );
  /*
    To be called once after finishing the single drawing started by
    {pz_plot_begin_single_drawing} in {f}. Will finalize the drawing, close the
    file, and set {f == NULL}. */

======================================================================
from pzplot.c - multi-figure page control (now in pswr.c)

void pz_plot_begin_single_drawing
  ( PSStream *f,
    char *outName,
    pz_plot_draw_fmt_options_t *o 
  ) 
  VAR nInFile: int := 0;
  {
    assert(f == NULL );
    DoBeginDrawing(f, outName, "", o, nInFile);
  } /* pz_plot_begin_single_drawing */
  

void pz_plot_end_single_drawing
  ( PSStream *f,
    pz_plot_draw_fmt_options_t *o 
  )
  VAR nInFile: int := 1;
  {
    assert(f != NULL );
    DoEndDrawing(f, o, nInFile);
    if (NOT o->epsFormat){ pswr_close(f, ); f = NULL; }
  } /* pz_plot_end_single_drawing */
   

void pz_plot_begin_new_drawing
  ( PSStream *f,
    char *outName,
    char *idDrawing,
    pz_plot_draw_fmt_options_t *o,
    int *nInFile 
  ) 
  {
    if (f != NULL ) && ( nInFile > 0){ DoEndDrawing(f, o, nInFile); }
    DoBeginDrawing(f, outName, idDrawing, o, nInFile);
  } /* pz_plot_begin_new_drawing */
  

void pz_plot_no_more_drawings
  ( PSStream *f,
    pz_plot_draw_fmt_options_t *o,
    int *nInFile 
  )
  {
    if (f != NULL)
    { if (nInFile > 0){ DoEndDrawing(f, o, nInFile); }
      if (NOT o->epsFormat)
      { pswr_close(f, ); f = NULL; nInFile = 0;
      }
    }
  } /* pz_plot_no_more_drawings */
   

void DoBeginDrawing
  ( PSStream *f,
    char *outName,
    char *idDrawing,
    pz_plot_draw_fmt_options_t *o,
    int *nInFile 
  )
  /*
    Starts a new drawing, assuming that the previous one, 
    if any, has been completed by {DoEndDrawing}. */
  {
    if (o->epsFormat)
    { /* Start a new EPS file: */
      assert(nInFile == 0 );
      VAR fileName: char *;
      {
        if (NOT Text.Equal(idDrawing, "")) 
      {   fileName = outName & "-" & idDrawing & ".eps"
        }
        else
        { fileName = txtcat(outName , ".eps");
        }
        fprintf(stderr, "writing %s\n", fileName );  
        f = NEW(PSPlot.EPSFile).open(fileName, 
          xSize = o->actualWidth, 
          ySize = o->actualHeight
        );
      }
    }
    else
    {
      assert((nInFile == 0) == (f == NULL) );
      if (f == NULL)
      { /* Open one file for all plots: */

        { /* with */
          ??? name = txtcat(outName , ".ps");
          /* do */
          fprintf(stderr, "writing %s\n", name );  
          f = NEW(PSPlot.PSFile).open(name);;
        }
      }
      /* Must begin a new drawing */
      fprintf(stderr, "  " & idDrawing & "[" & Fmt.Int(nInFile) & "]\n");

      { /* with */ 
        ??? f = NARROW(f, PSPlot.PSFile);
        int nDrawingsPerPage = o->nCols * o->nRows;
        /* do */
        if (nInFile % nDrawingsPerPage == 0) 
      {   /* Must start a new page */
          pswr_beginPage(f, );;
        }
        /* Start a new drawing on the page: */

        { /* with */ 
          double totWidth = ((double)o->nCols) * o->actualWidth;
          double plotXMargin = 0.5 * (PSPlot.LetterXSize - totWidth);
          double plotYMargin = plotXMargin;
          int plotCol = nInFile % o->nCols;
          int plotRow = (o->nRows - 1) - (nInFile / o->nCols) % o->nRows;
          double xCenter = o->actualWidth  * (((double)plotCol) + 0.5) + plotXMargin;
          double yCenter = o->actualHeight * (((double)plotRow) + 0.5) + plotYMargin;
          /* do */
          pswr_beginDrawing(f, o->actualWidth, o->actualHeight, xCenter, yCenter);
          pswr_setTextColor(f, (r3_t){{0,0,0}}); /* For captions/labels */
          pswr_label(f, idDrawing, 
            x = 1.0 - 2.0/o->actualWidth,
            y = 1.0 - 2.0/o->actualHeight,
            xAlign = 1.0, yAlign = 1.0,
            angle = 0.0,
            font = "Courier",
            size = 8.0
          );
        }
      }
    }
    /* Set same plotting scale in X and Y: */

    { /* with */ 
      double dx = o->window->r[HOR].end[1] - o->window->r[HOR].end[0];
      double sx = o->actualWidth/dx;
      double dy = o->window->r[VER].end[1] - o->window->r[VER].end[0];
      double sy = o->actualHeight/dy;
      double scale = MAX(sx, sy);
      double hx = (o->actualWidth/scale - dx)/2.0;
      double hy = (o->actualHeight/scale - dy)/2.0;
      /* do */
      pswr_setScale(f, HOR, o->window->r[HOR].end[0] - hx, o->window->r[HOR].end[1] + hx);
      pswr_setScale(f, VER, o->window->r[VER].end[0] - hy, o->window->r[VER].end[1] + hy);;
    }
    nInFile++;
  } /* DoBeginDrawing */


void DoEndDrawing
  ( PSStream *f, 
    pz_plot_draw_fmt_options_t *o,
    int *nInFile 
  )
  {
    if (o->epsFormat)
    { /* Must close the file */
      pswr_close(f, ); f = NULL; nInFile = 0;
    }
    else
    {

      { /* with */
        ??? f = NARROW(f, PSPlot.PSFile);
        int nDrawingsPerPage = o->nCols * o->nRows;
        /* do */
        pswr_endDrawing(f, );
        if (nInFile % nDrawingsPerPage == 0){ pswr_endPage(f, ); }
      }
    }
  } /* DoEndDrawing */