summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-tikz-paths.tex
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2006-01-09 00:56:57 +0000
committerKarl Berry <karl@freefriends.org>2006-01-09 00:56:57 +0000
commitf07bb53970ee2ecc53f81a206a3d3a67ef665e4a (patch)
tree6f57a1d62971db79e5ff023bdfd83b22cb971dc9 /Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-tikz-paths.tex
parent007f67a693e4d031fd3d792df8e4d5f43e2cb2e7 (diff)
doc 6
git-svn-id: svn://tug.org/texlive/trunk@85 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-tikz-paths.tex')
-rw-r--r--Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-tikz-paths.tex1266
1 files changed, 1266 insertions, 0 deletions
diff --git a/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-tikz-paths.tex b/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-tikz-paths.tex
new file mode 100644
index 00000000000..9eaffdcd086
--- /dev/null
+++ b/Master/texmf-dist/doc/generic/pgf/text-en/pgfmanual-en-tikz-paths.tex
@@ -0,0 +1,1266 @@
+% Copyright 2005 by Till Tantau <tantau@cs.tu-berlin.de>.
+%
+% This program can be redistributed and/or modified under the terms
+% of the LaTeX Project Public License Distributed from CTAN
+% archives in directory macros/latex/base/lppl.txt.
+
+
+\section{Syntax for Path Specifications}
+
+A \emph{path} is a series of straight and curved line segments. It is
+specified following a |\path| command and the specification must
+follow a special syntax, which is described in the subsections of the
+present section.
+
+
+\begin{command}{\path\meta{specification}|;|}
+ This command is available only inside a |{tikzpicture}| environment.
+
+ The \meta{specification} is a long stream of \emph{path
+ operations}. Most of these path operations tell \tikzname\ how the path
+ is build. For example, when you write |--(0,0)|, you use a
+ \emph{line-to operation} and it means ``continue the path from
+ wherever you are to the origin.''
+
+ At any point where \tikzname\ expects a path operation, you can also
+ give some graphic options, which is a list of options in brackets,
+ such as |[rounded corners]|. These options can have different
+ effects:
+ \begin{enumerate}
+ \item
+ Some options take ``immediate'' effect and apply to all subsequent
+ path operations on the path. For example, the |rounded corners|
+ option will round all following corners, but not the corners
+ ``before'' and if the |sharp corners| is given later on the path
+ (in a new set of brackets), the rounding effect will end.
+
+\begin{codeexample}[]
+\tikz \draw (0,0) -- (1,1)
+ [rounded corners] -- (2,0) -- (3,1)
+ [sharp corners] -- (3,0) -- (2,1);
+\end{codeexample}
+ Another example are the transformation options, which also apply
+ only to subsequent coordinates.
+ \item
+ The options that have immediate effect can be ``scoped'' by
+ putting part of a path in curly braces. For example, the above
+ example could also be written as follows:
+
+\begin{codeexample}[]
+\tikz \draw (0,0) -- (1,1)
+ {[rounded corners] -- (2,0) -- (3,1)}
+ -- (3,0) -- (2,1);
+\end{codeexample}
+ \item
+ Some options only apply to the path as a whole. For example, the
+ |color=| option for determining the color used for, say, drawing
+ the path always applies to all parts of the path. If several
+ different colors are given for different parts of the path, only
+ the last one (on the outermost scope) ``wins'':
+
+\begin{codeexample}[]
+\tikz \draw (0,0) -- (1,1)
+ [color=red] -- (2,0) -- (3,1)
+ [color=blue] -- (3,0) -- (2,1);
+\end{codeexample}
+
+ Most options are of this type. In the above example, we would have
+ had to ``split up'' the path into several |\path| commands:
+\begin{codeexample}[]
+\tikz{\draw (0,0) -- (1,1);
+ \draw [color=red] (2,0) -- (3,1);
+ \draw [color=blue] (3,0) -- (2,1);}
+\end{codeexample}
+ \end{enumerate}
+
+ By default, the |\path| command does ``nothing'' with the
+ path, it just ``throws it away.'' Thus, if you write
+ |\path(0,0)--(1,1);|, nothing is drawn
+ in your picture. The only effect is that the area occupied by the
+ picture is (possibly) enlarged so that the path fits inside the
+ area. To actually ``do'' something with the path, an option like
+ |draw| or |fill| must be given somewhere on the path. Commands like
+ |\draw| do this implicitly.
+
+ Finally, it is also possible to give \emph{node specifications} on a
+ path. Such specifications can come at different locations, but they
+ are always allowed when a normal path operation could follow. A node
+ specification starts with |node|. Basically, the effect is to
+ typeset the node's text as normal \TeX\ text and to place
+ it at the ``current location'' on the path. The details are explained
+ in Section~\ref{section-nodes}.
+
+ Note, however, that the nodes are \emph{not} part of the path in any
+ way. Rather, after everything has been done with the path what is
+ specified by the path options (like filling and drawing the path due
+ to a |fill| and a |draw| option somewhere in the
+ \meta{specification}), the nodes are added in a post-processing
+ step.
+
+ The following style influences scopes:
+ \begin{itemize}
+ \itemstyle{every path}
+ This style is installed at the beginning of every path. This can
+ be useful for (temporarily) adding, say, the |draw| option to
+ everything in a scope.
+\begin{codeexample}[]
+\begin{tikzpicture}[fill=examplefill] % only sets the color
+ \tikzstyle{every path}=[draw] % all paths are drawn
+ \fill (0,0) rectangle +(1,1);
+ \shade (2,0) rectangle +(1,1);
+\end{tikzpicture}
+\end{codeexample}
+ \end{itemize}
+\end{command}
+
+
+
+
+\subsection{The Move-To Operation}
+
+The perhaps simplest operation is the move-to operation, which is
+specified by just giving a coordinate where a path operation is
+expected.
+
+\begin{pathoperation}[noindex]{}{\meta{coordinate}}
+ \index{empty@\protect\meta{empty} path operation}%
+ \index{Path operations!empty@\protect\texttt{\meta{empty}}}%
+ The move-to operation normally starts a path at a certain
+ point. This does not cause a line segment to be created, but it
+ specifies the starting point of the next segment. If a path is
+ already under construction, that is, if several segments have
+ already been created, a move-to operation will start a new part of the
+ path that is not connected to any of the previous segments.
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (0,0) --(2,0) (0,1) --(2,1);
+\end{tikzpicture}
+\end{codeexample}
+
+ In the specification |(0,0) --(2,0) (0,1) --(2,1)| two move-to
+ operations are specified: |(0,0)| and |(0,1)|. The other two
+ operations, namely |--(2,0)| and |--(2,1)| are line-to operations,
+ described next.
+\end{pathoperation}
+
+
+\subsection{The Line-To Operation}
+
+
+\subsubsection{Straight Lines}
+
+\begin{pathoperation}{--}{\meta{coordinate}}
+ The line-to operation extends the current path from the current
+ point in a straight line to the given coordinate. The ``current
+ point'' is the endpoint of the previous drawing operation or the point
+ specified by a prior move-to operation.
+
+ You use two minus signs followed by a coordinate in round
+ brackets. You can add spaces before and after the~|--|.
+
+ When a line-to operation is used and some path segment has just been
+ constructed, for example by another line-to operation, the two line
+ segments become joined. This means that if they are drawn, the point
+ where they meet is ``joined'' smoothly. To appreciate the difference,
+ consider the following two examples: In the left example, the path
+ consists of two path segments that are not joined, but that happen to
+ share a point, while in the right example a smooth join is shown.
+
+\begin{codeexample}[]
+\begin{tikzpicture}[line width=10pt]
+ \draw (0,0) --(1,1) (1,1) --(2,0);
+ \draw (3,0) -- (4,1) -- (5,0);
+ \useasboundingbox (0,1.5); % make bounding box higher
+\end{tikzpicture}
+\end{codeexample}
+
+\end{pathoperation}
+
+
+\subsubsection{Horizontal and Vertical Lines}
+
+Sometimes you want to connect two points via straight lines that are
+only horizontal and vertical. For this, you can use two path
+construction operations.
+
+{\catcode`\|=12
+\begin{pathoperation}[noindex]{-|}{\meta{coordinate}}
+ \index{--1@\protect\texttt{-\protect\pgfmanualbar} path operation}%
+ \index{Path operations!--1@\protect\texttt{-\protect\pgfmanualbar}}%
+ This operation means ``first horizontal, then vertical.''
+
+ \begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (0,0) node(a) [draw] {A} (1,1) node(b) [draw] {B};
+ \draw (a.north) |- (b.west);
+ \draw[color=red] (a.east) -| (2,1.5) -| (b.north);
+\end{tikzpicture}
+\end{codeexample}
+\end{pathoperation}
+\begin{pathoperation}[noindex]{|-}{\meta{coordinate}}
+ \index{--2@\protect\texttt{\protect\pgfmanualbar-} path operation}%
+ \index{Path operations!--2@\protect\texttt{\protect\pgfmanualbar-}}%
+ This operations means ``first vertical, then horizontal.''
+\end{pathoperation}
+}
+
+
+\subsubsection{Snaked Lines}
+\label{section-tikz-snakes}
+
+The line-to operation can not only be used to append straight lines to
+the path, but also ``snaked'' lines (called thus because they look a
+little bit like snakes seen from above).
+
+\tikzname\ and \pgfname\ use a concept that I termed \emph{snakes}
+for appending such ``squiggly'' lines. A snake specifies a way of
+extending a path between two points in a ``fancy manner.''
+
+Normally, a snake will just connect the start point to the end point
+without starting new subpaths. Thus, a path containing a snaked line
+can, nevetheless, still be used for filling. However, this is not
+always the case. Some snakes consist of numerous unconnected
+segments. ``Lines'' consisting of such snakes cannot be used as the
+borders of enclosed areas.
+
+Here are some examples of snakes in action:
+
+\begin{codeexample}[]
+\begin{tikzpicture}[thick]
+ \draw (0,3) -- (3,3);
+ \draw[snake=zigzag] (0,2.5) -- (3,2.5);
+ \draw[snake=brace] (0,2) -- (3,2);
+ \draw[snake=triangles] (0,1.5) -- (3,1.5);
+ \draw[snake=coil,segment length=4pt] (0,1) -- (3,1);
+ \draw[snake=coil,segment aspect=0] (0,.5) -- (3,.5);
+ \draw[snake=expanding waves,segment angle=7] (0,0) -- (3,0);
+\end{tikzpicture}
+\end{codeexample}
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \filldraw[fill=red!20,snake=bumps] (0,0) rectangle (3,2);
+\end{tikzpicture}
+\end{codeexample}
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \filldraw[fill=blue!20] (0,3)
+ [snake=saw] -- (3,3)
+ [snake=coil,segment aspect=0] -- (2,1)
+ [snake=bumps] -| (0,3);
+\end{tikzpicture}
+\end{codeexample}
+
+No special path operation is needed to use a snake. Instead, you use
+the following option to ``switch on'' snaking:
+
+\begin{itemize}
+ \itemoption{snake}\opt{|=|\meta{snake name}}
+ This option causes the snake \meta{snake name} to be used for
+ subsequent line-to operations. So, whenever you use the |--| syntax
+ to specify that a straight line should be added to the path, a snake
+ to this path will be added instead. Snakes will also be used when
+ you use the \verb!-|! and \verb!|-! syntax and also when you use the
+ |rectangle| operation. Snakes will \emph{not} be used when you use
+ the curve-to operation nor when any other ``curved'' line is added
+ to the path.
+
+ This option has to be given anew for each path. However, you can
+ also leave out the \meta{snake name}. In this case, the enclosing
+ scope's \meta{snake name} is used. Thus, you can specify a
+ ``standard'' snake name for scope and then just say |\draw[snake]|
+ every time this snake should actually be used.
+
+ The \meta{snake name} |none| is special. It can be used to switch
+ off snaking after it has been switched on on a path.
+
+ A bit strangely, no valid \meta{snake names} are defined by
+ \tikzname\ by default. Instead, you have to include the library
+ package |pgflibrarysnakes|. This package defines numerous snakes,
+ see Section~\ref{section-library-snakes} for the complete list.
+\end{itemize}
+
+Most snakes can be configured. For example, for a snake that looks
+like a sine curve, you might wish to change the amplitude or the
+frequency. There are numerous options that influence these
+parameters. Not all options apply to all snakes, see
+Section~\ref{section-library-snakes} once more for details.
+
+\begin{itemize}
+ \itemoption{gap before snakes}|=|\meta{dimension}
+ This option allows you to add a certain ``gap'' to the snake at its
+ beginning. The snake will not start at the current point; instead
+ the start point of the snake is move be \meta{dimension} in the
+ direction of the target.
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw[help lines] (0,0) grid (3,2);
+ \draw[snake=zigzag] (0,1) -- ++(3,1);
+ \draw[snake=zigzag,gap before snake=1cm] (0,0) -- ++(3,1);
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{gap after snake}|=|\meta{dimension}
+ This option has the same effect as |gap before snake|, only it
+ affects the end of the snake, which will ``end early.''
+ \itemoption{gap around snake}|=|\meta{dimension}
+ This option sets the gap before and after the gap to
+ \meta{dimension}.
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw[help lines] (0,0) grid (3,2);
+ \draw[snake=brace] (0,1) -- ++(3,1);
+ \draw[snake=brace,gap around snake=5mm] (0,0) -- ++(3,1);
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{line before snake}|=|\meta{dimension}
+ This option works like |gap before snake|, only it will connect the
+ current point with a straight line to the start of the snake.
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw[help lines] (0,0) grid (3,2);
+ \draw[snake=zigzag] (0,1) -- ++(3,1);
+ \draw[snake=zigzag,line before snake=1cm] (0,0) -- ++(3,1);
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{line after snake}|=|\meta{dimension}
+ Works line |gap after snake|, only it adds a straight line.
+ \itemoption{line around snake}|=|\meta{dimension}
+ Works line |gap around snake|, only it adds straight lines.
+ \itemoption{raise snake}|=|\meta{dimension}
+ This option can be used with all snakes. It will offset the snake by
+ ``raising'' it by \meta{dimension}. A negative \meta{dimension} will
+ lower the snake. Raising and lowering is always relative to the line
+ along which the snake is drawn. Here is an example:
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \node (a) {A};
+ \node (b) at (2,1) {B};
+ \draw (a) -- (b);
+ \draw[snake=brace] (a) -- (b);
+ \draw[snake=brace,raise snake=5pt,red] (a) -- (b);
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{mirror snake}
+ This option causes the snake to be ``reflected along the path.''
+ This is best understood by looking at an example:
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \node (a) {A};
+ \node (b) at (2,1) {B};
+ \draw (a) -- (b);
+ \draw[snake=brace] (a) -- (b);
+ \draw[snake=brace,mirror snake,red,thick] (a) -- (b);
+\end{tikzpicture}
+\end{codeexample}
+ This option can be used with every snake and can be combined with
+ the |raise snake| option.
+ \itemoption{segment amplitude}|=|\meta{dimension}
+ This option sets the ``amplitude'' of the snake. For a snake that is
+ a sine wave this would be the amplitude of this line. For other
+ snakes this value typically describes how far the snakes ``rises
+ above'' or ``falls below'' the path. For some snakes, this value is
+ ignored.
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \node (a) {A} node (b) at (2,1) {B} node (c) at (2,-1) {C};
+ \draw[snake=zigzag] (a) -- (b);
+ \draw[snake=zigzag,segment amplitude=5pt,red,thick] (a) -- (c);
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{segment length}|=|\meta{dimension}
+ This option sets the length of each ``segment'' of a snake. For a
+ sine wave this would be the wave length, for other snakes it is the
+ length of each ``repetitive part'' of the snake.
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \node (a) {A} node (b) at (2,1) {B} node (c) at (2,-1) {C};
+ \draw[snake=zigzag] (a) -- (b);
+ \draw[snake=zigzag,segment length=20pt,red,thick] (a) -- (c);
+\end{tikzpicture}
+\end{codeexample}
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \node (a) {A} node (b) at (2,1) {B} node (c) at (2,-1) {C};
+ \draw[snake=bumps] (a) -- (b);
+ \draw[snake=bumps,segment length=20pt,red,thick] (a) -- (c);
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{segment object length}|=|\meta{dimension}
+ This option sets the length of the objects inside each segment of a
+ snake. This option is only used for snakes in which each segment
+ contains an object like a triangle or a star.
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \node (a) {A} node (b) at (2,1) {B} node (c) at (2,-1) {C};
+ \draw[snake=triangles] (a) -- (b);
+ \draw[snake=triangles,segment object length=8pt,red,thick] (a) -- (c);
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{segment angle}|=|\meta{degrees}
+ This option sets an angle that is interpreted in a snake-specific
+ way. For example, the |waves| and |expanding waves| snakes interpret
+ this as (half the) opening angle of the wave. The |border| snake
+ uses this value for the angle of the little ticks.
+\begin{codeexample}[]
+\begin{tikzpicture}[segment amplitude=10pt]
+ \node (a) {A} node (b) at (2,0) {B};
+ \draw[snake=border] (a) -- (b);
+ \draw[snake=border,segment angle=20,red,thick] (a) -- (b);
+\end{tikzpicture}
+\end{codeexample}
+\begin{codeexample}[]
+\begin{tikzpicture}[segment amplitude=10pt]
+ \node (a) {A} node (b) at (2,0) {B};
+ \node (a') at (0,-1) {A} node (b') at (2,-1) {B};
+ \draw[snake=expanding waves] (a) -- (b);
+ \draw[snake=expanding waves,segment angle=20,red,thick] (a') -- (b');
+\end{tikzpicture}
+\end{codeexample}
+ \itemoption{segment aspect}|=|\meta{ratio}
+ This option sets an aspect ratio that is interpreted in a
+ snake-specific way. For example, for the |coils| snake this
+ describes the ``direction'' from which the coil is viewed.
+\begin{codeexample}[]
+\begin{tikzpicture}[segment amplitude=5pt,segment length=5pt]
+ \node (a) {A} node (b) at (2,1) {B} node (c) at (2,-1) {C};
+ \draw[snake=coil] (a) -- (b);
+ \draw[snake=coil,segment aspect=0,red,thick] (a) -- (c);
+\end{tikzpicture}
+\end{codeexample}
+\end{itemize}
+
+It is possible to define new snakes, but this cannot be done inside
+\tikzname. You need to use the command |\pgfdeclaresnake| from the
+basic level directly, see Section~\ref{section-base-snakes}.
+
+The following styles define combinations of segment settings that may
+be useful:
+\begin{itemize}
+ \itemstyle{snake triangles 45}
+ Installs a snake the consists of little triangles with an opening
+ angle of $45^\circ$.
+ \itemstyle{snake triangles 60}
+ Installs a snake the consists of little triangles with an opening
+ angle of $60^\circ$.
+ \itemstyle{snake triangles 90}
+ Installs a snake the consists of little triangles with an opening
+ angle of $90^\circ$.
+\end{itemize}
+
+
+
+\subsection{The Curve-To Operation}
+
+The curve-to operation allows you to extend a path using a Bézier
+curve.
+
+\begin{pathoperation}{..}{\declare{|controls|}\meta{c}\opt{|and|\meta{d}}\declare{|..|\meta{y}}}
+ This operation extends the current path from the current
+ point, let us call it $x$, via a curve to a the current point~$y$.
+ The curve is a cubic Bézier curve. For such a curve,
+ apart from $y$, you also specify two control points $c$ and $d$. The
+ idea is that the curve starts at $x$, ``heading'' in the direction
+ of~$c$. Mathematically spoken, the tangent of the curve at $x$ goes
+ through $c$. Similarly, the curve ends at $y$, ``coming from'' the
+ other control point,~$d$. The larger the distance between $x$ and~$c$
+ and between $d$ and~$y$, the larger the curve will be.
+
+ If the ``|and|\meta{d}'' part is not given, $d$ is assumed to be
+ equal to $c$.
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw[line width=10pt] (0,0) .. controls (1,1) .. (4,0)
+ .. controls (5,0) and (5,1) .. (4,1);
+ \draw[color=gray] (0,0) -- (1,1) -- (4,0) -- (5,0) -- (5,1) -- (4,1);
+\end{tikzpicture}
+\end{codeexample}
+
+ As with the line-to operation, it makes a difference whether two curves
+ are joined because they resulted from consecutive curve-to or line-to
+ operations, or whether they just happen to have the same ending:
+
+\begin{codeexample}[]
+\begin{tikzpicture}[line width=10pt]
+ \draw (0,0) -- (1,1) (1,1) .. controls (1,0) and (2,0) .. (2,0);
+ \draw (3,0) -- (4,1) .. controls (4,0) and (5,0) .. (5,0);
+ \useasboundingbox (0,1.5); % make bounding box higher
+\end{tikzpicture}
+\end{codeexample}
+\end{pathoperation}
+
+
+\subsection{The Cycle Operation}
+
+\begin{pathoperation}{--cycle}{}
+ This operation adds a straight line from the current
+ point to the last point specified by a move-to operation. Note that
+ this need not be the beginning of the path. Furthermore, a smooth join
+ is created between the first segment created after the last move-to
+ operation and the straight line appended by the cycle operation.
+
+ Consider the following example. In the left example, two triangles are
+ created using three straight lines, but they are not joined at the
+ ends. In the second example cycle operations are used.
+
+\begin{codeexample}[]
+\begin{tikzpicture}[line width=10pt]
+ \draw (0,0) -- (1,1) -- (1,0) -- (0,0) (2,0) -- (3,1) -- (3,0) -- (2,0);
+ \draw (5,0) -- (6,1) -- (6,0) -- cycle (7,0) -- (8,1) -- (8,0) -- cycle;
+ \useasboundingbox (0,1.5); % make bounding box higher
+\end{tikzpicture}
+\end{codeexample}
+\end{pathoperation}
+
+
+
+\subsection{The Rectangle Operation}
+
+A rectangle can obviously be created using four straight lines and a
+cycle operation. However, since rectangles are needed so often, a
+special syntax is available for them.
+
+\begin{pathoperation}{rectangle}{\meta{corner}}
+ When this operation is used, one corner will be the current point,
+ another corner is given by \meta{corner}, which becomes the new
+ current point.
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (0,0) rectangle (1,1);
+ \draw (.5,1) rectangle (2,0.5) (3,0) rectangle (3.5,1.5) -- (2,0);
+\end{tikzpicture}
+\end{codeexample}
+\end{pathoperation}
+
+
+\subsection{Rounding Corners}
+
+All of the path construction operations mentioned up to now are
+influenced by the following option:
+\begin{itemize}
+ \itemoption{rounded corners}\opt{|=|\meta{inset}}
+ When this option is in force, all corners (places where a line is
+ continued either via line-to or a curve-to operation) are replaced by
+ little arcs so that the corner becomes smooth.
+
+\begin{codeexample}[]
+\tikz \draw [rounded corners] (0,0) -- (1,1)
+ -- (2,0) .. controls (3,1) .. (4,0);
+\end{codeexample}
+
+ The \meta{inset} describes how big the corner is. Note that the
+ \meta{inset} is \emph{not} scaled along if you use a scaling option
+ like |scale=2|.
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw[color=gray,very thin] (10pt,15pt) circle (10pt);
+ \draw[rounded corners=10pt] (0,0) -- (0pt,25pt) -- (40pt,25pt);
+\end{tikzpicture}
+\end{codeexample}
+
+ You can switch the rounded corners on and off ``in the middle of
+ path'' and different corners in the same path can have different
+ corner radii:
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (0,0) [rounded corners=10pt] -- (1,1) -- (2,1)
+ [sharp corners] -- (2,0)
+ [rounded corners=5pt] -- cycle;
+\end{tikzpicture}
+\end{codeexample}
+
+Here is a rectangle with rounded corners:
+\begin{codeexample}[]
+\tikz \draw[rounded corners=1ex] (0,0) rectangle (20pt,2ex);
+\end{codeexample}
+
+ You should be aware, that there are several pitfalls when using this
+ option. First, the rounded corner will only be an arc (part of a
+ circle) if the angle is $90^\circ$. In other cases, the rounded
+ corner will still be round, but ``not as nice.''
+
+ Second, if there are very short line segments in a path, the
+ ``rounding'' may cause inadverted effects. In such case it may be
+ necessary to temporarily switch off the rounding using
+ |sharp corners|.
+
+ \itemoption{sharp corners}
+ This options switches off any rounding on subsequent corners of the
+ path.
+\end{itemize}
+
+
+
+\subsection{The Circle and Ellipse Operations}
+
+A circle can be approximated well using four Bézier curves. However,
+it is difficult to do so correctly. For this reason, a special syntax
+is available for adding such an approximation of a circle to the
+current path.
+
+\begin{pathoperation}{circle}{|(|\meta{radius}|)|}
+ The center of the circle is given by the current point. The new
+ current point of the path will remain to be the center of the
+ circle.
+\end{pathoperation}
+
+\begin{pathoperation}{ellipse}{|(|\meta{half width}| and |\meta{half height}|)|}
+ Note that you can add spaces after |ellipse|, but you have to place
+ spaces around |and|.
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (1,0) circle (.5cm);
+ \draw (3,0) ellipse (1cm and .5cm) -- ++(3,0) circle (.5cm)
+ -- ++(2,-.5) circle (.25cm);
+\end{tikzpicture}
+\end{codeexample}
+\end{pathoperation}
+
+
+\subsection{The Arc Operation}
+
+The \emph{arc operation} allows you to add an arc to the current
+path.
+\begin{pathoperation}{arc}{|(|\meta{start angle}|:|\meta{end
+ angle}|:|\meta{radius}\opt{|/|\meta{half height}}|)|}
+ The arc operation adds a part of a circle of the given radius
+ between the given angles. The arc will start at the current point
+ and will end at the end of the arc.
+
+ \begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (0,0) arc (180:90:1cm) -- (2,.5) arc (90:0:1cm);
+ \draw (4,0) -- +(30:1cm) arc (30:60:1cm) -- cycle;
+ \draw (8,0) arc (0:270:1cm/.5cm) -- cycle;
+\end{tikzpicture}
+\end{codeexample}
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (-1,0) -- +(3.5,0);
+ \draw (1,0) ++(210:2cm) -- +(30:4cm);
+ \draw (1,0) +(0:1cm) arc (0:30:1cm);
+ \draw (1,0) +(180:1cm) arc (180:210:1cm);
+ \path (1,0) ++(15:.75cm) node{$\alpha$};
+ \path (1,0) ++(15:-.75cm) node{$\beta$};
+\end{tikzpicture}
+\end{codeexample}
+\end{pathoperation}
+
+
+\subsection{The Grid Operation}
+
+You can add a grid to the current path using the |grid| path
+operation.
+
+\begin{pathoperation}{grid}{\opt{\oarg{options}}\meta{corner}}
+ This operations adss a grid filling a rectangle whose two corners
+ are given by \meta{corner} and by the previous coordinate. Thus, the
+ typical way in which a grid is drawn is |\draw (1,1) grid (3,3);|,
+ which yields a grid filling the rectangle whose corners are at
+ $(1,1)$ and $(3,3)$. All coordinate transformations apply to the grid.
+
+\begin{codeexample}[]
+\tikz[rotate=30] \draw[step=1mm] (0,0) grid (2,2);
+\end{codeexample}
+
+ The stepping of the grid is governed by the following options:
+
+\begin{itemize}
+ \itemoption{step}|=|\meta{dimension} sets the stepping in both the
+ $x$ and $y$-direction.
+ \itemoption{xstep}|=|\meta{dimension} sets the stepping in the
+ $x$-direction.
+ \itemoption{ystep}|=|\meta{dimension} sets the stepping in the
+ $y$-direction.
+\end{itemize}
+
+ It is important to note that the grid is always ``phased'' such that
+ it contains the point $(0,0)$ if that point happens to be inside the
+ rectangle. Thus, the grid does \emph{not} always have an intersection
+ at the corner points; this occurs only if the corner points are
+ multiples of the stepping. Note that due to rounding errors, the
+ ``last'' lines of a grid may be omitted. In this case, you have to
+ add an epsilon to the corner points.
+
+ The following style is useful for drawing grids:
+\begin{itemize}
+ \itemstyle{help lines}
+ This style makes lines ``subdued'' by using thin gray lines for
+ them. However, this style is not installed automatically and you
+ have to say for example:
+\begin{codeexample}[]
+\tikz \draw[style=help lines] (0,0) grid (3,3);
+\end{codeexample}
+\end{itemize}
+\end{pathoperation}
+
+
+
+\subsection{The Parabola Operation}
+
+The |parabola| path operation continues the current path with a
+parabola. A parabola is a (shifted and scaled) curve defined by the
+equation $f(x) = x^2$ and looks like this: \tikz \draw (-1ex,1.5ex)
+parabola[parabola height=-1.5ex] +(2ex,0ex);.
+
+\begin{pathoperation}{parabola}{\opt{\oarg{options}|bend|\meta{bend
+ coordinate}}\meta{coordinate}}
+ This operation adds a parabola through the current point and the
+ given \meta{coordinate}. If the |bend| is given, it specifies where
+ the bend should go; the \meta{options} can also be used to specify
+ where the bend is. By default, the bend is at the old current point.
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (0,0) rectangle (1,1.5)
+ (0,0) parabola (1,1.5);
+ \draw[xshift=1.5cm] (0,0) rectangle (1,1.5)
+ (0,0) parabola[bend at end] (1,1.5);
+ \draw[xshift=3cm] (0,0) rectangle (1,1.5)
+ (0,0) parabola bend (.75,1.75) (1,1.5);
+\end{tikzpicture}
+\end{codeexample}
+
+ The following options influence parabolas:
+\begin{itemize}
+ \itemoption{bend}|=|\meta{coordinate}
+ Has the same effect as saying |bend|\meta{coordinate} outside the
+ \meta{options}. The option specifies that the bend of the parabola
+ should be at the given \meta{coordinate}. You have to take care
+ yourself that the bend position is a ``valid'' position; which means
+ that if there is no parabola of the form $f(x) = a x^2 + b x + c$
+ that goes through the old current point, the given bend, and the new
+ current point, the result will not be a parabola.
+
+ There is one special property of the \meta{coordinate}: When a
+ relative coordinate is given like |+(0,0)|, the position relative
+ to which this coordinate is ``flexible.'' More precisely, this
+ position lies somewhere on a line from the old current point to the
+ new current point. The exact position depends on the next
+ option.
+
+ \itemoption{bend pos}|=|\meta{fraction}
+ Specifies where the ``previous'' point is relative to which the bend
+ is calculated. The previous point will be at the \meta{fraction}th
+ part of the line from the old current point to the new current
+ point.
+
+ The idea is the following: If you say |bend pos=0| and
+ |bend +(0,0)|, the bend will be at the old current point. If you say
+ |bend pos=1| and |bend +(0,0)|, the bend will be at the new current
+ point. If you say |bend pos=0.5| and |bend +(0,2cm)| the bend will
+ be 2cm above the middle of the line between the start and end
+ point. This is most useful in situations such as the following:
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw[help lines] (0,0) grid (3,2);
+ \draw (-1,0) parabola[bend pos=0.5] bend +(0,2) +(3,0);
+\end{tikzpicture}
+\end{codeexample}
+
+ In the above example, the |bend +(0,2)| essentially means ``a
+ parabola that is 2cm high'' and |+(3,0)| means ``and 3cm wide.''
+ Since this situation arises often, there is a special shortcut
+ option:
+ \itemoption{parabola height}|=|\meta{dimension} This option has the
+ same effect as if you had written the following instead:
+ |[bend pos=0.5,bend={+(0pt,|\meta{dimension}|)}]|.
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw[help lines] (0,0) grid (3,2);
+ \draw (-1,0) parabola[parabola height=2cm] +(3,0);
+\end{tikzpicture}
+\end{codeexample}
+\end{itemize}
+
+The following styles are useful shortcuts:
+\begin{itemize}
+ \itemstyle{bend at start} This places the bend at the start of a
+ parabola. It is a shortcut for the following options:
+ |bend pos=0,bend={+(0,0)}|.
+ \itemstyle{bend at end} This places the bend at the end of a
+ parabola.
+\end{itemize}
+\end{pathoperation}
+
+
+\subsection{The Sine and Cosine Operation}
+
+The |sin| and |cos| operations are similar to the |parabola|
+operation. They, too, can be used to draw (parts of) a sine or cosine
+curve.
+
+\begin{pathoperation}{sin}{\meta{coordinate}}
+ The effect of |sin| is to draw a scaled and shifted version of a sine
+ curve in the interval $[0,\pi/2]$. The scaling and shifting is done in
+ such a way that the start of the sine curve in the interval is at the
+ old current point and that the end of the curve in the interval is at
+ \meta{coordinate}. Here is an example that should clarify this:
+
+\begin{codeexample}[]
+\tikz \draw (0,0) rectangle (1,1) (0,0) sin (1,1)
+ (2,0) rectangle +(1.57,1) (2,0) sin +(1.57,1);
+\end{codeexample}
+\end{pathoperation}
+
+\begin{pathoperation}{cos}{\meta{coordinate}}
+ This operation works similarly, only a cosine in the interval
+ $[0,\pi/2]$ is drawn. By correctly alternating |sin| and |cos|
+ operations, you can create a complete sine or cosine curve:
+
+\begin{codeexample}[]
+\begin{tikzpicture}[xscale=1.57]
+ \draw (0,0) sin (1,1) cos (2,0) sin (3,-1) cos (4,0) sin (5,1);
+ \draw[color=red] (0,1.5) cos (1,0) sin (2,-1.5) cos (3,0) sin (4,1.5) cos (5,0);
+\end{tikzpicture}
+\end{codeexample}
+\end{pathoperation}
+
+Note that there is no way to (conveniently) draw an interval on a sine
+or cosine curve whose end points are not multiples of $\pi/2$.
+
+
+
+\subsection{The Plot Operation}
+
+The |plot| operation can be used to append a line or curve to the path
+that goes through a large number of coordinates. These coordinates are
+either given in a simple list of coordinates or they are read from
+some file.
+
+The syntax of the |plot| comes in different versions.
+
+\begin{pathoperation}{--plot}{\meta{further arguments}}
+ This operation plots the curve through the coordinates specified in
+ the \meta{further arguments}. The current (sub)path is simply
+ continued, that is, a line-to operation to the first point of the
+ curve is implicitly added. The details of the \meta{further
+ arguments} will be explained in a moment.
+\end{pathoperation}
+
+\begin{pathoperation}{plot}{\meta{further arguments}}
+ This operation plots the curve through the coordinates specified in
+ the \meta{further arguments} by first ``moving'' to the first
+ coordinate of the curve.
+\end{pathoperation}
+
+The \meta{further arguments} are used in three different ways to
+specifying the coordinates of the points to be plotted:
+
+\begin{enumerate}
+\item
+ \opt{|--|}|plot|\oarg{local options}\declare{|coordinates{|\meta{coordinate
+ 1}\meta{coordinate 2}\dots\meta{coordinate $n$}|}|}
+\item
+ \opt{|--|}|plot|\oarg{local options}\declare{|file{|\meta{filename}|}|}
+\item
+ \opt{|--|}|plot|\oarg{local options}\declare{|function{|\meta{gnuplot formula}|}|}
+\end{enumerate}
+
+These different ways are explained in the following.
+
+
+\subsubsection{Plotting Points Given Inline}
+
+In the first two cases, the points are given directly in the \TeX-file
+as in the following example:
+
+\begin{codeexample}[]
+\tikz \draw plot coordinates {(0,0) (1,1) (2,0) (3,1) (2,1) (10:2cm)};
+\end{codeexample}
+
+Here is an example showing the difference between |plot| and |--plot|:
+
+\begin{codeexample}[]
+\begin{tikzpicture}
+ \draw (0,0) -- (1,1) plot coordinates {(2,0) (4,0)};
+ \draw[color=red,xshift=5cm]
+ (0,0) -- (1,1) -- plot coordinates {(2,0) (4,0)};
+\end{tikzpicture}
+\end{codeexample}
+
+
+\subsubsection{Plotting Points Read From an External File}
+
+The second way of specifying points is to put them in an external
+file named \meta{filename}. Currently, the only file format that
+\tikzname\ allows is the following: Each line of the \meta{filename}
+should contain one line starting with two numbers, separated by a
+space. Anything following the two numbers on the line is
+ignored. Also, lines starting with a |%| or a |#| are ignored as well
+as empty lines. (This is exactly the format that \textsc{gnuplot}
+produces when you say |set terminal table|.) If necessary, more
+formats will be supported in the future, but it is usually easy to
+produce a file containing data in this form.
+
+\begin{codeexample}[]
+\tikz \draw plot[mark=x,smooth] file {plots/pgfmanual-sine.table};
+\end{codeexample}
+
+The file |plots/pgfmanual-sine.table| reads:
+\begin{codeexample}[code only]
+#Curve 0, 20 points
+#x y type
+0.00000 0.00000 i
+0.52632 0.50235 i
+1.05263 0.86873 i
+1.57895 0.99997 i
+...
+9.47368 -0.04889 i
+10.00000 -0.54402 i
+\end{codeexample}
+It was produced from the following source, using |gnuplot|:
+\begin{codeexample}[code only]
+set terminal table
+set output "../plots/pgfmanual-sine.table"
+set format "%.5f"
+set samples 20
+plot [x=0:10] sin(x)
+\end{codeexample}
+
+The \meta{local options} of the |plot| operation are local to each
+plot and do not affect other plots ``on the same path.'' For example,
+|plot[yshift=1cm]| will locally shift the plot 1cm upward. Remember,
+however, that most options can only be applied to paths as a
+whole. For example, |plot[red]| does not have the effect of making the
+plot red. After all, you are trying to ``locally'' make part of the
+path red, which is not possible.
+
+\subsubsection{Plotting a Function}
+\label{section-tikz-gnuplot}
+
+Often, you will want to plot points that are given via a function like
+$f(x) = x \sin x$. Unfortunately, \TeX\ does not really have enough
+computational power to generate the points on such a function
+efficiently (it is a text processing program, after all). However,
+if you allow it, \TeX\ can try to call external programs that can
+easily produce the necessary points. Currently, \tikzname\ knows how to
+call \textsc{gnuplot}.
+
+When \tikzname\ encounters your operation
+|plot[id=|\meta{id}|] function{x*sin(x)}| for
+the first time, it will create a file called
+\meta{prefix}\meta{id}|.gnuplot|, where \meta{prefix} is |\jobname.| by
+default, that is, the name of you main |.tex| file. If no \meta{id} is
+given, it will be empty, which is alright, but it is better when each
+plot has a unique \meta{id} for reasons explained in a moment. Next,
+\tikzname\ writes some initialization code into this file followed by
+|plot x*sin(x)|. The initialization code sets up things
+such that the |plot| operation will write the coordinates into another
+file called \meta{prefix}\meta{id}|.table|. Finally, this table file
+is read as if you had said |plot file{|\meta{prefix}\meta{id}|.table}|.
+
+For the plotting mechanism to work, two conditions must be met:
+\begin{enumerate}
+\item
+ You must have allowed \TeX\ to call external programs. This is often
+ switched off by default since this is a security risk (you might,
+ without knowing, run a \TeX\ file that calls all sorts of ``bad''
+ commands). To enable this ``calling external programs'' a command
+ line option must be given to the \TeX\ program. Usually, it is
+ called something like |shell-escape| or |enable-write18|. For
+ example, for my |pdflatex| the option |--shell-escape| can be
+ given.
+\item
+ You must have installed the |gnuplot| program and \TeX\ must find it
+ when compiling your file.
+\end{enumerate}
+
+Unfortunately, these conditions will not always be met. Especially if
+you pass some source to a coauthor and the coauthor does not have
+\textsc{gnuplot} installed, he or she will have trouble compiling your
+files.
+
+For this reason, \tikzname\ behaves differently when you compile your
+graphic for the second time: If upon reaching
+|plot[id=|\meta{id}|] function{...}| the file \meta{prefix}\meta{id}|.table|
+already exists \emph{and} if the \meta{prefix}\meta{id}|.gnuplot| file
+contains what \tikzname\ thinks that it ``should'' contain, the |.table|
+file is immediately read without trying to call a |gnuplot|
+program. This approach has the following advantages:
+\begin{enumerate}
+\item
+ If you pass a bundle of your |.tex| file and all |.gnuplot| and
+ |.table| files to someone else, that person can \TeX\ the |.tex|
+ file without having to have |gnuplot| installed.
+\item
+ If the |\write18| feature is switched off for security reasons (a
+ good idea), then, upon the first compilation of the |.tex| file, the
+ |.gnuplot| will still be generated, but not the |.table|
+ file. You can then simply call |gnuplot| ``by hand'' for each
+ |.gnuplot| file, which will produce all necessary |.table| files.
+\item
+ If you change the function that you wish to plot or its
+ domain, \tikzname\ will automatically try to regenerate the |.table|
+ file.
+\item
+ If, out of laziness, you do not provide an |id|, the same |.gnuplot|
+ will be used for different plots, but this is not a problem since
+ the |.table| will automatically be regenerated for each plot
+ on-the-fly. \emph{Note: If you intend to share your files with
+ someone else, always use an id, so that the file can by typeset
+ without having \textsc{gnuplot} installed.} Also, having unique ids
+ for each plot will improve compilation speed since no external
+ programs need to be called, unless it is really necessary.
+\end{enumerate}
+
+When you use |plot function{|\meta{gnuplot formula}|}|, the \meta{gnuplot
+ formula} must be given in the |gnuplot| syntax, whose details are
+beyond the scope of this manual. Here is the ultra-condensed
+essence: Use |x| as the variable and use the C-syntax for normal
+plots, use |t| as the variable for parametric plots. Here are some examples:
+
+\begin{codeexample}[]
+\begin{tikzpicture}[domain=0:4]
+ \draw[very thin,color=gray] (-0.1,-1.1) grid (3.9,3.9);
+
+ \draw[->] (-0.2,0) -- (4.2,0) node[right] {$x$};
+ \draw[->] (0,-1.2) -- (0,4.2) node[above] {$f(x)$};
+
+ \draw[color=red] plot[id=x] function{x} node[right] {$f(x) =x$};
+ \draw[color=blue] plot[id=sin] function{sin(x)} node[right] {$f(x) = \sin x$};
+ \draw[color=orange] plot[id=exp] function{0.05*exp(x)} node[right] {$f(x) = \frac{1}{20} \mathrm e^x$};
+\end{tikzpicture}
+\end{codeexample}
+
+
+The following options influence the plot:
+
+\begin{itemize}
+ \itemoption{samples}|=|\meta{number}
+ sets the number of samples used in the plot. The default is 25.
+ \itemoption{domain}|=|\meta{start}|:|\meta{end}
+ sets the domain between which the samples are taken. The default is
+ |-5:5|.
+ \itemoption{parametric}\opt{|=|\meta{true or false}}
+ sets whether the plot is a parametric plot. If true, then |t| must
+ be used instead of |x| as the parameter and two comma-separated
+ functions must be given in the \meta{gnuplot formula}. An example is
+ the following:
+\begin{codeexample}[]
+\tikz \draw[scale=0.5,domain=-3.141:3.141,smooth]
+ plot[parametric,id=parametric-example] function{t*sin(t),t*cos(t)};
+\end{codeexample}
+
+ \itemoption{id}|=|\meta{id}
+ sets the identifier of the current plot. This should be a unique
+ identifier for each plot (though things will also work if it is not,
+ but not as well, see the explanations above). The \meta{id} will be
+ part of a filename, so it should not contain anything fancy like |*|
+ or |$|.%$
+ \itemoption{prefix}|=|\meta{prefix}
+ is put before each plot file name. The default is |\jobname.|, but
+ if you have many plots, it might be better to use, say |plots/| and
+ have all plots placed in a directory. You have to create the
+ directory yourself.
+ \itemoption{raw gnuplot}
+ causes the \meta{gnuplot formula} to be passed on to
+ \textsc{gnuplot} without setting up the samples or the |plot|
+ operation. Thus, you could write
+\begin{codeexample}[code only]
+plot[raw gnuplot,id=raw-example] function{set samples 25; plot sin(x)}
+\end{codeexample}
+ This can be
+ useful for complicated things that need to be passed to
+ \textsc{gnuplot}. However, for really complicated situations you
+ should create a special external generating \textsc{gnuplot} file
+ and use the |file|-syntax to include the table ``by hand.''
+\end{itemize}
+
+The following styles influence the plot:
+\begin{itemize}
+ \itemstyle{every plot}
+ This style is installed in each plot, that is, as if you always said
+\begin{codeexample}[code only]
+ plot[style=every plot,...]
+\end{codeexample}
+ This is most useful for globally setting a prefix for all plots by saying:
+\begin{codeexample}[code only]
+\tikzstyle{every plot}=[prefix=plots/]
+\end{codeexample}
+\end{itemize}
+
+
+
+\subsubsection{Placing Marks on the Plot}
+
+As we saw already, it is possible to add \emph{marks} to a plot using
+the |mark| option. When this option is used, a copy of the plot
+mark is placed on each point of the plot. Note that the marks are
+placed \emph{after} the whole path has been drawn/filled/shaded. In
+this respect, they are handled like text nodes.
+
+In detail, the following options govern how marks are drawn:
+\begin{itemize}
+ \itemoption{mark}|=|\meta{mark mnemonic}
+ Sets the mark to a mnemonic that has previously been defined using
+ the |\pgfdeclareplotmark|. By default, |*|, |+|, and |x| are available,
+ which draw a filled circle, a plus, and a cross as marks. Many more
+ marks become available when the library |pgflibraryplotmarks| is
+ loaded. Section~\ref{section-plot-marks} lists the available plot
+ marks.
+
+ One plot mark is special: the |ball| plot mark is available only
+ it \tikzname. The |ball color| determines the balls's color. Do not use
+ this option with large number of marks since it will take very long
+ to render in PostScript.
+
+ \begin{tabular}{lc}
+ Option & Effect \\\hline \vrule height14pt width0pt
+ \plotmarkentrytikz{ball}
+ \end{tabular}
+
+ \itemoption{mark size}|=|\meta{dimension}
+ Sets the size of the plot marks. For circular plot marks,
+ \meta{dimension} is the radius, for other plot marks
+ \meta{dimension} should be about half the width and height.
+
+ This option is not really necessary, since you achieve the same
+ effect by specifying |scale=|\meta{factor} as a local option, where
+ \meta{factor} is the quotient of the desired size and the default
+ size. However, using |mark size| is a bit faster and more natural.
+
+ \itemoption{mark options}|=|\meta{options}
+ These options are applied to marks when they are drawn. For example,
+ you can scale (or otherwise transform) the plot mark or set its
+ color.
+\begin{codeexample}[]
+\tikz \fill[fill=blue!20]
+ plot[mark=triangle*,mark options={color=blue,rotate=180}]
+ file{plots/pgfmanual-sine.table} |- (0,0);
+\end{codeexample}
+\end{itemize}
+
+
+
+\subsubsection{Smooth Plots, Sharp Plots, and Comb Plots}
+
+There are different things the |plot| operation can do with the points
+it reads from a file or from the inlined list of points. By default,
+it will connect these points by straight lines. However, you can also
+use options to change the behavior of |plot|.
+
+\begin{itemize}
+ \itemoption{sharp plot}
+ This is the default and causes the points to be connected by
+ straight lines. This option is included only so that you can
+ ``switch back'' if you ``globally'' install, say, |smooth|.
+
+ \itemoption{smooth}
+ This option causes the points on the path to be connected using a
+ smooth curve:
+
+\begin{codeexample}[]
+\tikz\draw plot[smooth] file{plots/pgfmanual-sine.table};
+\end{codeexample}
+
+ Note that the smoothing algorithm is not very intelligent. You will
+ get the best results if the bending angles are small, that is, less
+ than about $30^\circ$ and, even more importantly, if the distances
+ between points are about the same all over the plotting path.
+
+ \itemoption{tension}|=|\meta{value}
+ This option influences how ``tight'' the smoothing is. A lower value
+ will result in sharper corners, a higher value in more ``round''
+ curves. A value of $1$ results in a circle if four points at
+ quarter-positions on a circle are given. The default is $0.55$. The
+ ``correct'' value depends on the details of plot.
+
+\begin{codeexample}[]
+\begin{tikzpicture}[smooth cycle]
+ \draw plot[tension=0.2]
+ coordinates{(0,0) (1,1) (2,0) (1,-1)};
+ \draw[yshift=-2.25cm] plot[tension=0.5]
+ coordinates{(0,0) (1,1) (2,0) (1,-1)};
+ \draw[yshift=-4.5cm] plot[tension=1]
+ coordinates{(0,0) (1,1) (2,0) (1,-1)};
+\end{tikzpicture}
+\end{codeexample}
+
+ \itemoption{smooth cycle}
+ This option causes the points on the path to be connected using a
+ closed smooth curve.
+
+\begin{codeexample}[]
+\tikz[scale=0.5]
+ \draw plot[smooth cycle] coordinates{(0,0) (1,0) (2,1) (1,2)}
+ plot coordinates{(0,0) (1,0) (2,1) (1,2)} -- cycle;
+\end{codeexample}
+
+ \itemoption{ycomb}
+ This option causes the |plot| operation to interpret the plotting
+ points differently. Instead of connecting them, for each point of
+ the plot a straight line is added to the path from the $x$-axis to the point,
+ resulting in a sort of ``comb'' or ``bar diagram.''
+
+\begin{codeexample}[]
+\tikz\draw[ultra thick] plot[ycomb,thin,mark=*] file{plots/pgfmanual-sine.table};
+\end{codeexample}
+
+\begin{codeexample}[]
+\begin{tikzpicture}[ycomb]
+ \draw[color=red,line width=6pt]
+ plot coordinates{(0,1) (.5,1.2) (1,.6) (1.5,.7) (2,.9)};
+ \draw[color=red!50,line width=4pt,xshift=3pt]
+ plot coordinates{(0,1.2) (.5,1.3) (1,.5) (1.5,.2) (2,.5)};
+\end{tikzpicture}
+\end{codeexample}
+
+ \itemoption{xcomb}
+ This option works like |ycomb| except that the bars are horizontal.
+
+\begin{codeexample}[]
+\tikz \draw plot[xcomb,mark=x] coordinates{(1,0) (0.8,0.2) (0.6,0.4) (0.2,1)};
+\end{codeexample}
+
+ \itemoption{polar comb}
+ This option causes a line from the origin to the point to be added
+ to the path for each plot point.
+
+\begin{codeexample}[]
+\tikz \draw plot[polar comb,
+ mark=pentagon*,mark options={fill=white,draw=red},mark size=4pt]
+ coordinates {(0:1cm) (30:1.5cm) (160:.5cm) (250:2cm) (-60:.8cm)};
+\end{codeexample}
+
+
+ \itemoption{only marks}
+ This option causes only marks to be shown; no path segments are
+ added to the actual path. This can be useful for quickly adding some
+ marks to a path.
+
+\begin{codeexample}[]
+\tikz \draw (0,0) sin (1,1) cos (2,0)
+ plot[only marks,mark=x] coordinates{(0,0) (1,1) (2,0) (3,-1)};
+\end{codeexample}
+\end{itemize}
+
+
+
+
+
+\subsection{The Scoping Operation}
+
+When \tikzname\ encounters and opening or a closing brace (|{| or~|}|) at
+some point where a path operation should come, it will open or close a
+scope. All options that can be applied ``locally'' will be scoped
+inside the scope. For example, if you apply a transformation like
+|[xshift=1cm]| inside the scoped area, the shifting only applies to
+the scope. On the other hand, an option like |color=red| does not have
+any effect inside a scope since it can only be applied to the path as
+a whole.
+
+
+\subsection{The Node Operation}
+
+You can add nodes to a path using the |node| operation. Since this
+operation is quite complex and since the nodes are not really part of
+the path itself, there is a separate section dealing with nodes, see
+Section~\ref{section-nodes}.