Maintainer | diagrams-discuss@googlegroups.com |
---|---|
Safe Haskell | None |
Convenient creation of command-line-driven executables for rendering diagrams using the Postscript backend.
-
defaultMain
creates an executable which can render a single diagram at various options. -
multiMain
is likedefaultMain
but allows for a list of diagrams from which the user can choose one to render. -
pagesMain
is likedefaultMain
but renders a list of diagrams as pages in a single file.
If you want to generate diagrams programmatically---i.e. if you want to do anything more complex than what the below functions provide---you have several options.
- A simple but somewhat inflexible approach is to wrap up
defaultMain
(ormultiMain
, orpagesMain
) in a call towithArgs
. - A more flexible approach is to directly call
renderDia
; see Diagrams.Backend.Postscript for more information.
- defaultMain :: Diagram Postscript R2 -> IO ()
- multiMain :: [(String, Diagram Postscript R2)] -> IO ()
- pagesMain :: [Diagram Postscript R2] -> IO ()
- animMain :: Animation Postscript R2 -> IO ()
- data Postscript
Documentation
defaultMain :: Diagram Postscript R2 -> IO ()Source
This is the simplest way to render diagrams, and is intended to be used like so:
... other definitions ... myDiagram = ... main = defaultMain myDiagram
Compiling a source file like the above example will result in an
executable which takes command-line options for setting the size,
output file, and so on, and renders myDiagram
with the
specified options.
Pass --help
to the generated executable to see all available
options. Currently it looks something like
Command-line diagram generation. Foo [OPTIONS] Common flags: -w --width=INT Desired width of the output image -h --height=INT Desired height of the output image -o --output=FILE Output file -f --fpu=FLOAT Frames per unit time (for animations) -? --help Display help message -V --version Print version information
For example, a couple common scenarios include
$ ghc --make MyDiagram # output image.eps with a width of 400pt (and auto-determined height) $ ./MyDiagram -o image.eps -w 400
multiMain :: [(String, Diagram Postscript R2)] -> IO ()Source
multiMain
is like defaultMain
, except instead of a single
diagram it takes a list of diagrams paired with names as input.
The generated executable then takes a --selection
option
specifying the name of the diagram that should be rendered. The
list of available diagrams may also be printed by passing the
option --list
.
Example usage:
$ ghc --make MultiTest [1 of 1] Compiling Main ( MultiTest.hs, MultiTest.o ) Linking MultiTest ... $ ./MultiTest --list Available diagrams: foo bar $ ./MultiTest --selection bar -o Bar.eps -w 200
pagesMain :: [Diagram Postscript R2] -> IO ()Source
pagesMain
is like defaultMain
, except instead of a single
diagram it takes a list of diagrams and each wil be rendered as a page
in the Postscript file.
Example usage:
$ ghc --make MultiPage [1 of 1] Compiling Main ( MultiPage.hs, MultiPage.o ) Linking MultiPage ... $ ./MultiPage -o Pages.ps -w 200
animMain :: Animation Postscript R2 -> IO ()Source
animMain
is like defaultMain
, but renders an animation
instead of a diagram. It takes as input an animation and produces
a command-line program which will crudely "render" the animation
by rendering one image for each frame, named by extending the given
output file name by consecutive integers. For example if the given
output file name is foo/blah.eps
, the frames will be saved in
foo/blah001.eps
, foo/blah002.eps
, and so on (the number of
padding digits used depends on the total number of frames). It is
up to the user to take these images and stitch them together into
an actual animation format (using, e.g. ffmpeg
).
Of course, this is a rather crude method of rendering animations; more sophisticated methods will likely be added in the future.
The --fpu
option can be used to control how many frames will be
output for each second (unit time) of animation.
data Postscript Source
This data declaration is simply used as a token to distinguish this rendering engine.