s9fes-char-graphics (historical revision 44533)

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

s9fes-char-graphics

The Scheme 9 from Empty Space character graphics routines, and many extras. Features and API of the original are preserved, just extended.

Extras:

canvas properties
canvas print w/ frame
canvas polyline
canvas i/o
canvas clear, flood, copy, paste, scroll
multiple virtual-canvases
compositing
canvas sub-region (rect)
shape - circle, cross, box, image, w/ virtual methods
canvas character random-access is O(1)
canvas record printers

s9fes-char-graphics
Bugs & Limitations
Notes
Requirements
Author
Repository
Version history
License

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 (current-plotter-bkgd-char) initially.

new-canvas

[procedure] (new-canvas CANVAS WIDTH HEIGHT) -> canvas

Creates a canvas, sharing the char-canvas of CANVAS, but with a virtual size of WIDTH X HEIGHT "pixels".

canvas-duplicate

[procedure] (canvas-duplicate CANVAS) -> canvas

Returns a deep-copy of the CANVAS.

[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-real

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

Returns the real (physical) coordinates for the supplied virtual X Y.

canvas-virtual

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

Returns virtual coordinates for the supplied real (physical) X Y.

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

canvas-dump

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

Returns a (vector-of string) that contains the characters written to the canvas. The vector elements are the rows, the string code-points the columns.

Original API, an alias of canvas->vector now.

canvas-print

[procedure] (canvas-print CANVAS [FRAME])

Prints the CANVAS, one row per line, with an optional frame.

FRAME: (vector char char char char char char char char) ; top/bottom horizontal, top/bottom vertical, corner top left/right & bottom left/right chars; default #(#\- #\- #\| #\| #\+ #\+ #\+ #\+).
FRAME: #t ; use ASCII-FRAME-CHARS.
ASCII-FRAME-CHARS: #(#\- #\- #\| #\| #\+ #\+ #\+ #\+)
THIN-FRAME-CHARS: #(#\─ #\─ #\│ #\│ #\┌ #\┐ #\└ #\┘)
THICK-FRAME-CHARS: #(#\━ #\━ #\┃ #\┃ #\┏ #\┓ #\┗ #\┛)

string->canvas

[procedure] (string->canvas STR) -> canvas

Returns a canvas from the line-feed-encoded STR.

STR: string : string w/ embedded #\newline for each row.

with-output-to-canvas

[procedure] (with-output-to-canvas THUNK) -> canvas

Returns a canvas from the read output of THUNK. Useful for the result capture of other character graphics output as a canvas.

THUNK: (-> void) : writes to current-output-port.

Capture a plot:

(define *data* '(0 1 2 3 4 5 6 7 8 9))
(define data-plot (lambda () (char-plot *data* 'data 7 35 #f)))
(define data-plot-image (canvas->image (with-output-to-canvas data-plot)))

canvas->vector

[procedure] (canvas->vector CANVAS) -> (vector-of string)

Converts the CANVAS to a vector, row h-1 to row 0.

canvas->list

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

Converts the CANVAS to a list, row h-1 to row 0.

canvas->string

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

Converts the CANVAS to a string, row h-1 to row 0, delimited by #\newline.

current-plotter-char

[procedure] (current-plotter-char [CHAR]) -> char

current-plotter-bkgd-char

[procedure] (current-plotter-bkgd-char [CHAR]) -> char

Default char for clearing.

canvas-clear

[procedure] (canvas-clear CANVAS [RGN])

Uses the (current-plotter-bkgd-char) to clear the CANVAS RGN.

RGN: rect : canvas sub-area, default is whole canvas.

canvas-flood

[procedure] (canvas-flood CANVAS FILL [RGN]))

Cover the CANVAS RGN with the FILL char.

FILL: char : fill char, default (current-plotter-char).
RGN: rect : canvas sub-area, default is whole canvas.

canvas-scroll

[procedure] (canvas-scroll CANVAS [DX [DY [RGN]]])

Scroll the CANVAS RGN.

DX: integer : negative (left) or positive (right)
DY: integer : negative (up) or positive (down)
RGN: rect : canvas sub-area, default is whole canvas.

canvas-copy

[procedure] (canvas-copy CANVAS [RGN [TRANS]]) -> canvas

Copy the CANVAS RGN, clipping the RGN to fit if necessary.

RGN: rect : canvas sub-area, default is whole canvas.
TRANS: (char char fixnum fixnum) ; transformation function (see canvas-paste)

canvas-paste

[procedure] (canvas-paste CANVAS SOURCE-CANVAS [X [Y [TRANS]]])

Paste the SOURCE-CANVAS into CANVAS at lower-left X Y, clipping the SOURCE-CANVAS to fit if necessary.

X: integer : x, default is 0
Y: integer : y, default is 0
TRANS: (char char fixnum fixnum -> char) ; result char is function of source char+index & target+index.

The operation is performed, in the absence of a transformation function, as if (lambda (t s i j) s) was specified, i.e. overwrite.

Example of transform as used by the image shape:

(define ((compositor-alpha #!optional
                           (c (current-plotter-bkgd-char)))
          tc sc i j)
  (if (char=? c sc) tc sc) )

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 X0 Y0 X1 Y1 [CHAR])

Plots a line from X0 Y0 to X1 Y1, using CHAR.

X0 Y0 X1 Y1: fixnum ; .
CHAR: char ; drawing character, default (current-plotter-char).

canvas-plot-lines

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

LINES: (list-of integer) ; list of line segment x y.
CONFIG: (or false char (list-of (or false char))) ; drawing pattern, n elements, #f for skip or a char to draw; default is (current-plotter-char).

canvas-clear-chars

[procedure] (canvas-clear-chars CANVAS [RGN])

Uses the (current-plotter-bkgd-char) to clear the CANVAS RGN.

RGN: char-rect : canvas sub-area, default is whole canvas.

canvas-flood-chars

[procedure] (canvas-flood-chars CANVAS FILL [RGN]))

Fill the CANVAS RGN with the FILL.

FILL: char : fill char, default (current-plotter-char).
RGN: char-rect : canvas sub-area, default is whole canvas.

canvas-scroll-chars

[procedure] (canvas-scroll-chars CANVAS [DX [DY [RGN]]])

Scroll the CANVAS RGN.

DX: fixnum : columns negative (left) or positive (right)
DY: fixnum : rows negative (up) or positive (down)
RGN: char-rect : canvas sub-area, default is whole canvas.

canvas-copy-chars

[procedure] (canvas-copy-chars CANVAS [RGN [TRANS]]) -> canvas

Copy the CANVAS RGN.

RGN: char-rect : canvas sub-area, default is whole canvas.
TRANS: (char char fixnum fixnum) ; transformation function (see canvas-paste)

canvas-paste-chars

[procedure] (canvas-paste-chars CANVAS SOURCE-CANVAS [X [Y [TRANS]]])

Paste the SOURCE-CANVAS into CANVAS at lower-left X Y.

X: fixnum : x, default is 0
Y: fixnum : y, default is 0
TRANS: (char char fixnum fixnum) ; transformation function (see canvas-paste)

The returned canvas is the TARGET-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, CHAR 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-draw-line

[procedure] (canvas-draw-line CANVAS X0 Y0 X1 Y1 [CHAR])

Draws a line from X0 Y0 to X1 Y1, using CHAR.

X0 Y0 X1 Y1: fixnum ; .
CHAR: char ; drawing character, default (current-plotter-char).

canvas-draw-lines

[procedure] (canvas-draw-lines CANVAS LINES [CONFIG])

LINES: (list-of fixnum) ; list of line segment x y.
CONFIG: (or false char (list-of (or false char))) ; drawing pattern, n elements, #f for skip or a char to draw; default is (current-plotter-char).

make-char-canvas

char-canvas?

char-canvas-columns

char-canvas-rows

char-canvas-cmap

[procedure] (make-char-canvas COLS ROWS CHAR-OR-CMAP) -> char-canvas
[procedure] (char-canvas? OBJ) -> boolean
[procedure] (char-canvas-columns CHAR-CANVAS) -> fixnum
[procedure] (char-canvas-rows CHAR-CANVAS) -> fixnum
[procedure] (char-canvas-cmap CHAR-CANVAS) -> cmap

Char Canvas Rectangle

Usage

(import (s9fes char-canvas rect))

Shared Arguments & Types:

X Y: integer integer : position - x (column) & y (row) .
WD HT: integer integer : size - width (columns) & height (rows).

rect

rect?

rect-x

rect-y

rect-wd

rect-ht

[procedure] (rect X Y WD HT) -> rect
[procedure] (rect? OBJ) -> boolean
[procedure] (rect-x RECT) -> integer
[procedure] (rect-y RECT) -> integer
[procedure] (rect-wd RECT) -> integer
[procedure] (rect-ht RECT) -> integer

rect-x-end

[procedure] (rect-x-end RECT) -> integer

One beyond the canvas horizontal.

rect-y-end

[procedure] (rect-y-end RECT) -> integer

One beyond the canvas vertical.

rect-x-min

[procedure] (rect-x-min RECT) -> integer

Same as rect-x. For symmetry.

rect-y-min

[procedure] (rect-y-min RECT) -> integer

Same as rect-y. For symmetry.

rect-x-max

[procedure] (rect-x-max RECT) -> integer

Right-most horizontal coordinate.

rect-y-max

[procedure] (rect-y-max RECT) -> integer

Top-most vertical coordinate.

rect-copy

[procedure] (rect-copy RECT) -> rect

rect-null

[procedure] (rect-null) -> rect

Returns an empty rectangle.

rect-null?

[procedure] (rect-null? OBJ) -> boolean

Is the rectangle empty? (0 rect-wd or rect-ht)

rect-bias

[procedure] (rect-bias RECT DX DY) -> rect

Shift the RECT by DX in the horizontal and DY in the vertical. Does not change the size.

DX: integer : negative (left) or positive (right)
DY: integer : negative (up) or positive (down)

rect-scale

[procedure] (rect-scale RECT SX SY) -> rect

Grow the RECT by SX in the horizontal and SY in the vertical. Does not change the position.

SX: integer : negative (thin) or positive (widen)
SY: integer : negative (shorten) or positive (lengthen)

rect-bias!

[procedure] (rect-bias! RECT DX DY) -> rect

Bias the RECT in-place.

rect-scale!

[procedure] (rect-scale! RECT SX SY) -> rect

Scale the RECT in-place.

rect->list

[procedure] (rect->list RECT) -> (list integer integer integer integer)

list->rect

[procedure] (list->rect LS) -> rect

LS: (list integer integer integer integer)

canvas->rect

[procedure] (canvas->rect CANVAS) -> rect

Returns a rect from the CANVAS dimensions.

char-rect?

[procedure] (char-rect? OBJ) -> boolean

Note that a char-rect is-a rect, just restricted to fixnum.

char-canvas->rect

[procedure] (char-canvas->rect CHAR-CANVAS) -> rect

real-rect

[procedure] (real-rect CANVAS RECT) -> rect

Returns the rectangle in the real (physical) coordinate system.

virtual-rect

[procedure] (virtual-rect CANVAS RECT) -> rect

Returns the rectangle in the virtual coordinate system.

rect-area

[procedure] (rect-area RECT) -> integer

Returns the size of the rectangle.

rect-smaller?

[procedure] (rect-smaller? RECT1 RECT2) -> boolean

rect-larger?

[procedure] (rect-larger? RECT1 RECT2) -> boolean

rect-relates

[procedure] (rect-relates RECT1 RECT2) -> (list-of symbol)

Returns a, possibly empty, list of symbols describing the spatial relationship of RECT1 & RECT2.

left right: x
above below: y
thinner wider: width
shorter taller: height

rect-union

[procedure] (rect-union RECT1 RECT2) -> rect

Returns the encompassing rectangle of RECT1 & RECT2.

rect-intersection

[procedure] (rect-intersection RECT1 RECT2) -> rect

Returns the overlapping rectangle of RECT1 & RECT2, which may be empty.

rect-overlaps?

[procedure] (rect-overlaps? RECT1 RECT2) -> boolean

Does RECT1 intersect RECT2?

Char Canvas Shape Shared Arguments & Types:

Shapes are functions, either taking no arguments and returning the constructing parameters, or taking at least a canvas, rendering the shape, then returning the canvas.

real-shape-plotter: ([CANVAS [X0 [Y0]]] -> (or CANVAS PARAMS))
X0 Y0: fixnum fixnum ; center
PARAMS: (list symbol symbol ...) ; defining parameters (from the constructor)
shape-plotter: ([CANVAS [X0 [Y0]]] -> (or CANVAS PARAMS))
X0 Y0: integer integer ; center
PARAMS: (list symbol symbol ...) ; defining parameters (from the constructor)

real-shape-plotter is-a shape-plotter, just restricted to real coordinates.

The PARAMS are prefixed with a shape kind & coordinate-system.

Char Canvas Shape Shape

Usage

(import (s9fes char-canvas shape shape))

Shared Arguments & Types

SHAPE: shape-plotter ; argument type, includes real-shape-plotter

All error when the {SHAPE}} is unknown.

shape-size

[procedure] (shape-size SHAPE) -> integer integer

Returns the width & height (columns & rows) for the SHAPE.

shape-cardinality

[procedure] (shape-cardinality SHAPE) -> fixnum

Count of grouped shapes.

shape-elements

[procedure] (shape-elements SHAPE) -> (list-of SHAPE)

Grouped shapes.

shape-layout

[procedure] (shape-layout SHAPE) -> SHAPE

Returns a static SHAPE (no elastic elemetns) for the supplied SHAPE.

shape-show

[procedure] (shape-show SHAPE CANVAS X Y) -> canvas

By default (SHAPE CANVAS X Y), but up to the SHAPE.

shape-fold

[procedure] (shape-fold SHAPE FUNC SEED) -> SEED-TYPE

SEED-TYPE: 'a ; type-of SEED
FUNC: (shape-plotter 'a -> 'a) ;

registered-shapes

[procedure] (registered-shapes) -> (list-of symbol)

registered-shape-methods

[procedure] (registered-shape-methods ID) -> (list-of symbol)

ID: symbol : shape name

Char Canvas Shape Box

Usage

(import (s9fes char-canvas shape box))

Shared Arguments & Types

FRAME: (vector char char char char char char char char) ; top/bottom horizontal, top/bottom vertical, corner top left/right & bottom left/right chars; default #(#\- #\- #\| #\| #\+ #\+ #\+ #\+).
FRAME: #t ; use ASCII-FRAME-CHARS.

real-shape-box

[procedure] (real-shape-box WD HT [FRAME]) -> real-shape-plotter

WD: fixnum ; width
HT: fixnum ; height

shape-box

[procedure] (shape-box WD HT [FRAME]) -> shape-plotter

WD: integer ; width
HT: integer ; height

Char Canvas Shape Circle

Usage

(import (s9fes char-canvas shape circle))

Shared Arguments & Types:

octant-plotter: (canvas fixnum fixnum fixnum fixnum -> boolean) ; returns continue?
octant-visitor: (canvas fixnum fixnum -> boolean) ; returns continue?

real-shape-circle

[procedure] (real-shape-circle R [CONFIG]) -> real-shape-plotter

R: fixnum ; radius
CONFIG: (or false char (list-of (or false char))) ; octant drawing pattern, 8 elements, octant 0 to octant 8, #f for skip or a char to draw; default is (current-plotter-char).

shape-circle

[procedure] (shape-circle R [CONFIG]) -> shape-plotter

R: integer ; radius
CONFIG: (or false char (list-of (or false char))) ; octant drawing pattern, 8 elements, octant 0 to octant 8, #f for skip or a char to draw; default is (current-plotter-char).

(import (s9fes char-canvas) (s9fes char-canvas shape circle))

(define canvas-plot-circle@40 (shape-circle 40))

(let ((cv (make-canvas 10 10 100 100)))
  (canvas-plot-circle@40 cv 50 50)
  (canvas-print cv #t) )
;=>
+----------+
|    ***   |
|   *   *  |
|  *     * |
| *       *|
| *       *|
| *       *|
|  *     * |
|   *   *  |
|    ***   |
|          |
+----------+

circle-polygon-lines

[procedure] (circle-polygon-lines X0 Y0 RADIUS [N [ANGLE]) -> (list-of integer)

Returns a list of virtual coordinates suitable for use w/ canvas-plot-lines. A closed, convex, polygon is described.

X0 Y0: integer integer ; circle center in virtual coordinates
RADIUS: integer ; circle radius in virtual coordinates
N: fixnum ; number of points ; default 360
ANGLE: fixnum ; starting degree ; default 0

(import (s9fes char-canvas) (s9fes char-canvas shape circle))

(let ((cv (make-canvas 10 10 100 100)))
  (canvas-plot-lines cv (circle-polygon-lines 50 50 50))
  (canvas-print cv) )
;=>
  ******
 *      *
*        *
*        *
*        *
*        *
*        *
*        *
 *      *
  ******

Note how restricting the number of segments coarsens the image, even clipping. ((circle-polygon-lines 50 50 49 4) produces an ok diamond.)

(let ((cv (make-canvas 10 10 100 100)))
  (canvas-plot-lines cv (circle-polygon-lines 50 50 50 4))
  (canvas-print cv #t) )
;=>
+----------+
|    * *   |
|   *   *  |
|  *     * |
| *       *|
|*         |
| *       *|
|  *    ** |
|  *   *   |
|   * *    |
|    *     |
+----------+

circle-octant-plotter

[procedure] (circle-octant-plotter [CONFIG]) -> octant-plotter

Returns a canvas-drawing procedure for the specified octant drawing pattern CONFIG.

CONFIG: (or false char (list-of (or false char))) ; octant drawing pattern, 8 elements, octant 0 to octant 8, #f for skip or a char to draw; default is (current-plotter-char).

generate-circle-octant

[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: octant-visitor

circle-octant-point

[procedure] (circle-octant-point OCTANT X0 Y0 X Y) -> fixnum fixnum

Returns coordinates for octant 0 point X Y in the specified OCTANT, center at X0 Y0.

OCTANT: fixnum ; octant, 0..7, coordinates to calculate
X0 Y0: fixnum fixnum ; center
X Y: fixnum fixnum ; offset

circle-octant-visitor

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

X0 Y0: fixnum fixnum ; center
PLOTTER: octant-plotter

generate-virtual-circle-octant

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

Same as generate-circle-octant but w/ virtual coordinates (see above).

RADIUS: integer ; radius
VISITOR: octant-visitor

(import (s9fes char-canvas) (s9fes char-canvas shape circle))

(define (canvas-draw-circle cv c r w #!optional (pl (circle-octant-plotter)))
  (generate-circle-octant cv w (circle-octant-visitor c r pl)) )

(let* ((rw 5) (cl 5)
       (cr (quotient rw 2)) (cc (quotient cl 2)) (rd cc)
       (cv (make-canvas cl rw)) )
  (canvas-draw-circle cv cc cr rd)
  (canvas-print cv) )
;=>
 ***
*   *
*   *
*   *
 ***

virtual-circle-octant-visitor

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

Same as circle-octant-visitor but w/ virtual coordinates (see above).

X0 Y0: integer integer ; center
PLOTTER: octant-plotter

(import (s9fes char-canvas) (s9fes char-canvas shape circle))

(define (canvas-plot-circle cv x y r #!optional (pl (circle-octant-plotter)))
  (generate-virtual-circle-octant cv r (virtual-circle-octant-visitor x y pl)) )

(let* ((rw 5) (cl 5) (wd 100) (ht 250)
       (x0 (round (/ wd 2))) (y0 (round (/ ht 2))) (rd y0)
       (cv (make-canvas rw cl wd ht)) )
  (canvas-plot-circle cv x0 y0 rd)
  (canvas-print cv) )
;=>
 ***
*   *
*   *
*   *
 ***

Char Canvas Shape Cross

Usage

(import (s9fes char-canvas shape cross))

real-shape-cross--

|real-shape-cross-\||

real-shape-cross-+

[procedure] (real-shape-cross-- WD [HT [CONFIG]]) -> real-shape-plotter
[procedure] (|real-shape-cross-\|| WD [HT [CONFIG]]) -> real-shape-plotter
[procedure] (real-shape-cross-+ WD [HT [CONFIG]]) -> real-shape-plotter

WD: fixnum
HT: fixnum ; default WD
CONFIG: (or false char (list-of (or false char))) ; drawing pattern, 2 elements, #f for skip or a char to draw; default is (current-plotter-char).

|real-shape-cross-\\|

real-shape-cross-/

real-shape-cross-x

[procedure] (|real-shape-cross-\\| WD [HT [CONFIG]]) -> real-shape-plotter
[procedure] (real-shape-cross-/ WD [HT [CONFIG]]) -> real-shape-plotter
[procedure] (real-shape-cross-x WD [HT [CONFIG]]) -> real-shape-plotter

WD: fixnum
HT: fixnum ; default WD
CONFIG: (or false char (list-of (or false char))) ; drawing pattern, 2 elements, #f for skip or a char to draw; default is (current-plotter-char).

shape-cross--

|shape-cross-\||

shape-cross-+

[procedure] (shape-cross-- WD [HT [CONFIG]]) -> shape-plotter
[procedure] (|shape-cross-\|| WD [HT [CONFIG]]) -> shape-plotter
[procedure] (shape-cross-+ WD [HT [CONFIG]]) -> shape-plotter

WD: integer
HT: integer ; default WD
CONFIG: (or false char (list-of (or false char))) ; drawing pattern, 2 elements, #f for skip or a char to draw; default is (current-plotter-char).

|shape-cross-\\|

shape-cross-/

shape-cross-x

[procedure] (|shape-cross-\\| WD [HT [CONFIG]]) -> shape-plotter
[procedure] (shape-cross-/ WD [HT [CONFIG]]) -> shape-plotter
[procedure] (shape-cross-x WD [HT [CONFIG]]) -> shape-plotter

WD: integer
HT: integer ; default WD
CONFIG: (or false char (list-of (or false char))) ; drawing pattern, 2 elements, #f for skip or a char to draw; default is (current-plotter-char).

(import (s9fes char-canvas) (s9fes char-canvas shape cross))

(define canvas-plot-x@100x100 (shape-cross-x 100))

(let ((cv (make-canvas 10 5 100 100)))
  (canvas-plot-x@100x100 cv)
  (canvas-print cv) )
;=>
**      **
  **  **
    **
  **  **
**      **

Char Canvas Shape image

Usage

(import (s9fes char-canvas shape image))

read-image

write-image

load-image

store-image

canvas->image

string->image

real-shape-image

shape-image

[procedure] (read-image [IN]) -> image
[procedure] (write-image IMAGE [OUT])
[procedure] (load-image PATH) -> image
[procedure] (store-image IMAGE PATH)
[procedure] (canvas->image CANVAS) -> image
[procedure] (string->image STR) -> image

images are "composited" using the (current-plotter-bkgd-char) as the "alpha-channel". Source background is ignored and only foreground characters are placed. (see canvas-paste)

[procedure] (real-shape-image IMAGE [TRANS]]) -> real-shape-plotter
[procedure] (shape-image IMAGE [TRANS]]) -> shape-plotter

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

Bugs & Limitations

None. A thing of beauty.

Notes

Shape position as the center is different. The lower-left is probably expected.
The plot/virtual API with the draw/real distinction follows the original pattern. However, except as implementation details, using the draw/real is unlikely to be worth the effort. For performance have pixels always be chars: don't specify a virtual canvas size.

Requirements

utf8 srfi-1 format record-variants

test test-utils

The format extension is only used by the (s9fes char-plot) module.

Author

Kon Lovett

Repository

This egg is hosted on the CHICKEN Subversion repository:

https://anonymous@code.call-cc.org/svn/chicken-eggs/release/5/s9fes-char-graphics

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.15.3: Fix shape-cardinality & shape-elements.
1.15.2: Add registered-shape-methods, shape-cardinality, shape-elements, shape-layout, shape-show, shape-fold
1.15.1: Shape configuration information includes kind & coordinate-system. Add (s9fes char-canvas shape shape) & shape-size.
1.15.0: Remove (draw|plot)-(box|image|circle. {Rename icon' to image''.(s9fes char-canvas shape icon) => (s9fes char-canvas shape image), shape-icon => shape-image.
1.14.6: Rename oval to circle: (s9fes char-canvas shape oval) => (s9fes char-canvas shape circle), shape-oval => shape-circle.
1.14.5: Rename shape- => real-shape- & virtual-shape- to shape-.
1.14.4: Rename physical to real. Add virtual-rect.
1.14.3: Add copy & paste clipping.
1.14.2: Add canvas && char-canvas record printers. Better "too big" paste error.
1.14.1: Add canvas->image & canvas-duplicate.
1.14.0: Add "compositing" to canvas-copy, canvas-paste]canvas-copy-chars, canvas-paste-chars], shape-image, & shape-image.
1.13.0: Add (s9fes char-canvas shape image) module.
1.12.1: Fix box shape plotter position.
1.12.0: Rename to (s9fes char-canvas rect). Add rect-null, rect-null?, rect-area, rect-overlaps?, rect-union, rect-intersection, rect-smaller?, rect-larger?, rect-relates.
1.11.0: Add string->canvas & with-output-to-canvas. canvas-print takes optional frame (remove canvas-print/frame). Add (s9fes char-canvas shape box).
1.10.0: Add canvas-print/frame, new-canvas, canvas-flood, canvas-scroll, canvas-copy, canvas-paste, canvas-flood-chars, canvas-scroll-chars, canvas-copy-chars, canvas-paste-chars, canvas->list, canvas->vector. Add (s9fes rect) module. Add shape introspection.
1.9.1: shape-oval & shape-oval proper shapes (optional center).
1.9.0: Add shape-oval & shape-oval.
1.8.1: Fix (s9fes char-canvas shape cross) naming, again.
1.8.0: Fix (s9fes char-canvas shape cross) naming.
1.7.1: Smaller.
1.7.0: Fix shape-point-plotter, takes center, not top-left. Add cross-x-drawer & cross-+-drawer.
1.6.0: Add canvas-draw-line & canvas-draw-lines.
1.5.0: .
1.4.4: Prevent division-by-zero in canvas-plot-line.
1.4.3: .
1.4.2: .
1.4.1: .
1.4.0: Add current-plotter-char, shape oval & shape cross.
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