Tikz

Parameters can have scope. It is introduced by {scope} invironment, taking the parameters as options, i.e. \begin{scope}[key=value]. Scopes can be nested, and have lexcial scope. The top level {tikzpicture} env also acts like a scope.

There's also a every scope option to install styless for every scope.

The scopes package provide an easier way to specify scopes, using just {[options] ...}. This is pretty useful for inside-path scoping. One line scope command is also available as \scoped[options]<path command>.

Another way to group code together is to define a style. Like help lines style. Styles are defined as an option, e.g.

my style/.style={draw=red, fill=red!20}

The .style means "these keys should not be applied immediately, but rather a definition". Later reference to it is same as written the key values literally.

There seems not to be a way to inherit a style, but rather, you can .append style. The appended style is added to the end, and the last style will win. There's also a .prefix style but not useful in this case. The content of style can be parameterized, by #n where n starts from 1. It seems that it will be replaced literally.

outline/.style={draw=#1, fill=#1!50},
outline/.default=black

Note 2 things:

1. the lexer is actually pretty good
2. can use default value (s?)

Use it as outline=blue

Yet another way is to use perpendicular coordinate system. This calculate the intersection.

• (2,1 |- 3,4): yield 2,4
• (3,4 -| 2,1)

A more general way to find intersection of two pathes is to use intersections library (TODO).

• ++(x,y): You can also use relative position. means shift to the last point used.
• +(x,y): similar to ++ but does not change the last point

Note that the scoping will not localize the position, thus to make a local part "local", you can use the /tikz/current point is local option.

The package calc provide calculation for coordinates. The general syntax is:

([options] $<coordinate computation$)

The coordinate computation is roughly

compute ::= A [+-] A [+-] A ...
A ::= <factor>*<coordinate><modifiers>

Note that the <coordinate> must be surounded by (). Modifiers can be:

• partway modifier: !number!angle:<second coordinate>, e.g. (1,2)!.75!(3,4). angle: is optional
• distance modifiers: !dimension!angle:<second coordinate>. This differs with partway that it is a concrete distance (like 1cm) instead of a percentage.
• projection modifiers: (a)!(b)!(c) means draw a line between a-c, and project b onto c, get the intersection point.

• \draw: \draw is an abbreviation for \path[draw]. It will draw the entire path if this option appear anywhere inside the path. The draw=color will specify the color.
• \fill: only for closed path. abbrev for \path[fill]. \filldraw is abbrev for \path[fill,draw].
  • fill=<color>
  • pattern=<name> TODO list of patterns
    • dots
    • bricks
  • pattern color=<color>
• \shade: similarly there're \shade and \shadedraw

• \clip: does NOT have \clipdraw because it seems not making sense. If you want, use \path[draw,clip] explicitly

clip can be nested, and the clipped area will be in effect for the subsequent path. Those path will not affect the picture size. The only way to end the clip is to close the scope. Thus scope is typically used to create local clip, and clip is typically the first path in a scope.

A path can be used as a bounding box. It can be used in two ways, make it smaller or bigger.

Smaller

  Letf\begin{tikzpicture}
  \draw[use as bounding box] (2,0) rectangle (3,1);
  \draw (1,0) -- (4.75);
  \end{tikzpicture}Right

The second draw will be out of the box of this picture, and strike through the text.

Bigger

Left
\begin{tikzpicture}
\useasboundingbox (0,0) rectangle (3,1);
\fill (0.75, .25) cicle (.5cm);
\end{tikzpicture}
Right

The bounding box is larger than the filled circle, so the text will be further apart.

There's a node current bounding box, which has the shape of rectangle. For a single path, there's also a node called current path bounding box. The tikzpicture env also supports a trim left (which has a default of 0pt) and trim right. It will trim the bounding box, not the figure.

Options are only applied to the node itself, possible options are:

• draw
• fill
• shape=rectangle, circle, ellipse
• behind path
• in front of path
• inner sep: set the following together
  • inner xsep
  • inner ysep
• outer sep: set the following together
  • outer xsep
  • outer ysep
• minimum size: set the following together
  • minimum height
  • minimum width

Foreach works like this: the following creates three nodes. You can also nest the loops.

\tikz \draw (0,0) node foreach \x in {1,2,3} at (\x,0) {\x};
\tikz \draw (0,0) node foreach \x in {1,2,3} foreach \y in {1,2,3} at (\x,0) {\x};

The style hooks are every node and every circle node, every rectangle node, etc.

The scope will not influence the lexical scope of the node names. Thus we can use another option name prefix and name suffix so that every node names inside the scope will be renamed under the hood.

Options

• text=<color>
• node font=<font command>
• font=<font command>: font command can be \small, etc.
• align: set the alignment. This also enables multiple line text.
  • left
  • flush left (use hyphen to break words)
  • right
  • flush right
  • center
  • flush center
  • justify (use variable spacing)
  • none
• text width
• text height
• text depth: seems useless

It uses anchor. The default is the center of the node. Possible anchors

• north east south west
• base, center

This is good enough, but the author thinks it is not intuitive enough, thus he came up with some suger:

• above, below, left, right
• centered

This fits the scenario that you want a box that is just big enough to hold something. You need to load the fit library.

You create a node, give fit as an option with the value of several nodes.

\node[fit=(a) (b) (c)]

These continue the node options

• pos=<fraction>
  • midway: same as pos=0.5
  • near start 0.25
  • near end 0.75
  • very near start 0.125
  • very near end 0.875
  • at start 0
  • at end 1
• auto=<direction>: direction can be left, right
• swap: swap left and right. The short alias is '
• sloped: the text will be aligned with the line or on the tangent to the curve

This is used to add a node of text next to another node.

• label=[<options>]<angle>:<text>
  • the angle can be the following, if it is not specified, the value of label position is used.
    • a number as degree
    • anchor like north
    • above, below, left, right
  • absolute is a style. It will change the meaning of angle
  • label distance
  • every label: a style placeholder
• pin=[<options>]<angle>:<text>: it is very similar to label, the only difference is that it adds a line between the two nodes
  • pin distance
  • every pin
  • pin position
  • every pin edge
  • pin edge

The quotes syntax is very useful. It is in the library quotes. This must be placed inside the option of a node. The format is

"<text>"<options>

options don't need to be surrounded by curly braces, unless there's a comma in it (because the comma should mean the next option for the node). If the text has comma or colon, it MUST be surrounded by curly braces, like "{hello, world}". This should be limitation of parser.

• quotes mean label
• quotes mean pin
• every label quotes
• every pin quotes
• node quotes mean

The edge option can accept quotes.

• edge quotes=<options>: abbrev for every edge quotes/.style
• edge quotes center: abbrev for setting edge quotes={anchor=center}
• edge quotes mid

A good trick is to specify a graph structure first, and then specify the edges to be colored. The nodes will not be recreated.

When connecting with groups, there're multiple edges. You can specify a single edge by add options to the node.

• target edge style=<options>: abbrev > options
• target edge clear: abbrev clear >
• target edge node=<node spec>
• source edge style=<options>: abbrev < options
• source edge clear: abbrev clear <
• source edge node=<node spec>

The color is logical color. Some predefined color including source and target. These are used by connecting groups. You can use not source and not target on some nodes to remove them from the list, thus they will not be connected. Another color class is all which reference to all nodes. You can also create classes, but I don't currently need this feature.

When joining groups, you can use complete bipartite for the connecting edge option. This is called graph operator, the effect is to connect the each source and each target. Note that the source and target are the color classes of the nodes, used by complete bipartite by default. You can change it.

E.g. create color class

color class=red, color class=green

Set the nodes to color class, and connect them.

{[red] a b c} -- [complete bipartite={red}{green}]
{[green] d e f}

The idea of graph is to make the positioning automatic. Thus we have some algorithm to use.

• grow up, down, left, right
• branch up, down, left, right
• grid placement

We also have some positioning that takes the node size into consideration.

• grow right/left/up/down sep
• branch up/down/left/right sep

We also have circular placement

• clockwise
• counterclockwise

For the levels, we can give them styles at once.

level 1/.style={...}

Rules

• option before root: apply to the whole tree
• option after root: apply to root node only
• option before child: apply to all children from here
• option after child: apply to this child and its children
• option after node: apply to this node only

Some hooks

• every child
• every child node
• level <number>

The following options can be specified multiple times for each portion of the tree.

• level distance
• sibling distance
• grow=direction: direction can be a degree, or down,up,left,right; north,east,etc.

A special option for use after the child is missing. It will leave the space, but don't draw the node. A special styling of edge is to put edge from parent[<options>] right after a node, styling the coming edge.

• every cell={<row>}{<column>}: this is a style hook. The row and column are optional.
  • cells=<options>: abbrev for every cell/.append style=<options>
  • nodes=<options>: abbrev for every node/.append style=<options>
• column <number>: style for the column
  • every odd column
  • every even column
• row <number>: style for the row
  • every odd row
  • every even row
• row <number> column <number>: more specific

• matrix anchor=<anchor>: this anchor will only apply to the matrix
• anchor=<anchor>: apply to both matrix and cells

You can specify axis system manually, but typically just choose from one of the pre-defined systems.

• scientific axes
• school book axes

\datavisualization [
  scientific axes,
  all axis={grid},
  x axis = {attribute=time, label, length=2.5cm, ticks=few},
  y axix = {attribute=colname2, label={$x^2$}},
  visualize as smooth line
] data {
  time, colname2
  1,2
  3,4
}

ticks can be

• few
• some
• many

There are also absolute positioning and several positioning strategies. There are also styling options for ticks and grid.

Use data command.

data [<option>] {<inline data>}

This command, used inside data spec, give data. The whole {<inline data>} is optional. If present, it is used. Otherwise, option specify the file to read, by read from file=<filename> option.

data {
  x,y
  1,1
  2,2
  ...
}

data point[<options>]

specify one single data point, options

• x
• y

data group [<options>] {<name>} = {<data spec>}
data group [<options>] {<name>} += {<data spec>}
data group [<options>] {<name>}

1. define a group of data points
2. extend a group
3. use a group

This is for reuse some data points.

Specified in options.

• visualize as smooth line
• visualize as scatter

You may use multiple visualizers. Then you want to use different colors, provide legends.

Using these without parameter will use line and scatter as default set name.

• visualize as line,
• visualize as scatter
• visualize as smooth line

Use these to specify particular set name.

visualize as line=sin,
visualize as line=cos

This also has a sugar syntax:

visualize as line/.list={sin, cos}

To specify which data belong to which visualizer, you have two ways.

data {
  x,y,set
  0,0,sin
  1,1,cos
}

Or

data [set=sin] {
}
data [set=cos] {
}

The second one is obviously better in most cases.

After defining the visualizer with different name, you can set style to it by just assign options to the name.

sin={<options>}

style={<style options>}

Style options:

• red
• densely dotted
• mark=x

Apart from style option, you also has legend option. Legend is actually automatically added.

legend={below, rows=2},
sin={label in legend={text=$x^2$}},
style sheet=strong colors

style sheet values:

Color

• strong colors
• vary hue
• shades of blue
• shades of red
• gray scale

Line

• vary thickness
• vary dashing

Scatter

• cross marks

A very good idea is to put label or pin directly inside the graph, for that, for each visualizer defined, assign the label in data or pin in data with proper text and style.

sin={label in data={text=$x^2$, when=y is 1, text colored}}

It will place x² at the point of y=1, with the same color as the sin line.

For pin in data, you have also pin length and pin angle options.

Now back to legend placement, it can be (alias in parenthesis):

• east outside (right)
• north east outside
• south east outside
• west outside (left)
• north west outside
• south west outside
• north outside (above)
• south outside (below)

Inside placement is also supported

• south east inside
• east inside
• …

Can also relative to data points

• right of=<data point>: e.g. right of={x=1,y=2}
• above right of=<data point>
• above of
• above left of
• left of
• below left of
• below of
• below right of

The text of legend can be styled as well.

\usetikzlibrary{shapes.multipart}

It adds to the node following options:

mynode/.style={split, rectangle split parts=2}