Advanced Graphics Capabilities In Latex With Asymptote

What is Asymptote and Why Use It?

Asymptote is a powerful descriptive vector graphics language that provides LaTeX users with an integrated solution for generating precise, high-quality graphics directly within LaTeX documents. The Asymptote language is based on C++ and OpenGL, giving it significant advantages over LaTeX's native picture drawing capabilities.

Asymptote is designed specifically for technical drawing and comes with an impressive array of features for graphing functions, plotting data, creating diagrams, and importing images. It includes 3D capabilities and support for interactive graphics and animations. The main benefits over using the basic LaTeX picture environment include:

  • High-quality scalable vector graphics output
  • Powerful 3D graphics with perspectives and lighting
  • Precision down to fractions of a pixel
  • Reusable code modules and constants
  • Tight integration with LaTeX labels and sizes

For any graphic more complex than simple lines and geometric shapes, Asymptote provides major enhancements in quality and accuracy. For serious LaTeX users who regularly develop complex scientific figures, diagrams, charts, or technical illustrations, exploring Asymptote is highly recommended.

Basic Usage and Syntax

To start using Asymptote within your LaTeX documents, the Asymptote modules need to be imported inside the preamble. This is done by including:


Asymptote code is enclosed in LaTeX within asy environments. These Asymptote code blocks are integrated directly with the LaTeX content, but are handled separately during compilation:

// Asymptote drawing commands here  

The LaTeX document will have to be compiled with Asymptote integrated. This can be done either directly with command line tools or with an integrated LaTeX editor like TeXstudio that runs the Asymptote parser automatically alongside LaTeX.

An important aspect of effectively using Asymptote is understanding how measurements are calibrated against LaTeX. By default Asymptote uses the unit inch just like LaTeX. To draw a 1cm wide line:

line((0,0), (1cm,0));

Coordinates can be specified directly using LaTeX length units. In addition, sizes of graphical objects can be set relative to text in the LaTeX document based on variables like linewidth and textwidth. This allows precise alignment between graphics and document content.

Drawing 2D Graphs and Plots

Asymptote provides a full set of 2D drawing capabilities ideal for technical diagrams in fields like math, computer science, physics, and engineering. Basic shapes include:

  • Lines: line((0,0), (3,1))
  • Circles: circle((2,1), 0.5cm)
  • Ellipses: ellipse((3,-2), 0.6cm, 0.3cm)
  • Polygons: polygon((0,0), (2,-1), (0,-2))
  • Paths with splines
  • Arcs
  • Grids

These primitives can be combined and transformed to construct complex figures. Attributes like colors, styles, arrows, and thickness can be set. Text labels are added using the LaTeX-like label command:

label("\textbf{Graph Title}", (3,3)); 

Completed Asymptote graphics can be saved to external files and included in LaTeX documents with commands like:


The tight integration between Asymptote and LaTeX means labels and other textual elements are handled correctly during typesetting. Mathematical equations, formulas, and symbols can also be incorporated directly, for example:

label("$\int_a^b f(x) dx$", (1,-3));

This allows the creation of publication-quality graphs, charts, technical diagrams directly within LaTeX.

3D Graphics

One of the most powerful features of Asymptote is the built-in 3D graphics module. Enabling 3D is straightforward - it just requires importing the module:

import three;

This exposes all the 3D drawing capability. The 3D perspective and viewer position is typically set first. Common settings include:

currentprojection=perspective(camera=(0,0,1), up=(0,1,0),
  target=(0,0,0), zoom=1.0); 

Three-dimensional versions of shapes like spheres, cubes, cones and cylinders are provided:

draw(sphere((2,0,0), 1cm), emissive(white));

Combined with transformations like rotation, translation, scaling, and clips, intricate 3D forms can be constructed.

For more advanced graphics, surface meshes can be generated either procedurally or by importing external mesh data files. Lighting, materials, depth of field, and other effects are supported for enhanced realism.

The true power of 3D graphics comes from animation capabilities. Asymptote includes an animation module which can be imported:

import animation; 

Timelines, transitions and motions can be scripted to create 3D animations directly in LaTeX. Complex interactive 3D models with user controls can also be built and embedded.

Best Practices

Like any programming language, efficient use of Asymptote relies on understanding its strengths as well as following good coding practices.

The fact that it is an interpreted language means compilation time can be long for complex 3D graphics. Keeping code modular with functions and separating out objects avoids expensive recomputing. Use of external data files can also optimize performance.

Debugging Asymptote generally involves adding trace statements and printing key variable values. The 3D module has specific functions like draw(box, Invisible) to visualize objects and debug scenes. The community forum and GitHub issue tracker are also useful references.

Learning Asymptote is easier when building on existing code. The Asymptote GitHub repository and CTAN provide many documented examples across different applications like graphs, diagrams, technical illustrations and 3D scenes. These can be studied and adapted rather than coding from scratch.

Next Steps with Asymptote

Asymptote is under active development with new features and improvements added over time. Recent additions include pipes for plotting implicit functions and LaTeX integration for tabular environments.

For even more advanced graphics, Asymptote provides custom modules that can expand its base capabilities. These include special functions for specific visualization applications:

  • asypicture - Scientific raster images
  • bbox - Bounding boxes
  • fourier - Complex signals and transforms
  • layers - Multi-layer diagrams
  • pipes - Implicit plotter
  • sketch - Hand-drawn lines

The Asymptote GitHub wiki offers a gallery of examples showing graphics across scientific, engineering, and math domains generated with the language. These provide inspiration for the wide range of visualization possibilities offered by Asymptote.

For LaTeX documents needing high-quality, scalable, reusable graphics, Asymptote is worth exploring. Its expanding set of features combined with an active community make it an accessible and flexible choice for technical illustration tasks.

Leave a Reply

Your email address will not be published. Required fields are marked *