The cl-vectors Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-vectors Reference Manual

This is the cl-vectors Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:07:25 2022 GMT+0.

Table of Contents


1 Introduction

cl-vectors
==========

This library is released under the MIT license. See the MIT-LICENSE
file which should be included in the present distribution.

The project homepage can be found at the following URL:

  http://projects.tuxee.net/cl-vectors/

The latest sources can be found on GitHub:

  https://github.com/fjolliton/cl-vectors

Changes
-------

 version 0.1.5 - 2013-02-13

  - the project is now released under the MIT license.  It was
    previously offered under the LLGPL license.

 version 0.1.4b - 2010-09-25

  - added doc.lisp which contains the code used to generate the images
    for the documentation. The `show-annotated-path' can be useful to
    experiment with cl-vectors.

  - added paths:path-transform-as-marker (see documentation)

 version 0.1.3 - 2007-03-14

  - fixed paths:filter-distinct to better choose knots to keep (really
    eliminating zero length interpolation.)

  - extended cl-aa protocol to provide a way to sweep only a
    rectangular zone of the resulting state. (New functions are
    freeze-state, scanline-sweep, scanline-y and
    cells-sweep/rectangle.)

  - added a version of cl-aa specialized for rendering non-antialiased
    polygon, named aa-bin and included in the cl-aa system definition.

 version 0.1.2 - 2007-03-08

  - fixed make-circle-path. A bug prevented circle creation with non
    positive coordinates. Also, the circle path doesn't include the
    zero-length straight line anymore (it was here for historical
    reason.)

  - fixed dash transformation when processing arcs. The resultings
    chunk of arcs were not correctly specified for the :large-arc-flag
    attribute (it was false all the time.)

  - vectors:update-state now accept either a path or a list of paths.

 version 0.1.1 - 2007-03-06

  - fixed cl-aa.asd system definition ("cl-aa" -> "aa").
    Thanks to Ivan Toshkov.

 version 0.1 - 2007-03-06

  - Initial release.


2 Systems

The main system appears first, followed by any subsystem dependency.


Next: , Previous: , Up: Systems   [Contents][Index]

2.1 cl-vectors

cl-paths: vectorial paths manipulation

Author

Frederic Jolliton <frederic@jolliton.com>

License

MIT

Dependencies
Source

cl-vectors.asd.

Child Component

vectors.lisp (file).


Next: , Previous: , Up: Systems   [Contents][Index]

2.2 cl-aa

cl-aa: polygon rasterizer

Author

Frederic Jolliton <frederic@jolliton.com>

License

MIT

Source

cl-aa.asd.

Child Components

Previous: , Up: Systems   [Contents][Index]

2.3 cl-paths

cl-paths: vectorial paths manipulation

Author

Frederic Jolliton <frederic@jolliton.com>

License

MIT

Source

cl-paths.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 cl-vectors/cl-vectors.asd

Source

cl-vectors.asd.

Parent Component

cl-vectors (system).

ASDF Systems

cl-vectors.


3.1.2 cl-aa/cl-aa.asd

Source

cl-aa.asd.

Parent Component

cl-aa (system).

ASDF Systems

cl-aa.


3.1.3 cl-paths/cl-paths.asd

Source

cl-paths.asd.

Parent Component

cl-paths (system).

ASDF Systems

cl-paths.


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.4 cl-vectors/vectors.lisp

Source

cl-vectors.asd.

Parent Component

cl-vectors (system).

Packages

net.tuxee.vectors.

Public Interface

update-state (function).


3.1.5 cl-aa/aa.lisp

Source

cl-aa.asd.

Parent Component

cl-aa (system).

Packages

net.tuxee.aa.

Public Interface
Internals

3.1.6 cl-aa/aa-bin.lisp

Source

cl-aa.asd.

Parent Component

cl-aa (system).

Packages

net.tuxee.aa-bin.

Public Interface
Internals

3.1.7 cl-paths/paths-package.lisp

Source

cl-paths.asd.

Parent Component

cl-paths (system).

Packages

net.tuxee.paths.


3.1.8 cl-paths/paths.lisp

Dependency

paths-package.lisp (file).

Source

cl-paths.asd.

Parent Component

cl-paths (system).

Public Interface
Internals

Previous: , Up: Lisp   [Contents][Index]

3.1.9 cl-paths/paths-annotation.lisp

Dependencies
Source

cl-paths.asd.

Parent Component

cl-paths (system).

Public Interface

path-annotated (function).


4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 net.tuxee.aa-bin

Source

aa-bin.lisp.

Nickname

aa-bin

Use List

common-lisp.

Public Interface
Internals

4.2 net.tuxee.aa

Source

aa.lisp.

Nickname

aa

Use List

common-lisp.

Used By List

net.tuxee.vectors.

Public Interface
Internals

Next: , Previous: , Up: Packages   [Contents][Index]

4.3 net.tuxee.vectors

Source

vectors.lisp.

Nickname

vectors

Use List
Public Interface

update-state (function).


Previous: , Up: Packages   [Contents][Index]

4.4 net.tuxee.paths

Source

paths-package.lisp.

Nickname

paths

Use List

common-lisp.

Used By List

net.tuxee.vectors.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


5.1.1 Special variables

Special Variable: *arc-length-tolerance*

The maximum length of segment describing an arc.

Package

net.tuxee.paths.

Source

paths.lisp.

Special Variable: *bezier-angle-tolerance*

The default angle tolerance (in radian) used when rendering Bezier curves

Package

net.tuxee.paths.

Source

paths.lisp.

Special Variable: *bezier-distance-tolerance*

The default distance tolerance used when rendering Bezier curves.

Package

net.tuxee.paths.

Source

paths.lisp.


5.1.2 Ordinary functions

Function: cells-sweep (state function &optional span-function)

Call FUNCTION for each pixel on the polygon path described by previous call to LINE or LINE-F. The pixels are scanned in increasing Y, then on increasing X. For optimization purpose, the optional FUNCTION-SPAN, if provided, is called for a full span of identical alpha pixel. If not provided, a call is made to FUNCTION for each pixel in the span.

Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: cells-sweep (state function &optional function-span)

Call FUNCTION for each pixel on the polygon described by previous call to LINE or LINE-F. The pixels are scanned in increasing Y, then on increasing X.

For optimization purpose, the optional FUNCTION-SPAN, if provided, is called for a full span of identical alpha pixel. If not provided, a call is made to FUNCTION for each pixel in the span.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: cells-sweep/rectangle (state x1 y1 x2 y2 function &optional function-span)

Call FUNCTION for each pixel on the polygon described by previous call to LINE or LINE-F. The pixels are scanned in increasing Y, then on increasing X. This is limited to the rectangle region specified with (X1,Y1)-(X2,Y2) (where X2 must be greater than X1 and Y2 must be greater than Y1, to describe a non-empty region.)

For optimization purpose, the optional FUNCTION-SPAN, if provided, is called for a full span of identical alpha pixel. If not provided, a call is made to FUNCTION for each pixel in the span.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: clip-path (paths &rest args)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: clip-path/path (paths &rest args)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: create-path (type)

Create a new path of the given type. The type must be one of the following keyword:

:open-polyline – An open polyline path, :closed-polyline – A closed polyline path,
:polygon – Like :closed-polyline, but implicitly filled.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: dash-path (paths &rest args)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: filter-distinct (iterator &optional preserve-cyclic-end-p)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: freeze-state (state)

Freeze the state and return a list of scanlines. A scanline is an object which can be examined with SCANLINE-Y and processed with SCANLINE-SWEEP.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: line (state x1 y1 x2 y2)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: line (state x1 y1 x2 y2)

Draw a line from (X1,Y1) to (X2,Y2). All coordinates are integers with subpixel accuracy (a pixel width is given by +CELL-WIDTH+.) The line must be part of a closed polygon.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: line-f (state x1 y1 x2 y2)

Draw a line, whose coordinates are translated to fixed-point as expected by function LINE. This is a convenient function to not depend on +CELL-WIDTH+.

Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: line-f (state x1 y1 x2 y2)

Draw a line, whose coordinates are translated to fixed-point as expected by function LINE. This is a convenient function to not depend on +CELL-WIDTH+.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: make-arc (rx ry &key x-axis-rotation large-arc-flag sweep-flag)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-bezier-curve (control-points)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-catmull-rom (head control-points queue)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-circle-path (cx cy radius &optional radius-y x-axis-rotation)

Construct a path to represent a circle centered at CX,CY of the specified RADIUS.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-discrete-path (path)

Construct a path with only straight lines.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-point (x y)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-rectangle-path (x1 y1 x2 y2 &key round round-x round-y)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-rectangle-path/center (x y dx dy &rest args)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-regular-polygon-path (x y radius sides &optional start-angle)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-simple-path (points &optional type)

Create a path with only straight line, by specifying only knots.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-state (&key cells)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: make-state (&key current-cell cells scanlines end-of-lines dropped-cells recycling-cells)
Package

net.tuxee.aa.

Source

aa.lisp.

Function: make-straight-line ()
Package

net.tuxee.paths.

Source

paths.lisp.

Function: p* (point scale &optional scale-y)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: p+ (p1 p2)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: p- (p1 p2)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-annotated (paths &key include-tangents decimate-knots assume-type)

Annotate the path with visual effect (like color for each type of interpolation, circle to represent knots,..)

path – a path or a list of path

Return a list of (color . paths).

Package

net.tuxee.paths.

Source

paths-annotation.lisp.

Function: path-clear (path)

Clear the path such that it is empty.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-clone (path)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-concatenate (path interpolation other-path)

Append OTHER-PATH to PATH, joined by INTERPOLATION.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-extend (path interpolation knot)

Extend the path to KNOT, with INTERPOLATION.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-iterator (path)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-iterator-segmented (path &optional predicate)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-last-knot (path)

Return the last knot of the path. Return NIL if the path is empty.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-orient (path orientation &optional other-paths)

Orient the path in the given orientation.

If OTHER-PATHS is specified, then the paths are reversed inconditionnaly if PATH is also reversed.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-replace (path other-path)

Replace PATH with contents of OTHER-PATH.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-reset (path knot)

Reset the path such that it is a single knot.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-reverse (path)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-reversed (path)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-rotate (path angle &optional center)

Rotate the whole path by ANGLE radian around CENTER (which is the origin if unspecified.)

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-scale (path scale-x scale-y &optional center)

Scale the whole path by (SCALE-X,SCALE-Y) from CENTER (which is the origin if unspecified.) Warning: not all interpolations support non uniform scaling (when scale-x /= scale-y).

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-size (path)

Return the number of knots on the path.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-transform-as-marker (path path-reference side &key offset scale angle)

Translate, rotate and scale PATH representing a marker such that it is adapted to the PATH-REFERENCE. If SIDE is false, it is placed at the start of the path, otherwise it is placed at the end of the path.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-translate (path vector)

Translate the whole path accordingly to VECTOR.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: point-angle (point)

Compute the angle of POINT relatively to the X axis.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: point-distance (p1 p2)

Compute the distance between P1 and P2.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: point-norm (point)

Compute the distance of POINT from origin.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: point-rotate (point angle)

Rotate POINT by ANGLE radian around the origin.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: point-x (point)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: point-y (point)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: scanline-sweep ()

Call FUNCTION for each pixel on the polygon covered by SCANLINE. The pixels are scanned in increasing X. The sweep can be limited to a range by START (included) or/and END (excluded).

Package

net.tuxee.aa.

Source

aa.lisp.

Function: scanline-y (scanline)

Get the Y position of SCANLINE.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: state-reset (state)

Reset the state, losing all accumulated cells. It can be faster or less memory consuming to reset a state and reuse it, rather than creating a new state.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: stroke-path (paths &rest args)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: update-state (state paths)
Package

net.tuxee.vectors.

Source

vectors.lisp.


5.1.3 Generic functions

Generic Function: path-iterator-next (iterator)

Move the iterator to the next knot, and return
3 values: INTERPOLATION, KNOT and END-P. INTERPOLATION is the interpolation between the previous knot and the current one. For the first iteration, INTERPOLATION is usually the implicit straight line between the last knot and the first knot. KNOT and INTERPOLATION are null if the path is empty. END-P is true if the knot is the last on the path or if the path is empty.

Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: path-iterator-next ((iterator filter-distinct-state))
Method: path-iterator-next ((iterator pi-segmented-state))
Method: path-iterator-next ((iterator path-iterator-state))
Generic Function: path-iterator-reset (iterator)

Reset the iterator before the first knot.

Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: path-iterator-reset ((iterator filter-distinct-state))
Method: path-iterator-reset ((iterator pi-segmented-state))
Method: path-iterator-reset ((iterator path-iterator-state))

5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Constants

Constant: +alpha-divisor+

Constant used to translate value computed by AREA and COVER to an alpha value.

Package

net.tuxee.aa.

Source

aa.lisp.

Constant: +alpha-range+

For non overlapping polygons, the alpha value will be in the range (-limit,limit) where limit is +alpha-range+. The value is negative or positive accordingly to the polygon
orientation (clockwise or counter-clockwise.)

Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Constant: +alpha-range+

For non overlapping polygons, the alpha value will be in the range (-limit,limit) where limit is +alpha-range+. The value is negative or positive accordingly to the polygon
orientation (clockwise or counter-clockwise.)

Package

net.tuxee.aa.

Source

aa.lisp.

Constant: +cell-width+

A cell represent a pixel square, and the width is the fractional part of the fixed-point coordinate. A large value increase precision. 256 should be enough though. Note that smaller value should NOT increase performance.

Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Constant: +cell-width+

A cell represent a pixel square, and the width is the fractional part of the fixed-point coordinate. A large value increase precision. 256 should be enough though. Note that smaller value should NOT increase performance.

Package

net.tuxee.aa.

Source

aa.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.2 Special variables

Special Variable: *miter-limit*

Miter limit before reverting to bevel joint. Must be >=1.0.

Package

net.tuxee.paths.

Source

paths.lisp.


5.2.3 Macros

Macro: define-for-multiple-paths (name-multiple name-single &optional documentation)

Define a new function named by NAME-MULTIPLE which accepts either a single path or a list of paths as input from a function named by NAME-SINGLE accepting only a single path and producing a list of paths.

Package

net.tuxee.paths.

Source

paths.lisp.

Macro: do-path ((path interpolation knot) &body body)
Package

net.tuxee.paths.

Source

paths.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.4 Ordinary functions

Reader: cell-area (instance)
Writer: (setf cell-area) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

area.

Reader: cell-cover (instance)
Writer: (setf cell-cover) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

cover.

Function: cell-empty-p (cell)

Test if the cell is empty. A cell is empty when COVER and AREA are both zero.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: cell-p (object)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: cell-p (object)
Package

net.tuxee.aa.

Source

aa.lisp.

Function: cell-reset (cell)

Reset the cell such that CELL-EMPTY-P is true.

Package

net.tuxee.aa.

Source

aa.lisp.

Reader: cell-value (instance)
Writer: (setf cell-value) (instance)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Target Slot

value.

Reader: cell-x (instance)
Writer: (setf cell-x) (instance)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Target Slot

x.

Reader: cell-x (instance)
Writer: (setf cell-x) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

x.

Reader: cell-y (instance)
Writer: (setf cell-y) (instance)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Target Slot

y.

Reader: cell-y (instance)
Writer: (setf cell-y) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

y.

Function: clip-path/1 (path x y dx dy)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: clip-path/path/1 (path limit)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: compare-cells (a b)

Compare coordinates between 2 cells. Used to sort cells by Y, then by X.

Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: compare-cells (a b)

Compare coordinates between 2 cells. Used to sort cells by Y, then by X.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: compute-alpha (cover area)

Compute the alpha value given the accumulated cover and the actual area of a cell.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: copy-cell (instance)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: copy-cell (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Function: copy-path (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: copy-path-iterator-state (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: copy-pi-segmented-state (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: copy-state (instance)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: copy-state (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Function: dash-path/1 (path sizes &key toggle-p cycle-index)

Dash path. If TOGGLE-P is true, segments of odd indices are kept, while if TOGGLE-P is false, segments of even indices are kept. CYCLE indicate where to cycle the SIZES once the end is reached.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: discrete-bezier-curve (points function &key include-ends min-subdivide max-subdivide distance-tolerance angle-tolerance)

Subdivize Bezier curve up to certain criterions.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: evaluate-bezier (points position)

Evaluate the point at POSITION on the Bezier curve described by POINTS.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: line-intersection (x1 y1 x2 y2 x3 y3 x4 y4)

Compute the intersection between 2 lines (x1,y1)-(x2,y2) and (x3,y3)-(x4,y4). Return the coordinates of the intersection points as 2 values. If the 2 lines are colinears, return NIL.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: line-intersection/delta (x1 y1 dx1 dy1 x2 y2 dx2 dy2)

Compute the intersection between the line by (x1,y1) and direction (dx1,dy1) and the line by (x2,y2) and
direction (dx2,dy2). Return the coordinates of the intersection points as 2 values. If the 2 lines are colinears, return NIL.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: line-normal (x1 y1 x2 y2)

Normalize the vector (X2-X1,Y2-Y1). See NORMALIZE.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-cell (&key x y value)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: make-cell (&key x y cover area)
Package

net.tuxee.aa.

Source

aa.lisp.

Function: make-path (&key type orientation knots interpolations)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-path-iterator-state (&key path index)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: make-pi-segmented-state (&key path index predicate end-p queue)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: map-grid-spans (function x1 y1 x2 y2)

Call FUNCTION for each segments of the line from (X1,Y1) to (X2,Y2) cut by a grid with spacing +CELL-WIDTH+.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: map-line-intersections ()
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: map-line-spans (function a1 b1 a2 b2)

Call FUNCTION for each segment of a line with integer coordinates (A1,B1)-(A2,B2) cut by a grid of spacing +CELL-WIDTH+.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: normalize (x y &optional length)

Normalize the vector (X,Y) such that its length is LENGTH (or 1.0 if unspecified.) Return the component of the resulting vector as 2 values. Return NIL if the input vector had a null length.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-end-info (path side)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-from-iterator (iterator type)

Construct a new path from the given iterator.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: path-guess-orientation (path)

Guess the orientation of the path.

This is implemented loosely because we don’t take care about interpolations. We only consider a polygon described by the knots. However, it should work..

Update path orientation flag, and returns either :CW or :CCW.

Package

net.tuxee.paths.

Source

paths.lisp.

Reader: path-interpolations (instance)
Writer: (setf path-interpolations) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

interpolations.

Reader: path-iterator-state-index (instance)
Writer: (setf path-iterator-state-index) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

index.

Function: path-iterator-state-p (object)
Package

net.tuxee.paths.

Source

paths.lisp.

Reader: path-iterator-state-path (instance)
Writer: (setf path-iterator-state-path) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

path.

Reader: path-knots (instance)
Writer: (setf path-knots) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

knots.

Reader: path-orientation (instance)
Writer: (setf path-orientation) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

orientation.

Function: path-p (object)
Package

net.tuxee.paths.

Source

paths.lisp.

Reader: path-type (instance)
Writer: (setf path-type) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

type.

Reader: pi-segmented-state-end-p (instance)
Writer: (setf pi-segmented-state-end-p) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

end-p.

Reader: pi-segmented-state-index (instance)
Writer: (setf pi-segmented-state-index) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

index.

Function: pi-segmented-state-p (object)
Package

net.tuxee.paths.

Source

paths.lisp.

Reader: pi-segmented-state-path (instance)
Writer: (setf pi-segmented-state-path) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

path.

Reader: pi-segmented-state-predicate (instance)
Writer: (setf pi-segmented-state-predicate) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

predicate.

Reader: pi-segmented-state-queue (instance)
Writer: (setf pi-segmented-state-queue) (instance)
Package

net.tuxee.paths.

Source

paths.lisp.

Target Slot

queue.

Function: point-middle (p1 p2)

Compute the point between P1 and P2.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: set-current-cell (state x y)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: set-current-cell (state x y)

Ensure current cell is one at coordinate X and Y. If not, the current cell is stored, then reset accordingly to new coordinate.

Returns the current cell.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: split-bezier (points &optional position)

Split the Bezier curve described by POINTS at POSITION into two Bezier curves of the same degree. Returns the curves as 2 values.

Package

net.tuxee.paths.

Source

paths.lisp.

Reader: state-cells (instance)
Writer: (setf state-cells) (instance)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Target Slot

cells.

Reader: state-cells (instance)
Writer: (setf state-cells) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

cells.

Reader: state-current-cell (instance)
Writer: (setf state-current-cell) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

current-cell.

Reader: state-dropped-cells (instance)
Writer: (setf state-dropped-cells) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

dropped-cells.

Reader: state-end-of-lines (instance)
Writer: (setf state-end-of-lines) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

end-of-lines.

Function: state-finalize (state)

Finalize the state.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: state-p (object)
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Function: state-p (object)
Package

net.tuxee.aa.

Source

aa.lisp.

Function: state-push-cell (state cell)

Store a copy of the current cell into the cells list. If the state was reset, possibly reuse previous cells.

Package

net.tuxee.aa.

Source

aa.lisp.

Reader: state-recycling-cells (instance)
Writer: (setf state-recycling-cells) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

recycling-cells.

Function: state-reset (state)

Reset the state, losing all accumulated cells. It can be faster or less memory consuming to reset a state and reuse it, rather than creating a new state.

Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Reader: state-scanlines (instance)
Writer: (setf state-scanlines) (instance)
Package

net.tuxee.aa.

Source

aa.lisp.

Target Slot

scanlines.

Function: state-sort-cells (state)

Sort the cells by Y, then by X.

Package

net.tuxee.aa.

Source

aa.lisp.

Function: straight-line-p (value)
Package

net.tuxee.paths.

Source

paths.lisp.

Function: stroke-path/1 (path thickness &key caps joint inner-joint assume-type)

Stroke the path.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: svg-arc-parameters (p1 p2 rx ry rotation large-arc-flag-p sweep-flag-p)

Conversion from endpoint to center parameterization of SVG arc.

Returns values RC, RX, RY, START-ANGLE and DELTA-ANGLE, where RC is the center of the ellipse, RX and RY are the normalized
radii (needed if scaling was necessary).

Package

net.tuxee.paths.

Source

paths.lisp.

Function: svg-arc-parameters/reverse (center rx ry rotation start-angle delta-angle)

Conversion from center to endpoint parameterization of SVG arc.

Returns values P1, P2, LARGE-ARC-FLAG-P, SWEEP-FLAG-P.

Package

net.tuxee.paths.

Source

paths.lisp.

Function: update-cell (cell fx1 fy1 fx2 fy2)

Update COVER and AREA given a segment inside the corresponding cell. FX1, FY1, FX2 and FY2 must be subpixel coordinates between 0 and +CELL-WIDTH+ included.

Package

net.tuxee.aa.

Source

aa.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.5 Generic functions

Generic Function: interpolation-clone (interpolation)

Duplicate INTERPOLATION.

Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-clone ((interpolation bezier))
Method: interpolation-clone ((interpolation catmull-rom))
Method: interpolation-clone ((interpolation arc))
Method: interpolation-clone ((interpolation (eql :straight-line)))
Generic Function: interpolation-normal (interpolation k1 k2 side)

Compute the normal, going "outside" at
either K1 (if SIDE is false) or K2 (if SIDE is true). Return NIL if the normal cannot be computed. Return a point otherwise.

Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-normal ((interpolation bezier) k1 k2 side)
Method: interpolation-normal ((interpolation catmull-rom) k1 k2 side)
Method: interpolation-normal ((interpolation arc) k1 k2 side)
Method: interpolation-normal ((interpolation (eql :straight-line)) k1 k2 side)
Generic Function: interpolation-reverse (interpolation)

Reverse the path described by INTERPOLATION in-place.

Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-reverse ((interpolation bezier))
Method: interpolation-reverse ((interpolation catmull-rom))
Method: interpolation-reverse ((interpolation arc))
Method: interpolation-reverse ((interpolation (eql :straight-line)))
Generic Function: interpolation-reversed (interpolation)

Duplicate and reverse the INTERPOLATION.

Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-reversed (interpolation)
Generic Function: interpolation-rotate (interpolation angle)
Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-rotate ((interpolation bezier) angle)
Method: interpolation-rotate ((interpolation catmull-rom) angle)
Method: interpolation-rotate ((interpolation arc) angle)
Method: interpolation-rotate ((interpolation (eql :straight-line)) angle)
Generic Function: interpolation-scale (interpolation scale-x scale-y)
Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-scale ((interpolation bezier) scale-x scale-y)
Method: interpolation-scale ((interpolation catmull-rom) scale-x scale-y)
Method: interpolation-scale ((interpolation arc) scale-x scale-y)
Method: interpolation-scale ((interpolation (eql :straight-line)) scale-x scale-y)
Generic Function: interpolation-segment (interpolation k1 k2 function)

Segment the path between K1 and K2 described
by the INTERPOLATION. Call FUNCTION for each generated point on the interpolation path.

Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-segment ((interpolation bezier) k1 k2 function)
Method: interpolation-segment ((interpolation catmull-rom) k1 k2 function)
Method: interpolation-segment ((interpolation arc) k1 k2 function)
Method: interpolation-segment ((interpolation (eql :straight-line)) k1 k2 function)
Generic Function: interpolation-translate (interpolation vector)
Package

net.tuxee.paths.

Source

paths.lisp.

Methods
Method: interpolation-translate ((interpolation bezier) vector)
Method: interpolation-translate ((interpolation catmull-rom) vector)
Method: interpolation-translate ((interpolation arc) vector)
Method: interpolation-translate ((interpolation (eql :straight-line)) vector)

Next: , Previous: , Up: Internals   [Contents][Index]

5.2.6 Structures

Structure: cell
Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: x
Readers

cell-x.

Writers

(setf cell-x).

Slot: y
Readers

cell-y.

Writers

(setf cell-y).

Slot: value
Initform

0

Readers

cell-value.

Writers

(setf cell-value).

Structure: cell

A cell used to represent the partial area covered by a line passing by a corresponding pixel. The cell alone doesn’t hold all the information to calculate the area.

Package

net.tuxee.aa.

Source

aa.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: x
Type

integer

Initform

0

Readers

cell-x.

Writers

(setf cell-x).

Slot: y
Type

integer

Initform

0

Readers

cell-y.

Writers

(setf cell-y).

Slot: cover
Type

integer

Initform

0

Readers

cell-cover.

Writers

(setf cell-cover).

Slot: area
Type

integer

Initform

0

Readers

cell-area.

Writers

(setf cell-area).

Structure: path
Package

net.tuxee.paths.

Source

paths.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: type
Package

common-lisp.

Type

(member :open-polyline :closed-polyline :polygon)

Initform

:open-polyline

Readers

path-type.

Writers

(setf path-type).

Slot: orientation
Type

(member :unknown :cw :ccw)

Initform

:unknown

Readers

path-orientation.

Writers

(setf path-orientation).

Slot: knots
Initform

(make-array 0 :adjustable t :fill-pointer 0)

Readers

path-knots.

Writers

(setf path-knots).

Slot: interpolations
Initform

(make-array 0 :adjustable t :fill-pointer 0)

Readers

path-interpolations.

Writers

(setf path-interpolations).

Structure: path-iterator-state
Package

net.tuxee.paths.

Source

paths.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: path
Readers

path-iterator-state-path.

Writers

(setf path-iterator-state-path).

Slot: index
Readers

path-iterator-state-index.

Writers

(setf path-iterator-state-index).

Structure: pi-segmented-state
Package

net.tuxee.paths.

Source

paths.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: path
Readers

pi-segmented-state-path.

Writers

(setf pi-segmented-state-path).

Slot: index
Readers

pi-segmented-state-index.

Writers

(setf pi-segmented-state-index).

Slot: predicate
Readers

pi-segmented-state-predicate.

Writers

(setf pi-segmented-state-predicate).

Slot: end-p
Readers

pi-segmented-state-end-p.

Writers

(setf pi-segmented-state-end-p).

Slot: queue
Readers

pi-segmented-state-queue.

Writers

(setf pi-segmented-state-queue).

Structure: state

AA state. Hold all the cells generated when drawing lines.

Package

net.tuxee.aa-bin.

Source

aa-bin.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: cells
Readers

state-cells.

Writers

(setf state-cells).

Structure: state

AA state. Hold all the cells generated when drawing lines.

Package

net.tuxee.aa.

Source

aa.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: current-cell
Type

net.tuxee.aa::cell

Initform

(net.tuxee.aa::make-cell)

Readers

state-current-cell.

Writers

(setf state-current-cell).

Slot: cells
Readers

state-cells.

Writers

(setf state-cells).

Slot: scanlines
Readers

state-scanlines.

Writers

(setf state-scanlines).

Slot: end-of-lines
Readers

state-end-of-lines.

Writers

(setf state-end-of-lines).

Slot: dropped-cells
Readers

state-dropped-cells.

Writers

(setf state-dropped-cells).

Slot: recycling-cells
Initform

(cons nil nil)

Readers

state-recycling-cells.

Writers

(setf state-recycling-cells).


Previous: , Up: Internals   [Contents][Index]

5.2.7 Classes

Class: arc
Package

net.tuxee.paths.

Source

paths.lisp.

Direct methods
Direct slots
Slot: rx
Initargs

net.tuxee.paths::rx

Slot: ry
Initargs

net.tuxee.paths::ry

Slot: x-axis-rotation
Initargs

net.tuxee.paths::x-axis-rotation

Slot: large-arc-flag
Initargs

net.tuxee.paths::large-arc-flag

Slot: sweep-flag
Initargs

net.tuxee.paths::sweep-flag

Class: bezier
Package

net.tuxee.paths.

Source

paths.lisp.

Direct methods
Direct slots
Slot: control-points
Initform

(make-array 0)

Initargs

net.tuxee.paths::control-points

Class: catmull-rom
Package

net.tuxee.paths.

Source

paths.lisp.

Direct methods
Direct slots
Slot: head
Initargs

net.tuxee.paths::head

Slot: control-points
Initform

(make-array 0)

Initargs

net.tuxee.paths::control-points

Slot: queue
Initargs

net.tuxee.paths::queue

Class: filter-distinct-state
Package

net.tuxee.paths.

Source

paths.lisp.

Direct methods
Direct slots
Slot: iterator
Initargs

:iterator

Slot: cyclic-p
Initargs

:cyclic-p

Slot: fixed
Initargs

:fixed

Slot: next
Initargs

:next

Slot: next-is-end-p

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
C   D   E   F   G   I   L   M   N   P   S   U  
Index Entry  Section

(
(setf cell-area): Private ordinary functions
(setf cell-cover): Private ordinary functions
(setf cell-value): Private ordinary functions
(setf cell-x): Private ordinary functions
(setf cell-x): Private ordinary functions
(setf cell-y): Private ordinary functions
(setf cell-y): Private ordinary functions
(setf path-interpolations): Private ordinary functions
(setf path-iterator-state-index): Private ordinary functions
(setf path-iterator-state-path): Private ordinary functions
(setf path-knots): Private ordinary functions
(setf path-orientation): Private ordinary functions
(setf path-type): Private ordinary functions
(setf pi-segmented-state-end-p): Private ordinary functions
(setf pi-segmented-state-index): Private ordinary functions
(setf pi-segmented-state-path): Private ordinary functions
(setf pi-segmented-state-predicate): Private ordinary functions
(setf pi-segmented-state-queue): Private ordinary functions
(setf state-cells): Private ordinary functions
(setf state-cells): Private ordinary functions
(setf state-current-cell): Private ordinary functions
(setf state-dropped-cells): Private ordinary functions
(setf state-end-of-lines): Private ordinary functions
(setf state-recycling-cells): Private ordinary functions
(setf state-scanlines): Private ordinary functions

C
cell-area: Private ordinary functions
cell-cover: Private ordinary functions
cell-empty-p: Private ordinary functions
cell-p: Private ordinary functions
cell-p: Private ordinary functions
cell-reset: Private ordinary functions
cell-value: Private ordinary functions
cell-x: Private ordinary functions
cell-x: Private ordinary functions
cell-y: Private ordinary functions
cell-y: Private ordinary functions
cells-sweep: Public ordinary functions
cells-sweep: Public ordinary functions
cells-sweep/rectangle: Public ordinary functions
clip-path: Public ordinary functions
clip-path/1: Private ordinary functions
clip-path/path: Public ordinary functions
clip-path/path/1: Private ordinary functions
compare-cells: Private ordinary functions
compare-cells: Private ordinary functions
compute-alpha: Private ordinary functions
copy-cell: Private ordinary functions
copy-cell: Private ordinary functions
copy-path: Private ordinary functions
copy-path-iterator-state: Private ordinary functions
copy-pi-segmented-state: Private ordinary functions
copy-state: Private ordinary functions
copy-state: Private ordinary functions
create-path: Public ordinary functions

D
dash-path: Public ordinary functions
dash-path/1: Private ordinary functions
define-for-multiple-paths: Private macros
discrete-bezier-curve: Private ordinary functions
do-path: Private macros

E
evaluate-bezier: Private ordinary functions

F
filter-distinct: Public ordinary functions
freeze-state: Public ordinary functions
Function, (setf cell-area): Private ordinary functions
Function, (setf cell-cover): Private ordinary functions
Function, (setf cell-value): Private ordinary functions
Function, (setf cell-x): Private ordinary functions
Function, (setf cell-x): Private ordinary functions
Function, (setf cell-y): Private ordinary functions
Function, (setf cell-y): Private ordinary functions
Function, (setf path-interpolations): Private ordinary functions
Function, (setf path-iterator-state-index): Private ordinary functions
Function, (setf path-iterator-state-path): Private ordinary functions
Function, (setf path-knots): Private ordinary functions
Function, (setf path-orientation): Private ordinary functions
Function, (setf path-type): Private ordinary functions
Function, (setf pi-segmented-state-end-p): Private ordinary functions
Function, (setf pi-segmented-state-index): Private ordinary functions
Function, (setf pi-segmented-state-path): Private ordinary functions
Function, (setf pi-segmented-state-predicate): Private ordinary functions
Function, (setf pi-segmented-state-queue): Private ordinary functions
Function, (setf state-cells): Private ordinary functions
Function, (setf state-cells): Private ordinary functions
Function, (setf state-current-cell): Private ordinary functions
Function, (setf state-dropped-cells): Private ordinary functions
Function, (setf state-end-of-lines): Private ordinary functions
Function, (setf state-recycling-cells): Private ordinary functions
Function, (setf state-scanlines): Private ordinary functions
Function, cell-area: Private ordinary functions
Function, cell-cover: Private ordinary functions
Function, cell-empty-p: Private ordinary functions
Function, cell-p: Private ordinary functions
Function, cell-p: Private ordinary functions
Function, cell-reset: Private ordinary functions
Function, cell-value: Private ordinary functions
Function, cell-x: Private ordinary functions
Function, cell-x: Private ordinary functions
Function, cell-y: Private ordinary functions
Function, cell-y: Private ordinary functions
Function, cells-sweep: Public ordinary functions
Function, cells-sweep: Public ordinary functions
Function, cells-sweep/rectangle: Public ordinary functions
Function, clip-path: Public ordinary functions
Function, clip-path/1: Private ordinary functions
Function, clip-path/path: Public ordinary functions
Function, clip-path/path/1: Private ordinary functions
Function, compare-cells: Private ordinary functions
Function, compare-cells: Private ordinary functions
Function, compute-alpha: Private ordinary functions
Function, copy-cell: Private ordinary functions
Function, copy-cell: Private ordinary functions
Function, copy-path: Private ordinary functions
Function, copy-path-iterator-state: Private ordinary functions
Function, copy-pi-segmented-state: Private ordinary functions
Function, copy-state: Private ordinary functions
Function, copy-state: Private ordinary functions
Function, create-path: Public ordinary functions
Function, dash-path: Public ordinary functions
Function, dash-path/1: Private ordinary functions
Function, discrete-bezier-curve: Private ordinary functions
Function, evaluate-bezier: Private ordinary functions
Function, filter-distinct: Public ordinary functions
Function, freeze-state: Public ordinary functions
Function, line: Public ordinary functions
Function, line: Public ordinary functions
Function, line-f: Public ordinary functions
Function, line-f: Public ordinary functions
Function, line-intersection: Private ordinary functions
Function, line-intersection/delta: Private ordinary functions
Function, line-normal: Private ordinary functions
Function, make-arc: Public ordinary functions
Function, make-bezier-curve: Public ordinary functions
Function, make-catmull-rom: Public ordinary functions
Function, make-cell: Private ordinary functions
Function, make-cell: Private ordinary functions
Function, make-circle-path: Public ordinary functions
Function, make-discrete-path: Public ordinary functions
Function, make-path: Private ordinary functions
Function, make-path-iterator-state: Private ordinary functions
Function, make-pi-segmented-state: Private ordinary functions
Function, make-point: Public ordinary functions
Function, make-rectangle-path: Public ordinary functions
Function, make-rectangle-path/center: Public ordinary functions
Function, make-regular-polygon-path: Public ordinary functions
Function, make-simple-path: Public ordinary functions
Function, make-state: Public ordinary functions
Function, make-state: Public ordinary functions
Function, make-straight-line: Public ordinary functions
Function, map-grid-spans: Private ordinary functions
Function, map-line-intersections: Private ordinary functions
Function, map-line-spans: Private ordinary functions
Function, normalize: Private ordinary functions
Function, p*: Public ordinary functions
Function, p+: Public ordinary functions
Function, p-: Public ordinary functions
Function, path-annotated: Public ordinary functions
Function, path-clear: Public ordinary functions
Function, path-clone: Public ordinary functions
Function, path-concatenate: Public ordinary functions
Function, path-end-info: Private ordinary functions
Function, path-extend: Public ordinary functions
Function, path-from-iterator: Private ordinary functions
Function, path-guess-orientation: Private ordinary functions
Function, path-interpolations: Private ordinary functions
Function, path-iterator: Public ordinary functions
Function, path-iterator-segmented: Public ordinary functions
Function, path-iterator-state-index: Private ordinary functions
Function, path-iterator-state-p: Private ordinary functions
Function, path-iterator-state-path: Private ordinary functions
Function, path-knots: Private ordinary functions
Function, path-last-knot: Public ordinary functions
Function, path-orient: Public ordinary functions
Function, path-orientation: Private ordinary functions
Function, path-p: Private ordinary functions
Function, path-replace: Public ordinary functions
Function, path-reset: Public ordinary functions
Function, path-reverse: Public ordinary functions
Function, path-reversed: Public ordinary functions
Function, path-rotate: Public ordinary functions
Function, path-scale: Public ordinary functions
Function, path-size: Public ordinary functions
Function, path-transform-as-marker: Public ordinary functions
Function, path-translate: Public ordinary functions
Function, path-type: Private ordinary functions
Function, pi-segmented-state-end-p: Private ordinary functions
Function, pi-segmented-state-index: Private ordinary functions
Function, pi-segmented-state-p: Private ordinary functions
Function, pi-segmented-state-path: Private ordinary functions
Function, pi-segmented-state-predicate: Private ordinary functions
Function, pi-segmented-state-queue: Private ordinary functions
Function, point-angle: Public ordinary functions
Function, point-distance: Public ordinary functions
Function, point-middle: Private ordinary functions
Function, point-norm: Public ordinary functions
Function, point-rotate: Public ordinary functions
Function, point-x: Public ordinary functions
Function, point-y: Public ordinary functions
Function, scanline-sweep: Public ordinary functions
Function, scanline-y: Public ordinary functions
Function, set-current-cell: Private ordinary functions
Function, set-current-cell: Private ordinary functions
Function, split-bezier: Private ordinary functions
Function, state-cells: Private ordinary functions
Function, state-cells: Private ordinary functions
Function, state-current-cell: Private ordinary functions
Function, state-dropped-cells: Private ordinary functions
Function, state-end-of-lines: Private ordinary functions
Function, state-finalize: Private ordinary functions
Function, state-p: Private ordinary functions
Function, state-p: Private ordinary functions
Function, state-push-cell: Private ordinary functions
Function, state-recycling-cells: Private ordinary functions
Function, state-reset: Public ordinary functions
Function, state-reset: Private ordinary functions
Function, state-scanlines: Private ordinary functions
Function, state-sort-cells: Private ordinary functions
Function, straight-line-p: Private ordinary functions
Function, stroke-path: Public ordinary functions
Function, stroke-path/1: Private ordinary functions
Function, svg-arc-parameters: Private ordinary functions
Function, svg-arc-parameters/reverse: Private ordinary functions
Function, update-cell: Private ordinary functions
Function, update-state: Public ordinary functions

G
Generic Function, interpolation-clone: Private generic functions
Generic Function, interpolation-normal: Private generic functions
Generic Function, interpolation-reverse: Private generic functions
Generic Function, interpolation-reversed: Private generic functions
Generic Function, interpolation-rotate: Private generic functions
Generic Function, interpolation-scale: Private generic functions
Generic Function, interpolation-segment: Private generic functions
Generic Function, interpolation-translate: Private generic functions
Generic Function, path-iterator-next: Public generic functions
Generic Function, path-iterator-reset: Public generic functions

I
interpolation-clone: Private generic functions
interpolation-clone: Private generic functions
interpolation-clone: Private generic functions
interpolation-clone: Private generic functions
interpolation-clone: Private generic functions
interpolation-normal: Private generic functions
interpolation-normal: Private generic functions
interpolation-normal: Private generic functions
interpolation-normal: Private generic functions
interpolation-normal: Private generic functions
interpolation-reverse: Private generic functions
interpolation-reverse: Private generic functions
interpolation-reverse: Private generic functions
interpolation-reverse: Private generic functions
interpolation-reverse: Private generic functions
interpolation-reversed: Private generic functions
interpolation-reversed: Private generic functions
interpolation-rotate: Private generic functions
interpolation-rotate: Private generic functions
interpolation-rotate: Private generic functions
interpolation-rotate: Private generic functions
interpolation-rotate: Private generic functions
interpolation-scale: Private generic functions
interpolation-scale: Private generic functions
interpolation-scale: Private generic functions
interpolation-scale: Private generic functions
interpolation-scale: Private generic functions
interpolation-segment: Private generic functions
interpolation-segment: Private generic functions
interpolation-segment: Private generic functions
interpolation-segment: Private generic functions
interpolation-segment: Private generic functions
interpolation-translate: Private generic functions
interpolation-translate: Private generic functions
interpolation-translate: Private generic functions
interpolation-translate: Private generic functions
interpolation-translate: Private generic functions

L
line: Public ordinary functions
line: Public ordinary functions
line-f: Public ordinary functions
line-f: Public ordinary functions
line-intersection: Private ordinary functions
line-intersection/delta: Private ordinary functions
line-normal: Private ordinary functions

M
Macro, define-for-multiple-paths: Private macros
Macro, do-path: Private macros
make-arc: Public ordinary functions
make-bezier-curve: Public ordinary functions
make-catmull-rom: Public ordinary functions
make-cell: Private ordinary functions
make-cell: Private ordinary functions
make-circle-path: Public ordinary functions
make-discrete-path: Public ordinary functions
make-path: Private ordinary functions
make-path-iterator-state: Private ordinary functions
make-pi-segmented-state: Private ordinary functions
make-point: Public ordinary functions
make-rectangle-path: Public ordinary functions
make-rectangle-path/center: Public ordinary functions
make-regular-polygon-path: Public ordinary functions
make-simple-path: Public ordinary functions
make-state: Public ordinary functions
make-state: Public ordinary functions
make-straight-line: Public ordinary functions
map-grid-spans: Private ordinary functions
map-line-intersections: Private ordinary functions
map-line-spans: Private ordinary functions
Method, interpolation-clone: Private generic functions
Method, interpolation-clone: Private generic functions
Method, interpolation-clone: Private generic functions
Method, interpolation-clone: Private generic functions
Method, interpolation-normal: Private generic functions
Method, interpolation-normal: Private generic functions
Method, interpolation-normal: Private generic functions
Method, interpolation-normal: Private generic functions
Method, interpolation-reverse: Private generic functions
Method, interpolation-reverse: Private generic functions
Method, interpolation-reverse: Private generic functions
Method, interpolation-reverse: Private generic functions
Method, interpolation-reversed: Private generic functions
Method, interpolation-rotate: Private generic functions
Method, interpolation-rotate: Private generic functions
Method, interpolation-rotate: Private generic functions
Method, interpolation-rotate: Private generic functions
Method, interpolation-scale: Private generic functions
Method, interpolation-scale: Private generic functions
Method, interpolation-scale: Private generic functions
Method, interpolation-scale: Private generic functions
Method, interpolation-segment: Private generic functions
Method, interpolation-segment: Private generic functions
Method, interpolation-segment: Private generic functions
Method, interpolation-segment: Private generic functions
Method, interpolation-translate: Private generic functions
Method, interpolation-translate: Private generic functions
Method, interpolation-translate: Private generic functions
Method, interpolation-translate: Private generic functions
Method, path-iterator-next: Public generic functions
Method, path-iterator-next: Public generic functions
Method, path-iterator-next: Public generic functions
Method, path-iterator-reset: Public generic functions
Method, path-iterator-reset: Public generic functions
Method, path-iterator-reset: Public generic functions

N
normalize: Private ordinary functions

P
p*: Public ordinary functions
p+: Public ordinary functions
p-: Public ordinary functions
path-annotated: Public ordinary functions
path-clear: Public ordinary functions
path-clone: Public ordinary functions
path-concatenate: Public ordinary functions
path-end-info: Private ordinary functions
path-extend: Public ordinary functions
path-from-iterator: Private ordinary functions
path-guess-orientation: Private ordinary functions
path-interpolations: Private ordinary functions
path-iterator: Public ordinary functions
path-iterator-next: Public generic functions
path-iterator-next: Public generic functions
path-iterator-next: Public generic functions
path-iterator-next: Public generic functions
path-iterator-reset: Public generic functions
path-iterator-reset: Public generic functions
path-iterator-reset: Public generic functions
path-iterator-reset: Public generic functions
path-iterator-segmented: Public ordinary functions
path-iterator-state-index: Private ordinary functions
path-iterator-state-p: Private ordinary functions
path-iterator-state-path: Private ordinary functions
path-knots: Private ordinary functions
path-last-knot: Public ordinary functions
path-orient: Public ordinary functions
path-orientation: Private ordinary functions
path-p: Private ordinary functions
path-replace: Public ordinary functions
path-reset: Public ordinary functions
path-reverse: Public ordinary functions
path-reversed: Public ordinary functions
path-rotate: Public ordinary functions
path-scale: Public ordinary functions
path-size: Public ordinary functions
path-transform-as-marker: Public ordinary functions
path-translate: Public ordinary functions
path-type: Private ordinary functions
pi-segmented-state-end-p: Private ordinary functions
pi-segmented-state-index: Private ordinary functions
pi-segmented-state-p: Private ordinary functions
pi-segmented-state-path: Private ordinary functions
pi-segmented-state-predicate: Private ordinary functions
pi-segmented-state-queue: Private ordinary functions
point-angle: Public ordinary functions
point-distance: Public ordinary functions
point-middle: Private ordinary functions
point-norm: Public ordinary functions
point-rotate: Public ordinary functions
point-x: Public ordinary functions
point-y: Public ordinary functions

S
scanline-sweep: Public ordinary functions
scanline-y: Public ordinary functions
set-current-cell: Private ordinary functions
set-current-cell: Private ordinary functions
split-bezier: Private ordinary functions
state-cells: Private ordinary functions
state-cells: Private ordinary functions
state-current-cell: Private ordinary functions
state-dropped-cells: Private ordinary functions
state-end-of-lines: Private ordinary functions
state-finalize: Private ordinary functions
state-p: Private ordinary functions
state-p: Private ordinary functions
state-push-cell: Private ordinary functions
state-recycling-cells: Private ordinary functions
state-reset: Public ordinary functions
state-reset: Private ordinary functions
state-scanlines: Private ordinary functions
state-sort-cells: Private ordinary functions
straight-line-p: Private ordinary functions
stroke-path: Public ordinary functions
stroke-path/1: Private ordinary functions
svg-arc-parameters: Private ordinary functions
svg-arc-parameters/reverse: Private ordinary functions

U
update-cell: Private ordinary functions
update-state: Public ordinary functions

Jump to:   (  
C   D   E   F   G   I   L   M   N   P   S   U  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
A   C   D   E   F   H   I   K   L   N   O   P   Q   R   S   T   V   X   Y  
Index Entry  Section

*
*arc-length-tolerance*: Public special variables
*bezier-angle-tolerance*: Public special variables
*bezier-distance-tolerance*: Public special variables
*miter-limit*: Private special variables

+
+alpha-divisor+: Private constants
+alpha-range+: Private constants
+alpha-range+: Private constants
+cell-width+: Private constants
+cell-width+: Private constants

A
area: Private structures

C
cells: Private structures
cells: Private structures
Constant, +alpha-divisor+: Private constants
Constant, +alpha-range+: Private constants
Constant, +alpha-range+: Private constants
Constant, +cell-width+: Private constants
Constant, +cell-width+: Private constants
control-points: Private classes
control-points: Private classes
cover: Private structures
current-cell: Private structures
cyclic-p: Private classes

D
dropped-cells: Private structures

E
end-of-lines: Private structures
end-p: Private structures

F
fixed: Private classes

H
head: Private classes

I
index: Private structures
index: Private structures
interpolations: Private structures
iterator: Private classes

K
knots: Private structures

L
large-arc-flag: Private classes

N
next: Private classes
next-is-end-p: Private classes

O
orientation: Private structures

P
path: Private structures
path: Private structures
predicate: Private structures

Q
queue: Private structures
queue: Private classes

R
recycling-cells: Private structures
rx: Private classes
ry: Private classes

S
scanlines: Private structures
Slot, area: Private structures
Slot, cells: Private structures
Slot, cells: Private structures
Slot, control-points: Private classes
Slot, control-points: Private classes
Slot, cover: Private structures
Slot, current-cell: Private structures
Slot, cyclic-p: Private classes
Slot, dropped-cells: Private structures
Slot, end-of-lines: Private structures
Slot, end-p: Private structures
Slot, fixed: Private classes
Slot, head: Private classes
Slot, index: Private structures
Slot, index: Private structures
Slot, interpolations: Private structures
Slot, iterator: Private classes
Slot, knots: Private structures
Slot, large-arc-flag: Private classes
Slot, next: Private classes
Slot, next-is-end-p: Private classes
Slot, orientation: Private structures
Slot, path: Private structures
Slot, path: Private structures
Slot, predicate: Private structures
Slot, queue: Private structures
Slot, queue: Private classes
Slot, recycling-cells: Private structures
Slot, rx: Private classes
Slot, ry: Private classes
Slot, scanlines: Private structures
Slot, sweep-flag: Private classes
Slot, type: Private structures
Slot, value: Private structures
Slot, x: Private structures
Slot, x: Private structures
Slot, x-axis-rotation: Private classes
Slot, y: Private structures
Slot, y: Private structures
Special Variable, *arc-length-tolerance*: Public special variables
Special Variable, *bezier-angle-tolerance*: Public special variables
Special Variable, *bezier-distance-tolerance*: Public special variables
Special Variable, *miter-limit*: Private special variables
sweep-flag: Private classes

T
type: Private structures

V
value: Private structures

X
x: Private structures
x: Private structures
x-axis-rotation: Private classes

Y
y: Private structures
y: Private structures

Jump to:   *   +  
A   C   D   E   F   H   I   K   L   N   O   P   Q   R   S   T   V   X   Y  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   F   N   P   S   V  
Index Entry  Section

A
aa-bin.lisp: The cl-aa/aa-bin․lisp file
aa.lisp: The cl-aa/aa․lisp file
arc: Private classes

B
bezier: Private classes

C
catmull-rom: Private classes
cell: Private structures
cell: Private structures
cl-aa: The cl-aa system
cl-aa.asd: The cl-aa/cl-aa․asd file
cl-paths: The cl-paths system
cl-paths.asd: The cl-paths/cl-paths․asd file
cl-vectors: The cl-vectors system
cl-vectors.asd: The cl-vectors/cl-vectors․asd file
Class, arc: Private classes
Class, bezier: Private classes
Class, catmull-rom: Private classes
Class, filter-distinct-state: Private classes

F
File, aa-bin.lisp: The cl-aa/aa-bin․lisp file
File, aa.lisp: The cl-aa/aa․lisp file
File, cl-aa.asd: The cl-aa/cl-aa․asd file
File, cl-paths.asd: The cl-paths/cl-paths․asd file
File, cl-vectors.asd: The cl-vectors/cl-vectors․asd file
File, paths-annotation.lisp: The cl-paths/paths-annotation․lisp file
File, paths-package.lisp: The cl-paths/paths-package․lisp file
File, paths.lisp: The cl-paths/paths․lisp file
File, vectors.lisp: The cl-vectors/vectors․lisp file
filter-distinct-state: Private classes

N
net.tuxee.aa: The net․tuxee․aa package
net.tuxee.aa-bin: The net․tuxee․aa-bin package
net.tuxee.paths: The net․tuxee․paths package
net.tuxee.vectors: The net․tuxee․vectors package

P
Package, net.tuxee.aa: The net․tuxee․aa package
Package, net.tuxee.aa-bin: The net․tuxee․aa-bin package
Package, net.tuxee.paths: The net․tuxee․paths package
Package, net.tuxee.vectors: The net․tuxee․vectors package
path: Private structures
path-iterator-state: Private structures
paths-annotation.lisp: The cl-paths/paths-annotation․lisp file
paths-package.lisp: The cl-paths/paths-package․lisp file
paths.lisp: The cl-paths/paths․lisp file
pi-segmented-state: Private structures

S
state: Private structures
state: Private structures
Structure, cell: Private structures
Structure, cell: Private structures
Structure, path: Private structures
Structure, path-iterator-state: Private structures
Structure, pi-segmented-state: Private structures
Structure, state: Private structures
Structure, state: Private structures
System, cl-aa: The cl-aa system
System, cl-paths: The cl-paths system
System, cl-vectors: The cl-vectors system

V
vectors.lisp: The cl-vectors/vectors․lisp file

Jump to:   A   B   C   F   N   P   S   V