s9fes-char-graphics (historical revision 42658)

You are looking at historical revision 42658 of this page. It may differ significantly from its current revision.

s9fes-char-graphics

The Scheme 9 from Empty Space character graphics routines.

Char Canvas

This is a set of routines for drawing characters and lines on a scaled, character-based (a.k.a. "ASCII Art") canvas.

Assumes one character per column. Do not use wide characters.

Usage

(import (s9fes char-canvas))

make-canvas

[procedure] (make-canvas COLUMNS ROWS [WIDTH [HEIGHT]]) => canvas

Creates a character canvas with a physical size of COLUMNS X ROWS characters. The virtual size of the canvas is WIDTH X HEIGHT "pixels".

"Real coordinates" relate to the physical size of the canvas. "Virtual coordinates" are translated to real coordinates by scaling. Both types of coordinates are specified in X/Y notation.

The origin 0/0 is at the lower left corner of the canvas. The new canvas will be filled with blanks initially.

[procedure] (canvas? OBJ) => boolean
[procedure] (canvas-columns CANVAS) => fixnum
[procedure] (canvas-rows CANVAS) => fixnum
[procedure] (canvas-width CANVAS) => integer
[procedure] (canvas-height CANVAS) => integer

canvas-physical

[procedure] (canvas-physical CANVAS X Y) -> X Y

Returns the physical coordinates for the supplied virtual X Y.

canvas-virtual

[procedure] (canvas-virtual CANVAS X Y) -> X Y

Returns virtual coordinates for the supplied physical X Y.

Note canvas-virtual <=> canvas-physical is not guaranteed. So this routine is of little use.

canvas-dump

[procedure] (canvas-dump CANVAS) => (list-of string)

Returns a list of strings that contain the characters written to the canvas. The list elements are the rows, the strings the columns.

canvas-print

[procedure] (canvas-print CANVAS)

Prints the CANVAS, one row per line.

canvas->string

[procedure] (canvas-string CANVAS) => string

Prints the CANVAS to a string.

canvas-clear

[procedure] (canvas-clear CANVAS)

canvas-draw

[procedure] (canvas-draw CANVAS X Y CHAR)

Draws character CHAR at position X/Y. It uses real coordinates. When the X or Y coordinate is outside of the canvas, C will not be drawn.

canvas-draw-string

[procedure] (canvas-draw-string CANVAS X Y STRING)

Draws a STRING at position X/Y. It uses real coordinates. When STRING extends beyond the limits of the canvas, it will be clipped.

canvas-plot

[procedure] (canvas-plot CANVAS X Y CHAR)

Draws the character CHAR at the virtual position X/Y.

Draws a line from the virtual position X/Y to DX/DY using the character CHAR. All arguments must be integers. Lines originating or extending outside of the canvas will be clipped.

canvas-plot-string

[procedure] (canvas-plot-string CANVAS X Y STRING)

Draws a STRING at virtual position X/Y. When STRING extends beyond the limits of the canvas, it will be clipped.

canvas-plot-line

[procedure] (canvas-plot-line CANVAS X Y DX DY CHAR)

(let ((c (make-canvas 10 5 10 10)))
  (canvas-plot-line c 0 9 9 0 #\#)
  (canvas-plot-line c 0 0 9 9 #\*)
  (pp (canvas-dump c)) )
=>
("##      **"
 "  ##  **  "
 "    **    "
 "  **  ##  "
 "**      ##")

canvas-plot-lines

[procedure] (canvas-plot-lines CANVAS LINES CHAR)

LINES: (list-of integer) ; list of line segment x y.

generate-circle-octant

circle-octant-visitor

[procedure] (generate-circle-octant CANVAS RADIUS VISITOR)

Generates the coordinates for the first octant of a circle of RADIUS. It uses real coordinates. The VISITOR is called for each generated point. Should the VISITOR return #f the generator halts early.

RADIUS: fixnum ; radius
VISITOR: (canvas fixnum fixnum -> boolean)

[procedure] (circle-octant-visitor X0 Y0 PLOTTER) => VISITOR

X0 Y0: fixnum fixnum ; center

(PLOTTER canvas x0 y0 x y)

PLOTTER: (canvas fixnum fixnum fixnum fixnum -> boolean) ; returns continue?

(VISITOR canvas x y)

VISITOR: (canvas fixnum fixnum -> boolean) ; returns continue?

circle-octant-coordinates

[procedure] (circle-octant-coordinates (X0 Y0 X Y) => fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum fixnum

Returns the physical coordinates of all 8 octants for the center X0 Y0 & first octant point X Y, as 8 sets of x y fixnums.

X0 Y0: fixnum fixnum ; center
X Y: fixnum fixnum ; 1st octant point

(let ((c (make-canvas 10 10 10 10)))
  (define (visit cv x0 y0 x y)
    (let-values (((xr0 yr0 xr1 yr1 xr2 yr2 xr3 yr3 xr4 yr4 xr5 yr5 xr6 yr6 xr7 yr7)
                  (circle-octant-coordinates x0 y0 x y)) )
      (canvas-draw cv xr0 yr0 #\0)
      (canvas-draw cv xr1 yr1 #\1)
      (canvas-draw cv xr2 yr2 #\2)
      (canvas-draw cv xr3 yr3 #\3)
      (canvas-draw cv xr4 yr4 #\4)
      (canvas-draw cv xr5 yr5 #\5)
      (canvas-draw cv xr6 yr6 #\6)
      (canvas-draw cv xr7 yr7 #\7)
      #t ) )
  (generate-circle-octant c 2 (circle-octant-visitor 5 5 visit))
  (generate-circle-octant c 4  (circle-octant-visitor 5 5 visit))
  (canvas-dump c) )
=>
("    221   "
 "   2   1  "
 "  3 221 0 "
 " 3 3   0 0"
 " 4 4   7 7"
 " 4 4   7 7"
 "  4 566 7 "
 "   5   6  "
 "    566   "
 "          ")

Char Plot

Usage

(import (s9fes char-plot))

char-plot

[procedure] (char-plot LIST SYMBOL HEIGHT WDITH [COMPR?])

Creates a character canvas (see make-canvas), marks the data points in LIST with #\X and draws a line through the points with #\-. SYMBOL will be used to label the X axis (on which the data points will be distributed).

HEIGHT and WDITH specify the physical dimensions of the char canvas. Its virtual dimensions will be computed in such a way that all data points can be displayed.

When the COMPR? (compression) argument is set to #t, then the X axis will start at the magnitude of the least data point instead of zero, so that the entire width of the canvas is available for distributing the supplied data points. The default is #t.

(char-plot '(0 1 2 3 4 5 6 7 8 9) 'foo 7 35 #f)</procedure>
=>
----------- foo --> -----------------
|                              -X   |
|                          --X-     |
|                   --X--X-         |
|                -X-                |
|         -X---X-                   |
|     --X-                          |
|X--X-                              |
----------- foo --> -----------------

Draw Tree

Usage

(import (s9fes draw-tree))

draw-tree

[procedure] (draw-tree ROOT [MAX-WIDTH])

Draws a character graphic representation of the tree LIST on (current-output-port).

ROOT: pair ; tree root node.
MAX-WIDTH: fixnum ; maximum printed node width, in characters. default is 7.

(draw-tree '((a) (b . c) (d e)))
=>
[o|o]---[o|o]---[o|/]
  |       |       |
[o|/]     |     [o|o]---[o|/]
  |       |       |       |
  a       |       d       e
          |
        [o|o]---  c
          |
          b

If you want to check out the source code repository of this egg and you are not familiar with Subversion, see this page.

Version history

1.3.2: Fix octant stream.
1.3.1: Fix canvas? type.
1.3.0: Add generate-circle-octant & friends.
1.2.0: Add canvas-plot-string.
1.1.0: Add canvas-print, canvas-physical, canvas-virtual.
1.0.1: .
1.0.0: Initial release.

License

Public Domain