From 0da0790c8e0a586ac62d03aa1546f6dead322af0 Mon Sep 17 00:00:00 2001 From: Karl Berry Date: Wed, 17 May 2017 21:57:11 +0000 Subject: axodraw2 (17may17) git-svn-id: svn://tug.org/texlive/trunk@44396 c570f23f-e606-0410-a88d-b1316a301751 --- Master/texmf-dist/doc/latex/axodraw2/README | 41 + .../texmf-dist/doc/latex/axodraw2/axodraw2-man.pdf | Bin 0 -> 415732 bytes .../texmf-dist/doc/latex/axodraw2/axodraw2-man.tex | 5160 ++++++++++++++++++++ Master/texmf-dist/doc/latex/axodraw2/example.tex | 19 + Master/texmf-dist/source/latex/axodraw2/axohelp.c | 3699 ++++++++++++++ Master/texmf-dist/tex/latex/axodraw2/axodraw2.sty | 4728 ++++++++++++++++++ Master/tlpkg/bin/tlpkg-ctan-check | 2 +- Master/tlpkg/libexec/ctan2tds | 2 +- Master/tlpkg/tlpsrc/axodraw2.tlpsrc | 0 Master/tlpkg/tlpsrc/collection-mathscience.tlpsrc | 1 + 10 files changed, 13650 insertions(+), 2 deletions(-) create mode 100644 Master/texmf-dist/doc/latex/axodraw2/README create mode 100644 Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.pdf create mode 100644 Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.tex create mode 100644 Master/texmf-dist/doc/latex/axodraw2/example.tex create mode 100644 Master/texmf-dist/source/latex/axodraw2/axohelp.c create mode 100644 Master/texmf-dist/tex/latex/axodraw2/axodraw2.sty create mode 100644 Master/tlpkg/tlpsrc/axodraw2.tlpsrc diff --git a/Master/texmf-dist/doc/latex/axodraw2/README b/Master/texmf-dist/doc/latex/axodraw2/README new file mode 100644 index 00000000000..1a0bc97dd79 --- /dev/null +++ b/Master/texmf-dist/doc/latex/axodraw2/README @@ -0,0 +1,41 @@ +Axodraw2 is a package that defines macros for drawing Feynman graphs +in LaTeX documents. + +It is an important update of the axodraw package, but since it is not +completely backwards compatible, we have given the style file a +changed name. + +Many new features have been added, with new types of line, and much +more flexibility in their properties: For details see the +documentation. + +In addition, it is now possible to use axodraw2 with pdflatex, as well +as with the latex-dvips method. However with pdflatex (and also lualatex +and xelatex), an external program, axohelp, is used to perform the +geometrical calculations needed for the pdf code inserted in the +output file. The processing involves a run of pdflatex, a run of +axohelp, and then another run of pdflatex. + +The files in the distribution are: + + README This file + axodraw2.sty The main style file + axohelp.c Source code of axohelp + axohelp.exe MS-Windows executable for axohelp + axodraw2-man.pdf Documentation + axodraw2-man.tex Source for documentation + example.tex Example latex file for use of axodraw2 + + +Authors, copyright, license +--------------------------- + +(C) 1994-2016 John Collins (jcc8 at psu dot edu) and Jos Vermaseren +(t68 at nikhef dot nl) + +Axodraw2 is free software: you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation, either version 3 of the License, or (at your +option) any later version. See the files axodraw2.sty or axohelp.c +for more details. + diff --git a/Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.pdf b/Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.pdf new file mode 100644 index 00000000000..4294ea3b14d Binary files /dev/null and b/Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.pdf differ diff --git a/Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.tex b/Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.tex new file mode 100644 index 00000000000..03569ef2a77 --- /dev/null +++ b/Master/texmf-dist/doc/latex/axodraw2/axodraw2-man.tex @@ -0,0 +1,5160 @@ +\documentclass[12pt]{article} +\usepackage{a4wide} +% Use fix-cm or lmodern to get scaleable cm fonts +\usepackage{longtable,fix-cm,url,units,hyperref} + +\usepackage{axodraw2} + +\def\num{$\langle$number$\rangle$} +\def\colorname{$\langle$colorname$\rangle$} + +% How to typeset filenames and program names: Use \file and \program +% to allow stylistic changes. +% Basic definition of \file would bes \def\file#1{\texttt{#1}}, but +% that would not allow line breaks in long names. So define it by +% \DeclareUrlCommand from url package. (We can't use \url itself, +% because that provokes hyperref into making a hyperlink.) +\DeclareUrlCommand\file{\urlstyle{tt}} + +% Similarly specify how to typeset names of programs +\def\program#1{\texttt{#1}} + +% Backslash of the kind used in verbatim +\newcommand\BS{\symbol{`\\}} + +% Set the name of a TeX macro (and possibly its signature). +% In the argument, the initial backslash. Allow \{ and \} in the +% argument. E.g. \name{SetSpace\{\#\}}} +\newcommand\name[1]{% + \bgroup + \def\{{\symbol{`\{}}% + \def\}{\symbol{`\}}}% + \texttt{\BS#1}% + \egroup +} + + +\begin{document} + +%% ?? To get settings useful to test compatibility of axodraw2 with +%% color.sty, uncomment the following line: +%\SetColor{Blue} \color{green} \pagecolor[cmyk]{0,0.02,0.05,0} +%% Note green is useful, because it is defined in rgb color model +%% and the apparently equivalent Green, cmyk 1 0 1 0, looks quite +%% different on screen. So we can test the colors are entering graphics +%% correctly. + +%% ?? To test whether offsets work correctly, uncomment the following +%% line: +%\SetOffset(10,20) \SetScaledOffset(10,-20) + + +\setcounter{page}{0} +\thispagestyle{empty} +\hfill \begin{minipage}{3.0cm} +Nikhef 2015-025 +\end{minipage} +\vspace{20mm} + +\begin{center} +{\LARGE\bf\sc Axodraw Version 2} +\end{center} +\vspace{5mm} +\begin{center} +{\large John C. Collins$^{\, a}$ and J.A.M. Vermaseren$^{\, b}$} +\vspace{1cm}\\ +{\it $^a$ Department of Physics, Pennsylvania State University, \\ +\vspace{0.1cm} +University Park, Pennsylvania 16802, USA} \\ +\texttt{jcc8 at psu dot edu} \\ +\vspace{0.5cm} +{\it $^b$Nikhef Theory Group \\ +\vspace{0.1cm} +Science Park 105, 1098 XG Amsterdam, The Netherlands} \\ +\texttt{t68 at nikhef dot nl} \\ +\vspace{1.0cm} +(3 June 2016) +\end{center} +\vspace{5mm} + +\begin{abstract} +We present version two of the \LaTeX{} graphical style file Axodraw. +It has a number of new drawing primitives and many extra options, and +it can now work with \program{pdflatex} to directly produce +output in PDF file format (but with the aid of an auxiliary program). +\end{abstract} + +\newpage + +\tableofcontents + +\newpage + + +%>>#[ Introduction : +%========================= +\section{Introduction} +\label{sec:intro} + +This is the documentation for axodraw2, a \LaTeX{} package for drawing +Feynman graphs (and other simple graphics). This version is a +substantial update of the original axodraw package \cite{axodraw1}, +which was released +in 1994, and which has become rather popular in the preparation of articles in +elementary-particle physics. One of its advantages is that its +drawing primitives are included in the .tex document, in a +human-writable form. (This also allows convenient production of +axodraw figures by other software, e.g., Jaxodraw +\cite{jaxodraw1,jaxodraw2}.) +This is in distinction to methods that +use a separate program to create graphics files that are read in +during the processing of the \LaTeX{} file. The objects needed in +Feynman graphs are often difficult to draw at high quality with +conventional computer graphics software. + +The original axodraw package has hardly been modified since its +introduction. The new version addresses several later needs. A +detailed list of the changes is given in Sec.\ \ref{sec:changes}. + +One change arises from the fact that \TeX{} (and hence \LaTeX{}) +themselves do not possess sufficiently useful methods of drawing +complicated graphics, so that the drawing of the graphics is actually +done inserting suitable code in the final output file (postscript or +pdf). The original axodraw worked only with the +\program{latex}-\program{dvips} processing chain to put the diagrams in +the final postscript file.\footnote{A pdf file can be produced from + the postscript file by a program like \program{ps2pdf}.} Now we also +have in common use the \program{pdflatex} (and \program{lualatex} and +\program{xelatex}) programs that directly produce pdf. The new version +of axodraw works with \program{pdflatex}, \program{lualatex}, and +\program{xelatex}, as well as with the \program{latex}-\program{dvips} +method. + +Furthermore, more kinds of graphical object and greater flexibility in +their properties have been found useful for Feynman graphs. The new +version provides a new kind of line, B\'ezier, and is able to make the +various kinds of line doubled. There is now a very flexible +configuration of arrows. Many of the changes correspond to +capabilities of JaxoDraw \cite{jaxodraw1,jaxodraw2}, which is a +graphical program for drawing Feynman graphs, and which is able to +write and to import diagrams in the axodraw format. + +Finally, substantial improvements have been made in the handling of +colors, with much better compatibility with modern packages used to +set colors in the normal \LaTeX{} part of a document. + +Since some of the changes (especially in the internal coding) +introduce potential incompatibilities with the original version of +axodraw, the new version of the style file is given a new name +\file{axodraw2.sty}. Then the many legacy documents (e.g., on +\url{http://arxiv.org}) that use the old axodraw will continue to use +the old version, and will therefore continue to be compilable without +any need for any possible changes in the source document, and with unchanged +output. Even so, as regards the coding of diagrams, there are very +few backwardly incompatible changes in axodraw2. + +The software is available under the GNU General Public License +\cite{GPL} version 3. + + + +%========================= +\section{Changes} +\label{sec:changes} + +\subsection{Changes relative to original, axodraw version 1} +\label{sec:changes.wrt.1} + +Relative to the original version of axodraw, the current version, +axodraw2, has the following main changes: +\begin{itemize} + +\item A bug that the line bounding an oval did not have a uniform + width has been corrected. + +\item A bug has been corrected that axodraw did not work with the + revtex4 document class when \verb+\maketitle+ and two-column mode + were used. + +\item Axodraw2 works both when pdf output is produced directly using + the programs \program{pdflatex}, \program{lualatex}, and + \program{xelatex}, as well as when a postscript file is produced by + the latex--dvips method. The old version only worked when + postscript output was produced. However, an auxiliary program is + needed when using \program{pdflatex}, \program{lualatex}, or + \program{xelatex}. See Sec.\ \ref{sec:doc.compile} for how this is + done. + +\item In the original axodraw, a diagram is coded inside a + \verb+picture+ environment of \LaTeX. Now, a specialized + \verb+axopicture+ environment is provided and preferred; it provides + better behavior, especially when diagrams are to be scaled. + +\item In association with this, there are some changes in how scaling + of diagrams is done. + +\item An inconsistency in length units between postscript and \TeX{} + has been corrected. All lengths are now specified in terms of + $\unit[1]{pt} = \unit[1/72.27]{in} = \unit[0.3515]{mm}$. Previously + the unit length for graphics was the one defined by postscript to be + $\unit[1]{bp} = \unit[1/72]{in} = \unit[0.3528]{mm}$. + +\item Substantial improvements have been made in the treatment of + color. When named colors are used, axodraw2's use of color is + generally compatible with that of the modern, \LaTeX-standard + \file{color.sty} package. It also provides all the macros that were + defined in v.\ 1 of axodraw, including those of the \file{colordvi.sty} + package used by v.\ 1. + +\item The various types of line can now be produced as double lines, + e.g., + \begin{axopicture}(35,5)(0,-2) + \SetWidth{1} + \Line[double,sep=2.5](0,2)(35,2) + \end{axopicture}. + This is commonly used, for example, for notating Wilson lines. + +\item Lines can be made from B\'ezier curves. + Currently this is only for simple lines, not photon, gluon, or + zigzag lines. + +\item Gluon, photon, and zigzag lines can be dashed. + +\item Macros are provided for drawing gluon circles, without the + endpoint effects given by the corresponding gluon arc macros. + +\item The positions and sizes of arrows can be adjusted. See Sec.\ + \ref{sec:arrows} for all the possibilities. One example is + \begin{axopicture}(30,6)(0,-2) + \SetWidth{1} + \Line[arrow,arrowpos=0.8](0,2)(30,2) + \end{axopicture} + +\item Macros for drawing polygons and filled polygons are provided. + +\item Macros for drawing rotated boxes are provided. + +\item A macro \verb+\ECirc+ is provided for drawing a circle with a + transparent interior. + +\item A macro \verb+\EBoxc+ is provided for drawing a box with a + specified center. + +\item A macro \verb+\AxoGrid+ is provided for drawing a grid. One + use is to provide a useful tool in designing pictures. + +\item Since there are now many more possibilities to specify the + properties of a line, optional arguments to the main line drawing + commands can be used to specify them in a keyword style. + +\item A new macro named \verb+\Arc+ is introduced. With the aid of + optional arguments, this unifies the behavior of various arc-drawing + commands in the original axodraw. + +\item For consistency with the \verb+\Gluon+ macro, the + \verb+\GlueArc+ macro has been renamed to \verb+\GluonArc+, with the old + macro retained as a synonym. + +\item The behavior of arcs is changed to what we think is more natural + behavior when the specified opening is outside the natural range. + +\item What we call macros for drawing objects with postscript text are + now implemented within \LaTeX{} instead of relying on instructions + inserted in the postscript code. Thus all the normal \LaTeX{} + commands, including mathematics, can now be used in all text + objects, with proper scaling. The placement and scaling of text + objects are more consistent. + +\item Some new named colors are provided: + \LightYellow{LightYellow}, \LightRed{LightRed}, + \LightBlue{LightBlue}, \LightGray{LightGray}, + \VeryLightBlue{VeryLightBlue}. + (LightYellow, LightRed, LightBlue, LightGray, VeryLightBlue.) + +\item The macros originally specified as \verb+\B2Text+, + \verb+\G2Text+, and \verb+\C2Text+ are now named \verb+\BTwoText+, + \verb+\GTwoText+, and \verb+\CTwoText+. The intent of the + original code was to define macros with names \verb+\B2Text+, etc. + However in normal \TeX, macro names of more than one character + must only contain letters, unlike typical programming languages + that also allow digits. So the rules for \TeX{} macro names mean + that in defining, for example \verb+\def\B2Text(#1,#2)#3#4{...}+, + the original version of axodraw actually defined a macro named + named \verb+\B+, obligatorially followed by \verb+2Text+. This + caused a conflict if the user wished to define a macro \verb+\B+. + If it is desired to retain the old behavior, then the following + should be placed in the preamble of the .tex file, then the + axodraw2 package should be invoked in the source document with the + \texttt{v1compatible} option: + \begin{verbatim} + \usepackage[v1compatible]{axodraw2} + \end{verbatim} + +\end{itemize} + +\subsection{Changes relative to axodraw4j distributed with JaxoDraw} +\label{sec:changes.wrt.4j} + +The JaxoDraw program \cite{jaxodraw2} is distributed with a +version of axodraw called axodraw4j. As of July 2014, this was +effectively a predecessor of axodraw2, but without the possibility of +working with \program{pdflatex}. (The suffix ``4j'' is intended to mean ``for +JaxoDraw''.) + +The changes in axodraw2 relative to the version of axodraw4j dated +2008/11/19 are the following subset of those listed in Sec.\ +\ref{sec:changes.wrt.1}: +\begin{itemize} +\item Correction of the oval-drawing bug. +\item The ability to work with \program{pdflatex}, \program{lualatex}, + and \program{xelatex}. +\item The improvements in the handling of color. +\item The double and arrow options for B\'ezier lines. +\item The dash option for gluons and photons. +\item Color option for all lines. +\item Correction of inconsistency of length unit between \TeX{} and + postscript. +\item Better drawing of double gluons and photons. +\item The gluon circle, polygon, rotated box, \verb+\ECirc+, + \verb+\EBoxc+, and the \verb+\AxoGrid+ macros +\item A series of ``LongArrow'' macros for drawing lines with the + arrow at the end. The same effect could only be achieved in + axodraw4j with arrowpos=1 option to the basic line-drawing + commands. +\item A series of macros like \verb+\DashDoubleLine+ to provide access + to the dashed and double properties in the style of the macros + provided in v.\ 1 of axodraw. This is in addition to the optional + arguments that allow the same effect in axodraw4j and in axodraw2. +\item The \texttt{v1compatible} and other options are provided for the + package. +\item Better treatment of the scaling of objects. +\item The treatment of ``postscript text objects'' within \LaTeX{} + itself. +\end{itemize} + + +%--------------- +\subsection{Backward compatibility, etc} + +The official user interface of axodraw2 is backward-compatible with +versions 1 and 4j, with the exception of the issue mentioned above +about the commands that have the signatures \verb+\B2Text+, +\verb+\G2Text+, and \verb+\C2Text+. There are some minor changes in +the objects that are drawn, mostly concerning the exact dimensions of +default arrows and the scaling of the sizes of text objects. The +scoping of color changes is significantly different, but improved. + +The old axodraw only used the tools available in \LaTeX{} in the early +1990s. The new version needs a more modern installation. It has been +extensively tested with TeXLive 2011 and 2016. + +We have tested backwards compatibility by compiling the version 1 +manual with axodraw2; only a trivially modified preamble was needed. +It also worked to compile Collins's QCD book\cite{qcdbook}, +which has a large number +of JaxoDraw figures (processed automatically to pieces of axodraw code +imported into the document); only changes in the preamble were needed. + +Axodraw2 uses the following \LaTeX{} packages: \program{keyval}, +\program{ifthen}, \program{graphicx}, \program{color}, \program{ifxetex}. +It defines its own set of 73 named colors --- Sec.\ \ref{sec:colors} +--- which are the same as the 68 defined as dvips-defined names in the +color package, plus 5 more. + +In addition axodraw2 provides an \verb+axopicture+ environment +inside of which axodraw2's graphics are coded and drawn. In the old +axodraw, \LaTeX's \verb+picture+ environment was used instead. We +recommend the use of \verb+axopicture+ environment in axodraw2, and +that is the only method we document. However, old diagrams coded with +\verb+picture+ environment continue to work. + + +%========================= +\section{Installation} +\label{sec:installation} + +%--------------- +\subsection{Installation from standard \TeX{} distribution} + +At the moment that this document was written, axodraw2 was not part of any +standard \TeX{} distribution. + +It is on CTAN at \url{http://ctan.org/tex-archive/graphics/axodraw2}, +so that it should eventually be part of the standard distributions +(TeXLive and MiKTeX). After that, axodraw2 will either be installed +by default or can be installed by using the package manager of the +\TeX{} distribution. When available, this will be the easiest method +of installation. + + + +%--------------- +\subsection{Manual installation} + +%For a manual installation, the minimum that needs to be done is to put +For a manual installation, what needs to be done is to put +the file \file{axodraw2.sty} in a place where it will be found by +the \program{latex} program. If you wish to use axodraw2 with +\program{pdflatex}, you will also need to compile the \program{axohelp} +program and put it in an appropriate directory. Documentation can +also be installed if you want. + +%-- +\subsubsection{Style file texttt{axodraw2.sty}} + +If you merely want to try out axodraw2, just put the file +\file{axodraw2.sty} in the same directory as the \file{.tex} +file(s) you are working on. + +Otherwise, put it in an appropriate directory for a \LaTeX{} style +file, and, if necessary, run the texhash program to ensure that the +file is in the \TeX{} system's database of files. For example, +suppose that you have a TeXLive system installed for all users on a +Unix-like system (e.g., Linux or OS-X), and that TeXLive is installed, +as is usual, under the directory \file{/usr/local/texlive}. Then an +appropriate place for axodraw2 is in a directory +\file{/usr/local/texlive/texmf-local/tex/latex/axodraw2}. You will +need to run the \program{texhash} program in this last case. For such +a system-wide installation, you will probably have to do these +operations as an administrative user (e.g., root), possibly +supplemented by running the relevant commands with the \program{sudo} +program. + +%-- +\subsubsection{Helper program \program{axohelp}} +\label{sec:axohelp} + +If you wish to use axodraw2 with \program{pdflatex}, \program{lualatex}, +or \program{xelatex}., then you need to install the \program{axohelp} +program. + +On a Unix-like system (e.g., linux or OS-X), you first need to compile +the program by a C compiler. An appropriate shell command to do this +is +\begin{verbatim} + cc -o axohelp -O3 axohelp.c -lm +\end{verbatim} +(Note that this is a C compiler, \emph{not} a C++ compiler.) Most linux +systems have the program \program{cc} already installed. This also applies to +OS-X at versions below 10.7. But on OS-X version 10.7 and higher, you +will need to install a compiler, which can be done by installing XCode +and the associated command-line utilities. If you have the GNU +compilers installed, you might need to use the command \program{gcc} +instead of \program{cc}. + +For Microsoft Windows, if you do not have a C compiler available, you +can use the Windows binary \file{axohelp.exe} we have provided. It +should work with Windows 7 or higher. + +In any case once you have the executable (named \program{axohelp} on +unix-like systems, or \program{axohelp.exe} on a Microsoft system), put +it in a directory where it will be found when you run programs from +the command line. + + +%-- +\subsubsection{Testing} + +To test whether the installation works, you need a simple test file. +An example is given in Sec.\ \ref{sec:example}, and is provided +with the axodraw2 distribution as \file{example.tex}. + +At a command line with the current directory set to the directory +containing the file \file{example.tex}, run the following commands: +\begin{verbatim} + latex example + dvips example -o +\end{verbatim} +If all goes well, you will obtain a file \file{example.ps}. When +you view it, it should contain the diagram shown in Sec.\ +\ref{sec:example}. You can make a pdf file instead by the commands +\begin{verbatim} + latex example + dvipdf example +\end{verbatim} +A more extensive test can be made by compiling the manual. + +To make a pdf file directly, with \program{pdflatex}, you use the commands +\begin{verbatim} + pdflatex example + axohelp example + pdflatex example +\end{verbatim} +The \program{axohelp} run takes as input a file \file{example.ax1} +produced by the first run of \program{pdflatex} and makes an output +file \file{example.ax2}. The second run of \program{pdflatex} reads +the \file{example.ax2} file and uses the result to place the axodraw +objects in the \file{example.pdf} file. + + +%-- +\subsubsection{Documentation} + +Put the documentation in a place where you can find it. If you +installed the \file{axodraw2.sty} file in +\file{/usr/local/texlive/texmf-local/tex/latex/axodraw2}, the +standard place for the documentation would be +\file{usr/local/texlive/texmf-local/doc/latex/axodraw2}. + + +%========================= +\section{Use} +\label{sec:use} + +In this section we show how to use axodraw2, illustrated with an +example. + +\subsection{Basic example} +\label{sec:example} + +The principles of using axodraw2 are illustrated by the following +complete \LaTeX{} document: +\begin{verbatim} + \documentclass{article} + \usepackage{axodraw2} + \begin{document} + Example of Feynman graph using axodraw2 macros: + \begin{center} + \begin{axopicture}(200,110) + \SetColor{Red} + \Arc[arrow](100,50)(40,0,180) + \Text(100,100){$\alpha P_1 + \beta P_2 + k_\perp$} + \SetColor{Black} + \Arc[arrow](100,50)(40,180,360) + \Gluon(0,50)(60,50){5}{4} + \Vertex(60,50){2} + \Gluon(140,50)(200,50){5}{4} + \Vertex(140,50){2} + \end{axopicture} + \end{center} + \end{document} +\end{verbatim} +After compilation according to the instructions in Sec.\ +\ref{sec:doc.compile}, viewing the resulting file should show the +following Feynman graph: +\begin{center} + \begin{axopicture}(200,110) + \SetColor{Red} + \Arc[arrow](100,50)(40,0,180) + \Text(100,100){$\alpha P_1 + \beta P_2 + k_\perp$} + \SetColor{Black} + \Arc[arrow](100,50)(40,180,360) + \Gluon(0,50)(60,50){5}{4} + \Vertex(60,50){2} + \Gluon(140,50)(200,50){5}{4} + \Vertex(140,50){2} + \end{axopicture} +\end{center} +See Sec.\ \ref{sec:examples} for more examples + +\emph{Important note about visibility of graphics objects:} If you +view this document on a computer monitor, Feynman graphs drawn with +narrow lines may not fully match what was intended. This is because +of the way graphics viewers interact with the limited resolution of +computer monitors. To see the example graphs properly, you may need to +use a large enough magnification, or to use an actual print out. + +\emph{Note about sending a document to others}: If for example, you +submit an article to arXiv.org, it is likely that their automated +system for processing the file will not run axohelp. So together with +the tex file, you one should also submit the .ax2 file. + + +%----------------------- +\subsection{Document preparation} +\label{sec:doc.prep} + +The general rules for preparation of a document are: +\begin{itemize} + +\item Insert the following + \begin{verbatim} + \usepackage{axodraw2} + \end{verbatim} + in the preamble of the \file{.tex} file. + There are some options and commands that can be used to change axodraw2's + behavior from its default. See Secs.\ \ref{sec:invoke} and + \ref{sec:settings} for details. + +\item Where you want to insert axodraw2 objects, put them inside an + axopicture environment, specified in Sec.\ \ref{sec:env}, + \begin{verbatim} + \begin{axopicture}(x,y) + ... + \end{axopicture} + \end{verbatim} + Here \texttt{x} and \texttt{y} denote the desired size of the box + that is to be inserted in the document and that contains the graph. + An optional offset can be specified (as with \LaTeX's + \texttt{picture} environment). By default the units are + $\unit[1]{pt} = \unit[1/72.27]{in} = \unit[0.3515]{mm}$. + +\end{itemize} +Full details of all these components are in Sec.\ +\ref{sec:reference}. + +The design of graphs can be done manually, and this can be greatly +facilitated with the new \verb:\AxoGrid: command. A convenient way of +constructing diagrams is to use the graphical program +JaxoDraw~\cite{jaxodraw1,jaxodraw2}, which is what most people +do. This program can export axodraw code. It also uses axodraw as one +way of making postscript and pdf files. The original version of +axodraw was used by JaxoDraw until version 1.3. In version 2 of +JaxoDraw, a specially adapted version of \file{axodraw.sty} is used, +named \file{axodraw4j.sty}. The output from version 2 of +JaxoDraw is compatible with axodraw2. + + +%----------------------- +\subsection{Document compilation} +\label{sec:doc.compile} + +\subsubsection{To make a postscript file} +\label{sec:doc.compile.ps} + +When a postscript file is needed, you just make the postscript file as +usual. E.g., when the source file is \file{example.tex}, you run +the following commands: +\begin{verbatim} + latex example + dvips example -o +\end{verbatim} +which results in a postscript file \file{example.ps}. Of course, if +there are cross references to be resolved, you may need multiple runs +of \program{latex}, as usual. When needed, use of \program{bibtex}, +\program{makeindex}, and other similar programs is also as usual. +Instead of \program{latex}, one may also use the \program{dvilualatex} +program, which behaves like \program{latex} except for providing some +extra capabilities that are sometimes useful. + +Internally, axodraw uses \TeX's \verb+\special+ mechanism to put +specifications of postscript code into the \file{.dvi} file, and +\program{dvips} puts this code in the postscript file. This postscript +code performs the geometrical calculations needed to specific +axodraw's objects, and then draws them when the file is displayed or +printed. + +\emph{Important note about configuration of \program{dvips}:} You may +possibly find that when you run \program{dvips} that it spends a lot of +time running \program{mktexpk} to make bitmapped fonts, or that the +postscript +file contains bitmapped type-3 fonts. This is \emph{not} the default +situation in typical current installations. But if you do find this +situation, which is highly undesirable in most circumstances, you +should arrange for \program{dvips} to use type 1 fonts. This can be +done either by appropriately configuring your \TeX{} installation, for +which you will have to locate instructions, or by giving +\program{dvips} its \texttt{-V0} option: +\begin{verbatim} + dvips -V0 example -o +\end{verbatim} +Once you do this, you should see, from \program{dvips}'s output, +symptoms of its use of type 1 fonts. \emph{Let us re-emphasize that + you do not have to be concerned with this issue, under + normal circumstances. But since things were different within our + memory, we give some suggestions as to what to do in what are + currently abnormal circumstances.} + +\subsubsection{To make a pdf file via \program{latex}} + +There are multiple methods of making pdf files for a latex document; +we will not give all the advantages and disadvantages here. + +One way is to convert the postscript file, e.g., by +\begin{verbatim} + ps2pdf example.ps +\end{verbatim} +You can also produce a pdf file from the dvi file produced by +\program{latex} by the \program{dvipdf} command, e.g,. +\begin{verbatim} + dvipdf example +\end{verbatim} +\emph{Important note:} The program here is \program{dvipdf} and +\emph{not} the similarly named \program{dvipdfm} or \program{dvipdfmx}, +which are incompatible with axodraw. The reason why \program{dvipdf} +works is that it internally makes a postscript file and then converts +it to pdf. + + +\subsubsection{To make a pdf file by \program{pdflatex}, + \program{lualatex}, or \program{xelatex}} + +A common and standard way to make a pdf file is the \program{pdflatex} +program, which makes pdf directly. It has certain advantages, among +which are the possibility of importing a wide variety of graphics file +formats. (In contrast, the \program{latex} program only handles +encapsulated postscript.) + +However, to use axodraw2 with \program{pdflatex}, you need an +auxiliary program, \program{axohelp}, as in +\begin{verbatim} + pdflatex example + axohelp example + pdflatex example +\end{verbatim} +What happens is that during a run of \program{pdflatex}, axodraw2 +%writes a file \file{example.ax1} with specifications of its +writes a file \file{example.ax1} containing specifications of its +graphical objects. Then running \program{axohelp} reads the +%\file{example.ax1} file, computes the necessary pdf code to draw the +\file{example.ax1} file, computes the necessary pdf code to draw the +objects, and writes the results to \file{example.ax2}. The next run +of \program{pdflatex} reads \file{example.ax2} and uses it to put the +appropriate code in the output pdf file. + +The reason for the extra program is that axodraw needs many +geometrical calculations to place and draw its graphical objects. +\LaTeX{} itself does not provide anything convenient and efficient for +these calculations, while the PDF language does not offer sufficient +computational facilities, unlike the postscript language. + +If you modify a document, and recompile with \program{pdflatex}, you +will only need to rerun \program{axohelp} if the modifications +involve axodraw objects. Axodraw2 will output an appropriate message +when a rerun of \program{axohelp} is needed. + +If you wish to use \program{lualatex} or \program{xelatex}, instead of +\program{pdflatex}, then you can simply run the program +\program{lualatex} or \program{xelatex} instead of +\program{pdflatex}. These are equally compatible with axodraw2. + + + + +%----------------------- +\subsection{Automation of document compilation} +\label{sec:doc.auto.compile} + +It can be useful to automate the multiple steps for compiling a +\LaTeX{} document. One of us has provided a program \program{latexmk} +to do this --- see \url{http://www.ctan.org/pkg/latexmk/}. Here we +show how to configure +\program{latexmk} to run \program{axohelp} as needed when a document is +compiled via the \program{pdflatex} route. + +All you need to do is to put the following lines in one of +\program{latexmk}'s initialization files (as specified in its +documentation): +\begin{verbatim} + add_cus_dep( "ax1", "ax2", 0, "axohelp" ); + sub axohelp { return system "axohelp \"$_[0]\""; } + $clean_ext .= " %R.ax1 %R.ax2"; +\end{verbatim} +The first two lines specify that \program{latexmk} is to make +\file{.ax2} files from \file{.ax1} files by the \program{axohelp} +program, whenever necessary. (After that \program{latexmk} +automatically also does any further runs of \program{pdflatex} that are +necessary.) The last line is optional; it adds \file{.ax1} and +\file{.ax2} files to the list of files that will be deleted when +\program{latexmk} is requested to do a clean up of generated, +recreatable files. + +\program{Latexmk} is installed by default by the currently common +distributions of \TeX{} software, i.e., TeXLive and MiKTeX. It has as +an additional requirement a properly installed Perl system. For the +TeXLive distribution, this requirement is always met. + +With the above configuration, you need no change in how you invoke +\program{latexmk} to compile a document, when it uses axodraw2. For +producing postscript, you can simply use +\begin{verbatim} + latexmk -ps example +\end{verbatim} +and for producing pdf via \program{pdflatex} you can use +\begin{verbatim} + latexmk -pdf example +\end{verbatim} +Then \program{latexmk} takes care of whatever runs are needed of all +the relevant programs, now including \program{axohelp}, as well +whatever, possibly multiple, runs are needed for the usual programs +(\program{latex}, \program{pdflatex}, \program{bibtex}, etc). + + + +%>>#] Introduction : +%>>#[ The Commands : + +\section{Reference} +\label{sec:reference} + +\subsection{Package invocation} +\label{sec:invoke} + +To use the axodraw2 package in a \LaTeX{} document, you simply put +\begin{verbatim} + \usepackage{axodraw2} +\end{verbatim} +in the preamble of the document, as normal. + +The \verb+\usepackage+ command takes optional arguments +(comma-separated list of keywords) in square brackets, e.g., +\begin{verbatim} + \usepackage[v1compatible]{axodraw2} +\end{verbatim} +The options supported by axodraw2 are +\begin{itemize} +\item \texttt{v1compatible}: This makes axodraw2's operation more + compatible with v.\ 1. It allows the use of \verb+\B2Text+, + \verb+\G2Text+, and \verb+\C2Text+ as synonyms for the macros named + \verb+\BTwoText+, \verb+\GTwoText+, and \verb+\CTwoText+. + (You may wish also to use the \texttt{canvasScaleisUnitLength} + option, so that the scaling of the units in the \texttt{axopicture} + environment is the same as it was for the \texttt{picture} + environment used in v.\ 1.) +\item \texttt{canvasScaleIs1pt}: Unit for canvas dimensions + in an \texttt{axopicture} environment is fixed at $\unit[1]{pt}$, +\item \texttt{canvasScaleIsObjectScale}: Unit for canvas dimensions + in an \texttt{axopicture} environment are the same as those set for + axodraw objects (by the \verb+\SetScale+ macro). This is the + default setting, so the option need not be given. +\item \texttt{canvasScaleIsUnitLength}: Unit for canvas dimensions + in an \texttt{axopicture} environment is the current value of + \verb+\unitlength+, exactly as for \LaTeX{}'s \texttt{picture} + environment. (Thus, this corresponds to the behavior of the + original axodraw v.\ 1, which simply used the \texttt{picture} + environment.) +\item \texttt{PStextScalesIndependently}: Axodraw's text objects are + scaled by the factor set by the \verb+\SetTextScale+ command. +\item \texttt{PStextScalesLikeGraphics}: Axodraw's text objects are + scaled by the factor set by same factor for its graphics objects, + i.e., the scale set by the \verb+\SetScale+ command. +\end{itemize} +(N.B. Default scaling factors are initialized to unity.) + +\emph{Note:} If you use \program{axodraw}'s commands for placing text +and you use the standard \TeX{} Computer Modern fonts for the +document, then when you compile your document you may get a lot of +warning messages. These are about fonts not being available in +certain sizes. To fix this problem invoke the package +\program{fix-cm} in your document's preamble: +\begin{verbatim} + \usepackage{fix-cm} +\end{verbatim} +It is also possible to use the package \program{lmodern} for the same +purpose. + + +\subsection{Environment(s)} +\label{sec:env} + +The graphical and other objects made by axodraw2 are placed in an +\texttt{axopicture} environment, which is invoked either as +\begin{verbatim} + \begin{axopicture}(x,y) + ... + \end{axopicture} +\end{verbatim} +or +\begin{verbatim} + \begin{axopicture}(x,y)(xoffset,yoffset) + ... + \end{axopicture} +\end{verbatim} +Here, the \dots{} denote sequences of axodraw2 commands, as documented +in later sections, for drawing lines, etc. The \texttt{axopicture} +environment is just like standard \LaTeX's \texttt{picture} +environment,\footnote{In fact, the \texttt{axopicture} is changed from + the \texttt{picture} environment only by making some + axodraw-specific settings. So the \texttt{picture} environment that + was used in v.\ 1 may also be used with axodraw2; it merely has a + lack of automation on the setting of the canvas scale relative to + the object scale, and, in the future, other possible + initializations.}, except for doing some axodraw-specific +initialization. It inserts a region of size \texttt{x} by \texttt{y} +(with default units of $\unit[1]{pt} = \unit[1/72.27]{in} = +\unit[0.3515]{mm}$). Here \texttt{x} and \texttt{y} are set to the +numerical values you need. + +The positioning of axodraw objects is specified by giving $x$ and $y$ +coordinates, e.g., for the ends of lines. The origin of these +coordinates is, by default, at the lower left corner of the box that +\texttt{axopicture} inserts in your document. But sometimes, +particularly after editing a graph, you will find this is not +suitable. To avoid changing a lot of coordinate values to get correct +placement, you can specify an offset by the optional arguments +\texttt{(xoffset,yoffset)} to the \texttt{axopicture} environment, +exactly as for \LaTeX's \texttt{picture} environment. The offset +\texttt{(xoffset,yoffset)} denotes the position of the bottom left +corner of the box inserted in your document relative to the coordinate +system used for specifying object positions. Thus +\begin{verbatim} + \begin{axopicture}(20,20) + \Line(0,0)(20,20) + \end{axopicture} +\end{verbatim} +and +\begin{verbatim} + \begin{axopicture}(20,20)(-10,20) + \Line(-10,20)(10,40) + \end{axopicture} +\end{verbatim} +are exactly equivalent. + +Within an \texttt{axopicture} environment, all the commands that can +be used inside an ordinary \texttt{picture} environment can also be +used. + +We can think of the \texttt{axopicture} environment as defining a +drawing canvas for axodraw's graphical and text objects. +There are possibilities for manipulating (separately) the units used +to specify the canvas and the objects. These can be useful for +scaling a diagram or parts of it from an originally chosen design. +See Secs.\ \ref{sec:units} and \ref{sec:settings} for details. + + +\subsection{Graphics drawing commands} +\label{sec:commands} + +In this section we present commands for drawing graphical objects, +split up by category. Later, we will give: details of options to the +line-drawing commands, explanations of some details about specifying +gluons and about specifying arrow parameters, and then commands for +textual objects and for adjusting settings (e.g., separation in a +double line). Mostly, we present the commands by means of examples. +Note that many of the arguments of the commands, notably arguments for +$(x,y)$ coordinate values are delimited by parentheses and commas +instead of the brace delimiters typically used in \LaTeX. + +It should also be noted that some commands provide different ways of +performing the same task. For instance +\begin{verbatim} + \BCirc(50,50){30} +\end{verbatim} +can also be represented by +\begin{verbatim} + \CCirc(50,50){30}{Black}{White} +\end{verbatim} +when the current color is black. The presence of the BCirc command has been +maintained both for backward compatibility, and because it represents +a convenient short hand for a common situation. This also holds for similar +commands involving boxes and triangles. For the new Polygon, FilledPolygon, +RotatedBox and FilledRotatedBox commands we have selected a more minimal +scheme. + +Similar remarks apply to the new feature of options for line drawing +commands. Originally in v.\ 1, a line with an arrow would be coded as +\begin{verbatim} + \ArrowLine(30,65)(60,25) +\end{verbatim} +It is now also possible to code using the general \verb+\Line+ macro, +but with a keyword optional argument: +\begin{verbatim} + \Line[arrow](30,65)(60,25) +\end{verbatim} +One advantage of the option method is a variety of other properties of +an individual line may also be coded, as in +\begin{verbatim} + \Line[arrow,arrowpos=1](30,65)(60,25) +\end{verbatim} +without the need to use separate global setting for the property, by +the commands listed in Sec.\ \ref{sec:settings}, or by having a +corresponding compulsory argument to the command. +Which way to do things is a matter of user taste in particular +situations. + +%--#[ AxoGrid : + +\subsubsection{Grid drawing} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,140)(-10,0)} +\AxoGrid(0,0)(10,10)(9,14){LightGray}{0.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{axogrid} +\verb:\AxoGrid(0,0)(10,10)(9,14){LightGray}{0.5}: \hfill \\ +This command is used in our examples to allow the reader to compare the +coordinates in the commands with those of the actual picture. The arguments +are first the position of the left bottom corner, then two values that tell +the size of the divisions in the $x$ and $y$ direction. Next there are two +values that specify how many divisions there should be in the $x$ and $y$ +direction. Then the color of the lines is given and finally the width of +the lines. Note that if there are $(n_x,n_y)$ divisions there will be +$n_x+1$ vertical lines and $n_y+1$ horizontal lines. The temporary use of +this command can also be convenient when designing pictures manually. +\end{minipage}\vspace{4mm} + +%--#] AxoGrid : +%--#[ Line : + +\subsubsection{Ordinary straight lines} +\label{sec:Line} + + +All of the commands in this section can be given optional keyword +arguments, which are defined in Secs.\ \ref{sec:options} and +\ref{sec:arrows}. These can be used to specify the type of line +(dashed, double), to specify the use of an arrow, and its parameters, and +to specify some of the line's parameters. + +The basic line drawing command is \verb+\Line+:\\[3mm] +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\Line(10,10)(80,30) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{line} +\verb:\Line(10,10)(80,30): \hfill \\ +In this command we have two coordinates. The (solid) line goes from the +first to the second. +\end{minipage}\vspace{4mm} + +Examples of the use of optional arguments are:\\[3mm] +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,80)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\Line[color=Magenta,arrow](10,70)(80,70) +\Line[dash](10,50)(80,50) +\Line[arrow,double](10,30)(80,30) +\Line[arrow,dash,double](10,10)(80,10) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{line.options} +\begin{verbatim} +\Line[color=Magenta,arrow](10,70)(80,70) +\Line[dash](10,50)(80,50) +\Line[arrow,double](10,30)(80,30) +\Line[arrow,dash,double](10,10)(80,10) +\end{verbatim} +\end{minipage} +\\[4mm] +Details of the specification of arrows, together with alternative +commands for making lines with arrows are given in Sec.\ +\ref{sec:arrows}. + +\vspace{4mm} +%--#] Line : +%--#[ DoubleLine : + +Alternative commands for dashed and/or double lines are:\\[3mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DoubleLine(10,25)(80,25){1} +\DoubleLine[color=Red](10,15)(80,15){2} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doubleline} +\verb:\DoubleLine(10,25)(80,25){1}: \hfill \\ +\verb:\DoubleLine[color=Red](10,15)(80,15){2}: \hfill \\ +In this command we have two coordinates as in the Line command but two +lines are drawn. The extra parameter is the separation between the two +lines. Note however that everything between the lines is blanked out. +\end{minipage}\vspace{4mm} + +%--#] DoubleLine : +%--#[ DashLine : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashLine(10,25)(80,25){2} +\DashLine(10,15)(80,15){6} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashline} +\verb:\DashLine(10,25)(80,25){2}: \hfill \\ +\verb:\DashLine(10,15)(80,15){6}: \hfill \\ +In this command we have two coordinates. The dashed line goes from the +first to the second. The extra parameter is the size of the dashes. The +space between the dashes is transparent. +\end{minipage}\vspace{4mm} + +%--#] DashLine : +%--#[ DashDoubleLine : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashDoubleLine(10,25)(80,25){1.5}{2} +\DashDoubleLine(10,15)(80,15){1.5}{6} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoubleline} +\verb:\DashDoubleLine(10,25)(80,25){1.5}{2}: \hfill \\ +\verb:\DashDoubleLine(10,15)(80,15){1.5}{6}: \hfill \\ +In this command we have two coordinates. The dashed lines go from the +first to the second. The first extra parameter is the separation between +the lines and the second extra parameter is the size of the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashDoubleLine : +%--#[ Arc : + +\subsubsection{Arcs} +\label{sec:Arc} + +The commands in this section draw circular arcs in types corresponding +to the straight lines of Sec.\ \ref{sec:Line}. In v.\ 1, some of +these commands had names containing ``Arc'' and some ``CArc''. Some +kinds had variant names containing ``Arcn'', whose the direction of +drawing was clockwise instead of anticlockwise. In v.\ 2, we have +tried to make the situation more consistent. First, all the old names +have been retained, for backward compatibility. Second, a general +purpose command \verb+\Arc+ has been introduced; in a single command, +with the aid of optional arguments, it covers all the variants. See +Secs.\ \ref{sec:options} and \ref{sec:arrows} for full details. The +options can be used to specify the type of line (dashed, double, +clockwise or anticlockwise), to specify the use of arrow, and its +parameters, and to specify some of the line's parameters. The other +commands in this section can also be given optional keyword arguments. + +The basic \verb+\Arc+ command has the form\\[3mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\Arc(45,0)(40,20,160) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{carc} +\verb:\Arc(45,0)(40,20,160):\hfill \\ +In this command we have one coordinate: the center of the circle. Then +follow the radius of the circle, the start angle and the finishing angle. +The arc will be drawn counterclockwise. +\end{minipage}\vspace{4mm} + +An example of the use of the optional parameters is:\\[3mm] +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-10,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\Arc[arrow,dash,clockwise](40,40)(30,20,160) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{carc.opt} +\verb:\Arc[arrow,dash,clockwise](40,40)(30,20,160): +\end{minipage}\vspace{4mm} + +Alternative commands for dashed and/or double arcs are as follows. +\vspace*{4mm} + +%--#] Arc : +%--#[ DoubleArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DoubleArc[color=Green](45,0)(40,20,160){2} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublearc} +\verb:\DoubleArc[color=Green](45,0)(40,20,160){2}:\hfill \\ +In this command we have one coordinate: the center of the circle. Then +follow the radius of the circle, the start angle and the finishing angle. +The arc will be drawn counterclockwise. The last argument is the line +separation of the double line. +\end{minipage}\vspace{4mm} + +%--#] DoubleArc : +%--#[ DashArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashArc(45,0)(40,20,160){4} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dasharc} +\verb:\DashArc(45,0)(40,20,160){4}:\hfill \\ +In this command we have one coordinate: the center of the circle. Then +follow the radius of the circle, the start angle and the finishing angle. +The arc will be drawn counterclockwise. The last argument is the size of +the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashArc : +%--#[ DashDoubleArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashDoubleArc(45,0)(40,20,160){2}{4} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublearc} +\verb:\DashDoubleArc(45,0)(40,20,160){2}{4}:\hfill \\ +In this command we have one coordinate: the center of the circle. Then +follow the radius of the circle, the start angle and the finishing angle. +The arc will be drawn counterclockwise. The last two arguments are the line +separation of the double line and the size of the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashDoubleArc : +%--#[ Bezier : + +\subsubsection{B\'ezier lines} +\label{sec:Bezier} + +The commands in this section draw B\'ezier curves, specified by 4 +points. The variants are just as for straight lines, Sec.\ +\ref{sec:Line}. + +All of the commands in this section can be given optional keyword +arguments, which are defined in Sec.\ \ref{sec:options}. These can be +used to specify the type of line (dashed, double), to specify the use +of an arrow, and its parameters, and to specify some of the line's +parameters. + +The basic general purpose command is \verb+\Bezier+:\\[3mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\Bezier(10,10)(75,30)(65,40)(20,50) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{bezier} +\verb:\Bezier(10,10)(75,30)(65,40)(20,50): \hfill \\ +Draws a cubic B\'ezier curve based on the four given points. The first +point is the starting point and the fourth the finishing point. The +second and third points are the two control points. +\end{minipage}\vspace{4mm} + +An example of the use of optional arguments is +\\[3mm] +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\Bezier[color=Red,arrow,double,arrowpos=1](10,10)% + (75,30)(65,40)(20,50) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{bezier.opt} +\begin{verbatim} + \Bezier[color=Red,arrow,double,arrowpos=1](10,10)% + (75,30)(65,40)(20,50) +\end{verbatim} +\end{minipage}\vspace{4mm} + +%--#] Bezier : +%--#[ DoubleBezier : +Alternative ways of making dashed and/or double B\'ezier curves +are:\\[3mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\DoubleBezier(10,10)(75,30)(65,40)(20,50){1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublebezier} +\verb:\DoubleBezier(10,10)(75,30)(65,40)(20,50){1.5}: \hfill \\ +Draws a cubic B\'ezier curve based on the four given points. +The first four arguments are the same as for \verb+\Bezier+. +The final argument is the line separation. +\end{minipage}\vspace{4mm} + +%--#] DoubleBezier : +%--#[ DashBezier : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\DashBezier(10,10)(75,30)(65,40)(20,50){4} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashbezier} +\verb:\DashBezier(10,10)(75,30)(65,40)(20,50){4}: \hfill \\ +Draws a cubic B\'ezier curve based on the four given points. +The first four arguments are the same as for \verb+\Bezier+. +The final argument is the size of the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashBezier : +%--#[ DashDoubleBezier : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\DashDoubleBezier(10,10)(75,30)(65,40)(20,50){1.5}{4} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublebezier} +\verb:\DashDoubleBezier(10,10)(75,30)(65,40)(20,50){1.5}{4}: +Draws a cubic B\'ezier curve based on the four given points. +The first four arguments are the same as for \verb+\Bezier+. +The final two arguments are the line separation and the size of the +dashes. +\end{minipage}\vspace{4mm} + +%--#] DashDoubleBezier : +%--#[ Curve : + +\subsubsection{Curves} + +The commands in this section draw curves through an arbitrary sequence +of points. They only exist in variants for continuous and dashed +lines. No optional arguments are allowed. +\vspace{4mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\Curve{(5,55)(10,32.5)(15,23)(20,18)(25,14.65)(30,12.3)(40,9.5)(55,7)} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{curve} +\verb:\Curve{(5,55)(10,32.5)(15,23)(20,18): \hfill \\ +\verb: (25,14.65)(30,12.3)(40,9.5)(55,7)}: \hfill \\ +Draws a smooth curve through the given points. The $x$ coordinates of the +points should be in ascending order. The curve is obtained by constructing +quadratic fits to each triplet of adjacent points and then in each interval +between two points interpolating between the two relevant parabolas. +\end{minipage}\vspace{4mm} + +%--#] Curve : +%--#[ DashCurve : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\DashCurve{(5,55)(10,32.5)(15,23)(20,18)(25,14.65)(30,12.3)(40,9.5)(55,7)}{4} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashcurve} +\verb:\DashCurve{(5,55)(10,32.5)(15,23)(20,18): \hfill \\ +\verb: (25,14.65)(30,12.3)(40,9.5)(55,7)}{4}: \hfill \\ +Draws a smooth dashed curve through the given points. The $x$ coordinates of +the points should be in ascending order. The last argument is the size of +the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashCurve : +%--#[ Gluon : + +\subsubsection{Gluon lines} +\label{sec:Gluon} + +The basic gluon drawing commands are \verb+\Gluon+, \verb+\GluonArc+, +\verb+\GluonCirc+. There are also variants for dashed and double +gluons. But arrows aren't possible. + +See Sec.\ \ref{sec:gluon.remarks} for additional information on the +shape of gluon lines. + +All of the commands in this section can be given optional keyword +arguments, which are defined in Sec.\ \ref{sec:options}. These can be +used to specify the type of line (dashed, double), and to specify some +of the line's parameters. +\vspace{3mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\Gluon(10,20)(80,20){5}{7} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluon} +\verb:\Gluon(10,20)(80,20){5}{7}: \hfill \\ +In this command we have coordinates for the start and end of the line, +the amplitude of the windings and the number of windings. A negative +value for the amplitude reverses the orientation of the windings --- +see Sec.\ \ref{sec:gluon.remarks} for details. +\end{minipage} +\\[4mm] +Optional arguments can be used, e.g., \hfill \\[3mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\Gluon[color=Blue,dash,dashsize=1,double](10,20)(80,20){4}{7} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluon.opt} +\verb:\Gluon[color=Blue,dash,double](10,20)(80,20){4}{7}: +\end{minipage} + + +\vspace{4mm} + +%--#] Gluon : +%--#[ DoubleGluon : +\noindent +Examples of the other commands for various types of gluon line are as +follows. They can all take optional arguments. +\\[3mm] +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DoubleGluon(10,20)(80,20){5}{7}{1.3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublegluon} +\verb:\DoubleGluon(10,20)(80,20){5}{7}{1.3}:\hfill \\ +The first 6 arguments are as in the \verb+\Gluon+ command. The +extra argument is the line separation. +\end{minipage}\vspace{4mm} + +%--#] DoubleGluon : +%--#[ DashGluon : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashGluon(10,20)(80,20){5}{7}{1} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashgluon} +\verb:\DashGluon(10,20)(80,20){5}{7}{1}:\hfill \\ +The first 6 arguments are as in the \verb+Gluon+ command. The +extra argument is the size of the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashGluon : +%--#[ DashDoubleGluon : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashDoubleGluon(10,20)(80,20){5}{7}{1.3}{1} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublegluon} +\verb:\DashDoubleGluon(10,20)(80,20){5}{7}{1.3}{1}:\hfill \\ +The first 7 arguments are as in the \verb+DoubleGluon+ +command. +The last two arguments are the line +separation of the double line and the size of the dashes. +\end{minipage} +\vspace{8mm} + +%--#] DashDoubleGluon : +%--#[ GluonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\GluonArc(45,0)(40,20,160){5}{8} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluonarc} +\verb:\GluonArc(45,0)(40,20,160){5}{8}:\hfill \\ +In this command we have one coordinate: the center of the circle. Then +follow the radius of the circle, the start angle and the finishing angle. +The arc will be drawn counterclockwise. The final two parameters are the +amplitude of the windings and the number of windings. +Like the other commands in this section, this command can take +optional arguments, Sec.\ \ref{sec:options}. +\end{minipage} +\vspace{4mm} + +%--#] GluonArc : +%--#[ DoubleGluonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} + \DoubleGluonArc[color=Red](45,0)(40,20,160)% + {5}{8}{1.3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublegluonarc} +\begin{verbatim} + \DoubleGluonArc[color=Red](45,0)(40,20,160)% + {5}{8}{1.3} +\end{verbatim} +The first 7 arguments are as in the \verb+GluonArc+ command. The extra +argument is the separation in the double line. +\end{minipage}\vspace{4mm} + +%--#] DoubleGluonArc : +%--#[ DashGluonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashGluonArc(45,0)(40,20,160){5}{8}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashgluonarc} +\verb:\DashGluonArc(45,0)(40,20,160){5}{8}{1.5}:\hfill \\ +The first 7 arguments are as in the \verb+GluonArc+ command. The extra +argument is the size of the dash segments. +\end{minipage}\vspace{4mm} + +%--#] DashGluonArc : +%--#[ DashDoubleGluonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashDoubleGluonArc(45,0)(40,20,160){5}{8}{1.3}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublegluonarc} +\verb:\DashDoubleGluonArc(45,0)(40,20,160){5}{8}{1.3}{1.5}:\hfill \\ +The first 7 arguments are as in the \verb+GluonArc+ command. The extra +arguments are the separation of the lines and the size of the dash +segments. +\end{minipage}\vspace{10mm} + +%--#] DashDoubleGluonArc : +%--#[ GluonCirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-15,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\GluonCirc(40,40)(30,0){5}{16} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluoncirc} +\verb:\GluonCirc(40,40)(30,0){5}{16}:\hfill \\ +The arguments are: Coordinates for the center of the circle, the +radius and a phase, the +amplitude of the gluon windings and the number of windings. +Like the other commands in this section, this command can take +optional arguments, Sec.\ \ref{sec:options}. The phase argument +specifies a counterclockwise rotation of the line relative to a +default starting point. +\end{minipage}\vspace{4mm} + +%--#] GluonCirc : +%--#[ DoubleGluonCirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-15,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\DoubleGluonCirc[color=Red](40,40)(30,0){5}{16}{1.3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublegluoncirc} +\verb:\DoubleGluonCirc[color=Red](40,40)(30,0){5}{16}{1.3}:\hfill \\ +The first 6 arguments are as for the \verb+GluonCirc+ command. The +final argument is the line separation. +\end{minipage}\vspace{4mm} + +%--#] DoubleGluonCirc : +%--#[ DashGluonCirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-15,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\DashGluonCirc(40,40)(30,0){5}{16}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashgluoncirc} +\verb:\DashGluonCirc(40,40)(30,0){5}{16}{1.5}:\hfill \\ +The first 6 arguments are as for the \verb+GluonCirc+ command. +The final argument is the size of the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashGluonCirc : +%--#[ DashDoubleGluonCirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-15,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\DashDoubleGluonCirc(40,40)(30,0){5}{16}{1.3}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublegluoncirc} +\verb:\DashDoubleGluonCirc(40,40)(30,0){5}{16}{1.3}{1.5}:\hfill \\ +The first 6 arguments are as for the \verb+GluonCirc+ command. +The final 2 arguments are the line separation and the size of the +dashes. +\end{minipage}\vspace{4mm} + +%--#] DashDoubleGluonCirc : +%--#[ Photon : + +\subsubsection{Photon lines} +\label{sec:Photon} + +The basic drawing commands for drawing photon lines are \verb+\Photon+ +and \verb+\PhotonArc+. There are also variants for dashed and double +photons. But arrows aren't possible. + +All of the commands in this section can be given optional keyword +arguments, which are defined in Sec.\ \ref{sec:options}. These can be +used to specify the type of line (dashed, double), and to specify some +of the line's parameters.\vspace{3mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\Photon(10,20)(80,20){5}{7} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{photon} +\verb:\Photon(10,20)(80,20){5}{7}: \hfill \\ +In this command we have two coordinates, the amplitude of the wiggles and +the number of wiggles. +A negative value for the amplitude will reverse the orientation of the +wiggles. +The line will be drawn with the number of wiggles rounded to the +nearest half integer. +Like the other commands in this section, this command can take +optional arguments, Sec.\ \ref{sec:options}. +\end{minipage}\vspace{4mm} + +%--#] Photon : +%--#[ DoublePhoton : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DoublePhoton(10,20)(80,20){5}{7}{1.3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublephoton} +\verb:\DoublePhoton(10,20)(80,20){5}{7}{1.3}:\hfill \\ +The first 6 arguments are as in the \verb+Photon+ command. The +extra argument is the line separation. +\end{minipage}\vspace{4mm} + +%--#] DoublePhoton : +%--#[ DashPhoton : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashPhoton[color=Red](10,20)(80,20){5}{7}{1} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashphoton} +\verb:\DashPhoton[color=Red](10,20)(80,20){5}{7}{1}:\hfill \\ +The first 6 arguments are as in the \verb+Photon+ command. The +extra argument is the size of the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashPhoton : +%--#[ DashDoublePhoton : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashDoublePhoton(10,20)(80,20){5}{7}{1.3}{1} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublephoton} +\verb:\DashDoublePhoton(10,20)(80,20){5}{7}{1.3}{1}:\hfill \\ +The first 6 arguments are as in the \verb+Photon+ +command. +The final 2 arguments are the line separation and the size of the +dashes. +\end{minipage}\vspace{10mm} + +%--#] DashDoublePhoton : +%--#[ PhotonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\PhotonArc(45,0)(40,20,160){5}{8} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{photonarc} +\verb:\PhotonArc(45,0)(40,20,160){5}{8}:\hfill \\ +In this command we have one coordinate: the center of the circle. Then +follow the radius of the circle, the start angle and the finishing angle. +The arc will be drawn counterclockwise. The final two parameters are the +amplitude of the wiggles and the number of wiggles. +Like the other commands in this section, this command can take +optional arguments, Sec.\ \ref{sec:options}. +\end{minipage}\vspace{4mm} + +%--#] PhotonArc : +%--#[ DoublePhotonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DoublePhotonArc[color=Red](45,0)(40,20,160)% + {5}{8}{1.3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublephotonarc} +\begin{verbatim} +\DoublePhotonArc[color=Red](45,0)(40,20,160)% + {5}{8}{1.3} +\end{verbatim} +The first 7 arguments are as in the \verb+PhotonArc+ command. The extra +argument is the separation of the double line. +\end{minipage}\vspace{4mm} + +%--#] DoublePhotonArc : +%--#[ DashPhotonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashPhotonArc(45,0)(40,20,160){5}{8}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashphotonarc} +\verb:\DashPhotonArc(45,0)(40,20,160){5}{8}{1.5}:\hfill \\ +The first 7 arguments are as in the \verb+PhotonArc+ command. The +extra argument is the size of the dash segments. +\end{minipage}\vspace{4mm} + +%--#] DashPhotonArc : +%--#[ DashDoublePhotonArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashDoublePhotonArc(45,0)(40,20,160){5}{8}{1.3}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublephotonarc} +\verb:\DashDoublePhotonArc(45,0)(40,20,160){5}{8}{1.3}{1.5}:\hfill \\ +The first 7 arguments are as in the \verb+PhotonArc+ command. The +extra arguments are the separation of the lines and the size of the +dash segments. +\end{minipage}\vspace{4mm} + +%--#] DashDoublePhotonArc : +%--#[ ZigZag : + +\subsubsection{Zigzag lines} + +The basic drawing commands for drawing zigzag lines are \verb+\Zigzag+ +and \verb+\ZigzagArc+. There are also variants for dashed and double +lines. But arrows aren't possible. + +All of the commands in this section can be given optional keyword +arguments, which are defined in Sec.\ \ref{sec:options}. These can be +used to specify the type of line (dashed, double), and to specify some +of the line's parameters. +\vspace{4mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\ZigZag(10,20)(80,20){5}{7.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{zigzag} +\verb:\ZigZag(10,20)(80,20){5}{7.5}: \hfill \\ +In this command we have two coordinates, the amplitude of the sawteeth and +the number of sawteeth. +A negative value for the amplitude will reverse the orientation of the +sawteeth. +The line will be drawn with the number of sawteeth rounded to the +nearest half integer. +\end{minipage} +\\[3mm] +Like the other commands in this section, this command can take +optional arguments, Sec.\ \ref{sec:options}, e.g.,\\[3mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\ZigZag[color=Red,double,sep=1.5](10,20)(80,20){5}{7} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{zigzag.opt} +\verb:\ZigZag[color=Red,double,sep=1.5](10,20)(80,20){5}{7}: +\end{minipage}\vspace{6mm} + +%--#] ZigZag : +%--#[ DoubleZigZag : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DoubleZigZag(10,20)(80,20){5}{7}{1.3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublezigzag} +\verb:\DoubleZigZag(10,20)(80,20){5}{7}{1.3}:\hfill \\ +The first 6 arguments are as in the \verb+ZigZag+ command. The +extra argument is the line separation. +\end{minipage}\vspace{4mm} + +%--#] DoubleZigZag : +%--#[ DashZigZag : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashZigZag(10,20)(80,20){5}{7}{1} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashzigzag} +\verb:\DashZigZag(10,20)(80,20){5}{7}{1}:\hfill \\ +The first 6 arguments are as in the \verb+ZigZag+ command. The +extra argument is the size of the dashes. +\end{minipage}\vspace{4mm} + +%--#] DashZigZag : +%--#[ DashDoubleZigZag : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,40)(-10,0)} +\AxoGrid(0,0)(10,10)(9,4){LightGray}{0.5} +\DashDoubleZigZag(10,20)(80,20){5}{7}{1.3}{1} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublezigzag} +\verb:\DashDoubleZigZag(10,20)(80,20){5}{7}{1.3}{1}:\hfill \\ +The first 6 arguments are as in the \verb+ZigZag+ command. +The extra arguments are the separation of the lines and the size of +the dash segments. +\end{minipage}\vspace{6mm} + +%--#] DashDoubleZigZag : +%--#[ ZigZagArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\ZigZagArc(45,0)(40,20,160){5}{8} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{zigzagarc} +\verb:\ZigZagArc(45,0)(40,20,160){5}{8}:\hfill \\ +In this command we have one coordinate: the center of the circle. Then +follow the radius of the circle, the start angle and the finishing +angle. The arc will be drawn counterclockwise. The final two +arguments are the amplitude of the sawteeth and the number of +sawteeth. Like the other commands in this section, this command can +take optional arguments, Sec.\ \ref{sec:options}. +\end{minipage}\vspace{4mm} + +%--#] ZigZagArc : +%--#[ DoubleZigZagArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DoubleZigZagArc(45,0)(40,20,160){5}{8}{1.3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{doublezigzagarc} +\verb:\DoubleZigZagArc(45,0)(40,20,160){5}{8}{1.3}:\hfill \\ +The first 7 arguments are as for the \verb+ZigZagArc+ command. The +extra argument is the separation in the double line. +\end{minipage}\vspace{4mm} + +%--#] DoubleZigZagArc : +%--#[ DashZigZagArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashZigZagArc(45,0)(40,20,160){5}{8}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashzigzagarc} +\verb:\DashZigZagArc(45,0)(40,20,160){5}{8}{1.5}:\hfill \\ +The first 7 arguments are as for the \verb+ZigZagArc+ command. The +extra argument is the size of the dash segments. +\end{minipage}\vspace{4mm} + +%--#] DashZigZagArc : +%--#[ DashDoubleZigZagArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,50)(-10,0)} +\AxoGrid(0,0)(10,10)(9,5){LightGray}{0.5} +\DashDoubleZigZagArc(45,0)(40,20,160){5}{8}{1.3}{1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{dashdoublezigzagarc} +\verb:\DashDoubleZigZagArc(45,0)(40,20,160){5}{8}{1.3}{1.5}:\hfill \\ +The first 7 arguments are as for the \verb+ZigZagArc+ command. The +final 2 arguments are the separation of the lines and the size of the +dash segments. +\end{minipage}\vspace{4mm} + +%--#] DashDoubleZigZagArc : +%--#[ Vertex : + +\subsubsection{Vertices, circles, ovals} +\label{sec:other.graphics} + +The commands in this section are for graphical elements other +than those that we conceived of as lines in Feynman graphs. Many of +these have standard uses as components of Feynman graphs\footnote{Of + course, none of the commands is restricted to its originally + envisaged use, or to being used to draw Feynman graphs. But + especially the line-drawing commands have been designed from the + point-of-view of being suitable for the needs of drawing particular + elements of Feynman graphs.}. The commands here are mostly shown +in association with other objects, to indicate some of their +properties. +\vspace{4mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,50)(-15,0)} +\AxoGrid(0,0)(10,10)(8,5){LightGray}{0.5} +\Line(10,10)(70,10) +\Photon(40,10)(40,40){4}{3} +\Vertex(40,10){1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{vertex} +\verb:\Line(10,10)(70,10): \hfill \\ +\verb:\Photon(40,10)(40,40){4}{3}: \hfill \\ +\verb:\Vertex(40,10){1.5}: \hfill \\ +\verb+\Vertex+ gives a vertex, as is often used for connecting lines +in Feynman graphs. It gives a fat dot. The arguments are coordinates +(between parentheses) for its center, and the radius of the dot. +\end{minipage}\vspace{4mm} + +%--#] Vertex : +%--#[ ECirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\Red{\Line(0,0)(60,60)} +\ECirc(30,30){20} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{ecirc} +\verb:\Red{\Line(0,0)(60,60)}:\\ +\verb:\ECirc(30,30){20}:\\ +\verb+\ECirc+ draws a circle with its center at the specified +coordinate (first two arguments) and the specified radius (third +argument). The interior is transparent, so that it does not erase +previously drawn material. +If you need a filled circle, use the \verb+\Vertex+ command (to which +we have defined a synonym \verb+\FCirc+ to match similar commands for +other shapes). +\end{minipage}\vspace{4mm} + +%--#] ECirc : +%--#[ BCirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\Red{\Line(0,0)(60,60)} +\BCirc(30,30){20} +\Blue{\Line(60,0)(0,60)} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{bcirc} +\verb:\Red{\Line(0,0)(60,60)}:\\ +\verb:\BCirc(30,30){20}:\\ +\verb:\Blue{\Line(60,0)(0,60)}:\\ +\verb+\BCirc+ +draws a circle with the center at the specified coordinate (first two +arguments) and the specified radius (third argument). The interior is +white and opaque, so that it erases previously written objects, but not +subsequently drawn objects. +\end{minipage}\vspace{4mm} + +%--#] BCirc : +%--#[ GCirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\Red{\Line(0,0)(60,60)} +\GCirc(30,30){20}{0.82} +\Blue{\Line(60,0)(0,60)} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gcirc} +\verb:\Red{\Line(0,0)(60,60)}:\\ +\verb:\GCirc(30,30){20}{0.82}:\\ +\verb:\Blue{\Line(60,0)(0,60)}:\\ +\verb+\GCirc+ draws a circle with the center at the specified +coordinate (first two arguments) and the specified radius (third +argument). Previously written contents are overwritten and made gray +according to the grayscale specified by the fourth argument (0=black, +1=white). +\end{minipage}\vspace{4mm} + +%--#] GCirc : +%--#[ CCirc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,60)(-25,0)} +\AxoGrid(0,0)(10,10)(6,6){LightGray}{0.5} +\Red{\Line(0,0)(60,60)} +\CCirc(30,30){20}{Red}{Yellow} +\Blue{\Line(60,0)(0,60)} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{ccirc} +\verb:\Red{\Line(0,0)(60,60)}:\\ +\verb:\CCirc(30,30){20}{Red}{Yellow}:\\ +\verb:\Blue{\Line(60,0)(0,60)}:\\ +\verb+\CCirc+ draws a colored circle with the center at the specified +coordinate (first two arguments) and the specified radius (third +argument). The fourth argument is the name of the color for the circle +itself. Its interior is overwritten and colored with the color +specified by name in the fifth argument. +\end{minipage}\vspace{4mm} + +%--#] CCirc : +%--#[ Oval : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,110)(-15,0)} +\AxoGrid(0,0)(10,10)(8,11){LightGray}{0.5} +\Oval(40,80)(20,30)(0) +\Oval(40,30)(20,30)(30) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{oval} +\verb:\Oval(40,80)(20,30)(0):\\ +\verb:\Oval(40,30)(20,30)(30):\\ +\verb:\Oval: draws an oval. The first pair of values is the center of +the oval. The next pair forms the half-height and the half-width. The +last argument is a (counterclockwise) rotation angle. The interior is +transparent, so that it does not erase previously drawn material. +\end{minipage}\vspace{4mm} + +%--#] Oval : +%--#[ FOval : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,60)(-15,0)} +\AxoGrid(0,0)(10,10)(8,6){LightGray}{0.5} +\SetColor{Yellow} +\FOval(40,30)(20,30)(30) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{foval} +\verb:\SetColor{Yellow}:\\ +\verb:\FOval(40,80)(20,30)(30):\\ +\verb:\FOval: draws an oval filled with the current color overwriting +previously written material. Its arguments are the same as for the +\verb:\Oval: command. +\end{minipage}\vspace{4mm} + +%--#] FOval : +%--#[ GOval : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,60)(-15,0)} +\AxoGrid(0,0)(10,10)(8,6){LightGray}{0.5} +\Red{\Line(0,0)(80,60)} +\GOval(40,30)(20,30)(0){0.6} +\Blue{\Line(80,0)(0,60)} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{goval} +\verb:\Red{\Line(0,0)(80,60)}:\\ +\verb:\GOval(40,30)(20,30)(0){0.6}: \\ +\verb:\Blue{\Line(80,0)(0,60)}:\\ +\verb:\GOval: draws an oval with a gray interior. +The first 5 arguments are the same as for the \verb:\Oval: command. +The last argument indicates the +grayscale with which the oval will be filled, overwriting previously +written contents (0=black, 1=white). +\end{minipage}\vspace{4mm} + +%--#] GOval : +%--#[ COval : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,60)(-15,0)} +\AxoGrid(0,0)(10,10)(8,6){LightGray}{0.5} +\SetWidth{1} +\Green{\Line(0,0)(80,60)} +\COval(40,30)(20,30)(20){Orange}{Blue} +\Yellow{\Line(80,0)(0,60)} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{coval} +\verb:\Green{\Line(0,0)(80,60)}:\\ +\verb:\COval(40,30)(20,30)(20){Orange}{Blue}:\\ +\verb:\Yellow{\Line(80,0)(0,60)}:\\ +\verb:\COval: draws a colored oval. +The first 5 arguments are the same as for the \verb:\Oval: command. +The last two arguments are the names of two colors. +The first is the color of the line that forms the oval and the second is +the color of the inside. +\end{minipage}\vspace{4mm} + +%--#] COval : +%--#[ EBox : + +Commands for drawing boxes are in two series. For the first set, the +box's position is specified by the coordinates of its bottom left +corner and top right corner:\\[4mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\EBox(10,10)(50,40) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{ebox} +\verb:\EBox(10,10)(50,40): \hfill \\ +Draws a box. The points specified are the bottom left corner and the top +right corner. +The interior is transparent, so that it does not erase previously +drawn material. +\end{minipage}\vspace{4mm} + +%--#] EBox : +%--#[ FBox : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\FBox(10,10)(50,40) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{fbox} +\verb:\FBox(10,10)(50,40): \hfill \\ +Draws a box filled with the current color overwriting +previously written material. Its arguments are the same as for the +\verb:\EBox: command. +\end{minipage}\vspace{4mm} + +%--#] FBox : +%--#[ BBox : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\BBox(10,10)(50,40) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{bbox} +\verb:\BBox(10,10)(50,40): \hfill \\ +Draws a blanked-out box. The points specified are the bottom left corner +and the top right corner. +\end{minipage}\vspace{4mm} + +%--#] BBox : +%--#[ GBox : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\GBox(10,10)(50,40){0.9} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gbox} +\verb:\GBox(10,10)(50,40){0.9}: \hfill \\ +Draws a box filled with a grayscale given by the fifth argument (black=0, +white=1). The points specified are the bottom left corner and the top +right corner. +\end{minipage}\vspace{4mm} + +%--#] GBox : +%--#[ CBox : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\SetWidth{1.5} +\CBox(10,10)(50,40){Green}{LightRed} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{cbox} +\verb:\CBox(10,10)(50,40){Green}{LightRed}: \hfill \\ +Draws a box in the color specified by name in the fifth argument. The +contents are filled with the color specified by name in the sixth +argument. The points specified are the bottom left corner and the top +right corner. +\end{minipage}\vspace{4mm} + +%--#] CBox : +%--#[ EBoxc : + +For the other series of box-drawing commands, the box's position is +specified by its center, and its width and height. The command names +end with a ``\texttt{c}'', for ``center'':\\[3mm] +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\EBoxc(30,25)(40,30) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{eboxc} +\label{boxc} +\verb:\EBoxc(30,25)(40,30): \hfill \\ +Draws a box. The first two numbers give the center of the box. The next two +numbers are the width and the height of the box. Instead of \verb:\EBoxc: +one may also use \verb:\Boxc:. + +There is also the similar command \verb:\FBoxc: that draws a filled box. +\end{minipage}\vspace{4mm} + +%--#] EBoxc : +%--#[ BBoxc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\BBoxc(30,25)(40,30) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{bboxc} +\verb:\BBoxc(30,25)(40,30): \hfill \\ +Draws a box of which the contents are blanked out. The arguments are +the same as for the \verb+\EBoxc+ command. +\end{minipage}\vspace{4mm} + +%--#] BBoxc : +%--#[ GBoxc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\GBoxc(30,25)(40,30){0.9} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gboxc} +\verb:\GBoxc(30,25)(40,30){0.9}: \hfill \\ +Draws a box filled with a grayscale given by the fifth argument (black=0, +white=1). +The first 4 arguments are the same as for the \verb+\EBoxc+ command. +\end{minipage}\vspace{4mm} + +%--#] GBoxc : +%--#[ CBoxc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\SetWidth{1.5} +\CBoxc(30,25)(40,30){Brown}{LightBlue} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{cboxc} +\verb:\CBoxc(30,25)(40,30){Brown}{LightBlue}: \hfill \\ +Draws a box in the color specified by name in the fifth argument. The +contents are filled with the color specified by name in the sixth +argument. +The first 4 arguments are the same as for the \verb+\EBoxc+ command. +\end{minipage}\vspace{4mm} + +%--#] BBoxc : +%--#] CBoxc : +%--#[ RotatedBox : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\RotatedBox(30,25)(40,30){30}{Red} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{rotatedbox} +\verb:\RotatedBox(30,25)(40,30){30}{Red}: \hfill \\ +Draws a rotated box. The first two numbers give the center of the +box. The next two numbers are the width and the height of the box. The +fifth argument is the counterclockwise rotation angle and the sixth +argument is the color of the box. The interior of the box is +transparent. +\end{minipage}\vspace{4mm} + +%--#] RotatedBox : +%--#[ FilledRotatedBox : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\FilledRotatedBox(30,25)(40,30){30}{Blue} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{filledrotatedbox} +\verb:\FilledRotatedBox(30,25)(40,30){30}{Blue}: \hfill \\ +Draws a rotated box. +The first 4 arguments are the same as for the \verb+\RotatedBox+ command. +The +fifth argument is the counterclockwise rotation angle and the sixth +argument is the color of the inside of the box. If a differently +colored outline is needed, it should be written with the +\verb+RotatedBox+ command. +\end{minipage}\vspace{4mm} + +%--#] FilledRotatedBox : +%--#[ ETri : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\ETri(10,20)(50,10)(40,40) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{etri} +\verb:\ETri(10,20)(50,10)(40,40): \hfill \\ +Draws a triangle. The three points specified are the corners of the +triangle. +The interior is transparent. + +There is also the similar command \verb:\FTri: that draws a filled triangle. +\end{minipage}\vspace{4mm} + +%--#] ETri : +%--#[ BTri : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\BTri(10,20)(50,10)(40,40) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{btri} +\verb:\BTri(10,20)(50,10)(40,40): \hfill \\ +Draws a blanked-out triangle. The three points specified are the corners of +the triangle. +\end{minipage}\vspace{4mm} + +%--#] BTri : +%--#[ GTri : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\GTri(10,20)(50,10)(40,40){0.9} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gtri} +\verb:\GTri(10,20)(50,10)(40,40){0.9}: \hfill \\ +Draws a triangle of which the content are filled with the grayscale +specified by the seventh argument (black=0, white=1). The three points +specified are the corners of the triangle. +\end{minipage}\vspace{4mm} + +%--#] GTri : +%--#[ CTri : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\SetWidth{1} +\CTri(10,20)(50,10)(40,40){Red}{Yellow} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{ctri} +\verb:\CTri(10,20)(50,10)(40,40){Red}{Yellow}: \hfill \\ +Draws a triangle in the color named in the seventh argument. The +contents are filled with the color named in the eightth argument. The +three points specified are the corners of the triangle. +\end{minipage}\vspace{4mm} + +%--#] CTri : +%--#[ Polygon : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\Polygon{(10,20)(20,10)(40,20)(50,10)(45,40)(15,30)}{Red} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{polygon} +\verb:\Polygon{(10,20)(20,10)(40,20)(50,10): \hfill \\ + \verb: (45,40)(15,30)}{Red}: \hfill \\ +Draws a polygon. The first argument is a sequence of two dimensional +points which form the corners of the polygon. The second argument is +the name of the color of the polygon. The interior is transparent. +\end{minipage}\vspace{4mm} + +%--#] Polygon : +%--#[ FilledPolygon : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(60,50)(-25,0)} +\AxoGrid(0,0)(10,10)(6,5){LightGray}{0.5} +\FilledPolygon{(10,20)(20,10)(40,20)(50,10)(45,40)(15,30)}{Apricot} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{filledpolygon} +\verb:\FilledPolygon{(10,20)(20,10)(40,20)(50,10): \hfill \\ + \verb: (45,40)(15,30)}{Apricot}: \hfill \\ +Draws a polygon. The first argument is a sequence of two dimensional +points which form the corners of the polygon. The second argument is +the name of the color of the interior. +\end{minipage}\vspace{4mm} + +%--#] FilledPolygon : +%--#[ LinAxis : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(100,50)(-5,0)} +\AxoGrid(0,0)(10,10)(10,5){LightGray}{0.5} +\LinAxis(10,30)(90,30)(4,5,5,0,1) +\LinAxis(10,10)(90,10)(4,5,5,2,1) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{linaxis} +\verb:\LinAxis(10,30)(90,30)(4,5,5,0,1):\\ +\verb:\LinAxis(10,10)(100,10)(4,5,5,2,1): \\ +\verb+\LinAxis+($x_1$,$y_1$)($x_2$,$y_2$)($N_D$,$d$,hashsize,offset,width) + draws a line to be used as an axis in a graph. Along the axis + are hash marks. Going from the first coordinate to the second, the + hash marks are on the left side if `hashsize', which is the size of the + hash marks, is positive and on the right side if it is negative. + $N_D$ is the number of `decades', indicated by fat hash marks, and + $d$ is the (integer) number of subdivisions inside each decade. The offset + parameter tells to which subdivision the first coordinate + corresponds. When it is zero, this coordinate corresponds to a fat + mark of a decade. Because axes have their own width, this is + indicated with the last parameter. +%Draws a line with subdivisions that can be used as the axis on a histogram +%or other figure. The first four arguments are the endpoints of the axis. +%Then we have the number of decades, the number of divisions inside each +%decade, the size of the hash marks, the offset in divisions at which we +%start and the linewidth. The hashmarks will be on the left side when going +%from point 1 to point 2. +\end{minipage}\vspace{4mm} + +%--#] LinAxis : +%--#[ LogAxis : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(100,40)(-5,0)} +\AxoGrid(0,0)(10,10)(10,4){LightGray}{0.5} +\LogAxis(0,30)(100,30)(4,3,0,1) +\LogAxis(0,10)(100,10)(4,3,3,1) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{logaxis} +\verb:\LogAxis(0,30)(100,30)(4,3,0,1): \hfill \\ +\verb:\LogAxis(0,10)(100,10)(4,3,3,1): \hfill \\ +\verb+\LogAxis+($x_1$,$y_1$)($x_2$,$y_2$)($N_L$,hashsize + ,offset,width) \hfill \\ + This draws a line to be used as a logarithmic axis in a graph. Along + the axis are hash marks. Going from the first coordinate to the second, + the hash marks are on the left side if `hashsize', which is the size of + the hash marks, is positive and on the right side if it is negative. + $N_L$ is the number of orders of magnitude, indicated by fat hash + marks. The offset parameter tells to which integer subdivision the + first coordinate corresponds. When it is zero, this coordinate + corresponds to a fat mark, which is identical to when the value would + have been 1. Because axes have their own width, this is indicated with + the last parameter. +%Draws a line with subdivisions that can be used as the axis on a histogram +%or other figure. The first four arguments are the endpoints of the axis. +%Then we have the number of orders of magnitude, +%the size of the hash marks, the offset inside a logarithm at which we +%start and the linewidth. The hashmarks will be on the left side when going +%from point 1 to point 2. +\end{minipage}\vspace{4mm} + +%--#] LogAxis : +%>>#] The Commands : +%>>#[ Text : + +\subsection{Text} +\label{sec:text} + +%--#[ Implementation : + +Axodraw2 provides several commands for inserting text into diagrams. +Some are for plain text, with a chosen placement and angle. Some +allow placement of text inside boxes. There are two sets of commands. +Some we call \TeX-text commands; these use the standard \LaTeX{} fonts +as used in the rest of the document. The others we call +postscript-text commands; these use a user-specified standard +postscript font or, if the user wishes, the usual document font, at a +user-chosen size. + +[\emph{Side issue:} In version 1 of axodraw, the difference between +the classes of text command was caused by a serious implementation +difficulty. With the then-available \LaTeX{} technology, certain +graphic effects, could not be achieved within \LaTeX, at least not +easily. So direct programming in postscript was resorted to, with the +result that normal \LaTeX{} commands, including mathematics, were not +available in the postscript-text commands. With the greatly improved +methods now available, this has all changed, and the restrictions have +gone. But since the commands and their basic behavior is already +defined, we have retained the distinction between \TeX{}-text commands +and postscript-text commands.] + +In the original version of Axodraw the commands for two lines inside a +box were \verb:B2Text:, \verb:G2Text: and \verb:C2Text:. This causes +some problems explained in Sec.\ \ref{sec:changes.wrt.1}. If you need to +retain compatibility with v.\ 1 on this issue, e.g., with old files or +old diagrams or for personal preference, you can use the +\texttt{v1compatible} option when loading axodraw2 --- see Sec.\ +\ref{sec:invoke}. + +\vspace{4mm} + +%--#] Implementation : +%--#[ Text : + +\subsubsection{\TeX-type text} + +Illustrated by examples, the commands to insert text are as follows: + +\medskip + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,90)(-10,0)} +\AxoGrid(0,0)(10,10)(9,9){LightGray}{0.5} +\Text(10,10)[l]{left} +\Text(45,45){centered} +\Text(80,80)[rt]{right-top} +\Text(20,60)(45){$e^{i\pi/4}$} +\SetColor{Red} +\Vertex(10,10){1.5} +\Vertex(45,45){1.5} +\Vertex(80,80){1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{text} +\verb:\Text(10,10)[l]{left}: \hfill \\ +\verb:\Text(45,45){centered}: \hfill \\ +\verb:\Text(80,80)[rt]{right-top}: \hfill \\ +\verb:\Text(20,60)(45){$e^{i\pi/4}$}: \hfill \\ +\verb:\SetColor{Red}: \hfill \\ +\verb:\Vertex(10,10){1.5}: \hfill \\ +\verb:\Vertex(45,45){1.5}: \hfill \\ +\verb:\Vertex(80,80){1.5}: \hfill \\ +\verb+\Text+ writes text in the current \LaTeX{} font. The most +general form is \verb+\Text(x,y)(theta)[pos]{text}+; but either or +both of the theta and pos arguments (and their delimiters) can be omitted. +It puts the text +at focal point $(x,y)$, with a rotation by anticlockwise angle theta. +The default angle is zero, and the default position is to +center the text horizontally and vertically at the focal point. The +position letters are any relevant combination of `l', `r', `t', and +`b', as in the various +\TeX/\LaTeX{} box commands to indicate left, right, top or bottom +adjustment with respect to the focal point. No indication means +centered. +\end{minipage}\vspace{4mm} + +%--#] Text : +%--#[ rText : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,90)(-10,0)} +\AxoGrid(0,0)(10,10)(9,9){LightGray}{0.5} +\rText(10,10)[l][l]{left-left} +\rText(45,45)[][u]{upside} +\rText(80,10)[r][r]{right-right} +\rText(20,60)[][r]{$e^{i\pi}$} +\SetColor{Red} +\Vertex(10,10){1.5} +\Vertex(45,45){1.5} +\Vertex(80,10){1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{rtext} +\verb:\rText(10,10)[l][l]{left-left}: \hfill \\ +\verb:\rText(45,45)[][u]{upside}: \hfill \\ +\verb:\rText(80,10)[r][r]{right-right}: \hfill \\ +\verb:\rText(20,60)[][r]{$e^{i\pi}$}: \hfill \\ +\verb:\SetColor{Red}: \hfill \\ +\verb:\Vertex(10,10){1.5}: \hfill \\ +\verb:\Vertex(45,45){1.5}: \hfill \\ +\verb:\Vertex(80,10){1.5}: \hfill \\ +The \verb:\rText: command gives a subset of the functionality of the +\verb+\Text+ command. It is used for backward compatibility with +Axodraw v.\ 1. The general form of the command is +\verb:\rText(x,y)[mode][rotation]{text}:. +Unlike the case with the \verb:\Text: command and typical standard +\LaTeX{} commands, if the option letters are omitted, the square +brackets must be retained. +The coordinates $(x,y)$ are +the focal point of the text. The third argument is \verb+l+, +\verb+r+, or empty to indicate the justification of the text. The +fourth argument is \verb+l+, \verb+r+, \verb+u+, or empty to indicate +respectively whether the text is rotated left (anticlockwise) by 90 +degrees, is rotated right (clockwise) by 90 degrees, is upside-down, +or is not rotated. The fifth argument is the text. +This command is retained only for backward compatibility; +for new diagrams it is probably better to use the the \verb:\Text:. +\end{minipage}\vspace{4mm} + +%--#] rText : +%--#[ SetPFont : + +\subsubsection{Postscript-type text} +\label{sec:PSText} + +The remaining text-drawing commands can use postscript fonts with an +adjustable size. + +To set the font for later text-drawing commands in this class, the +\verb:\SetPFont: command sets the `Postscript' +font, e.g., +\begin{verbatim} + \SetPFont{Helvetica}{20} +\end{verbatim} +(This font is initialized by axodraw2 to Times-Roman at 10pt.) +The font set in this way is used in the \verb:PText:, \verb:BText:, +\verb:GText:, \verb:CText:, \verb:BTwoText:, \verb:GTwoText: and +\verb:CTwoText: commands. The fonts that can be used are the 35 fonts +that are made available by Adobe and that are normally available in +all postscript interpreters, including printers. The fonts, together +with the names used to specify them in the normal font-setting +commands of \TeX{} and \LaTeX{}, are shown in Table \ref{tab:Pfont}. + +\begin{table} +\begin{tabular}{|l|l|l|l|} +\hline +Font name & \LaTeX{} & Font name & \LaTeX{} \\ +\hline +AvantGarde-Book & pagk & Helvetica-Narrow & phvrrn\\ +AvantGarde-BookOblique & pagko & Helvetica-NarrowOblique & phvron\\ +AvantGarde-Demi & pagd & NewCenturySchlbk-Bold & pncb \\ +AvantGarde-DemiOblique & pagdo & NewCenturySchlbk-BoldItalic & pncbi \\ +Bookman-Demi & pbkd & NewCenturySchlbk-Italic & pncri \\ +Bookman-DemiItalic & pbkdi & NewCenturySchlbk-Roman & pncr \\ +Bookman-Light & pbkl & Palatino-Bold & pplb \\ +Bookman-LightItalic & pbkli & Palatino-BoldItalic & pplbi \\ +Courier-Bold & pcrb & Palatino-Italic & pplri \\ +Courier-BoldOblique & pcrbo & Palatino-Roman & pplr \\ +Courier & pcrr & Symbol & psyr \\ +Courier-Oblique & pcrro & Times-Bold & ptmb \\ +Helvetica-Bold & phvb & Times-BoldItalic & ptmbi \\ +Helvetica-BoldOblique & phvbo & Times-Italic & ptmri \\ +Helvetica-NarrowBold & phvbrn& Times-Roman & ptmr \\ +Helvetica-NarrowBoldOblique & phvbon& ZapfChancery-MediumItalic & pzcmi \\ +Helvetica & phvr & ZapfDingbats & pzdr \\ +Helvetica-Oblique & phvro & & \\ +\hline +\end{tabular} +\caption{Available postscript fonts and their corresponding names in + \LaTeX.} +\label{tab:Pfont} +\end{table} +If you prefer to use the normal document font (which would normally be +Computer Modern in the common document classes), you simply leave the +fontname empty, e.g,. +\begin{verbatim} + \SetPFont{}{20} +\end{verbatim} +As for the second, fontsize argument, leaving it empty uses the size +that \LaTeX{} is using at the moment the text-drawing command starts, +e.g., +\begin{verbatim} + \SetPFont{Helvetica-Bold}{} +\end{verbatim} +\vspace{3mm} + +%--#] SetPFont : +%--#[ PText : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,90)(-10,0)} +\AxoGrid(0,0)(10,10)(9,9){LightGray}{0.5} +\SetPFont{Helvetica}{13} +\PText(10,10)(0)[l]{left} +\PText(45,45)(30)[]{centered} +\PText(80,80)(20)[rt]{right-top} +%\PText(20,60)(140)[]{$e^{i\pi}$} +\SetColor{Red} +\Vertex(10,10){1.5} +\Vertex(45,45){1.5} +\Vertex(80,80){1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{ptext} +\verb:\SetPFont{Helvetica}{13}: \hfill \\ +\verb:\PText(10,10)(0)[l]{left}: \hfill \\ +\verb:\PText(45,45)(30)[]{centered}: \hfill \\ +\verb:\PText(80,80)(20)[rt]{right-top}: \hfill \\ +%\verb:\PText(20,60)(90)[]{$e^{i\pi}$}: \hfill \\ +\verb:\SetColor{Red}: \hfill \\ +\verb:\Vertex(10,10){1.5}: \hfill \\ +\verb:\Vertex(45,45){1.5}: \hfill \\ +\verb:\Vertex(80,80){1.5}: \hfill \\ +The \verb:\PText: command writes %text +in Axodraw's current Postscript font. +The first two arguments give the focal point, the third argument is a +rotation angle and the fourth argument is as in the various \TeX/\LaTeX{} +box commands to indicate left, right, top or bottom adjustment with respect +to the focal point. No indication means centered. + +Note that use of normal \LaTeX{} font setting commands or of math-mode +will not normally have the desired effect. +\end{minipage}\vspace{4mm} + +%--#] PText : +%--#[ BText : + +\noindent +\begin{minipage}{4.53cm} +\begin{axopicture}{(110,110)(-10,0)} +\AxoGrid(0,0)(10,10)(10,9){LightGray}{0.5} +\ArrowLine(30,65)(60,25) +\SetPFont{Bookman-Demi}{14} +\BText(30,65){Who?} +\SetPFont{AvantGarde-Book}{16} +\BText(60,25){Me?} +\end{axopicture} +\end{minipage} +\begin{minipage}{10.8cm} +\label{btext} +\verb:\ArrowLine(30,65)(60,25): \hfill \\ +\verb:\SetPFont{Bookman-Demi}{14}: \hfill \\ +\verb:\BText(30,65){Who?}: \hfill \\ +\verb:\SetPFont{AvantGarde-Book}{16}: \hfill \\ +\verb:\BText(60,25){Me?}: \hfill \\ +The \verb:\BText: command writes a centered box with text in it. It uses +Axodraw's current Postscript font. +\end{minipage}\vspace{4mm} + +%--#] BText : +%--#[ GText : + +\noindent +\begin{minipage}{4.53cm} +\begin{axopicture}{(110,110)(-10,0)} +\AxoGrid(0,0)(10,10)(10,9){LightGray}{0.5} +\ArrowLine(30,65)(60,25) +\SetPFont{Bookman-Demi}{12} +\GText(30,65){0.9}{Why?} +\SetPFont{Courier-Bold}{5} +\GText(60,25){0.75}{We wanted it that way!} +\end{axopicture} +\end{minipage} +\begin{minipage}{10.8cm} +\label{gtext} +\verb:\ArrowLine(30,65)(60,25): \hfill \\ +\verb:\SetPFont{Bookman-Demi}{12}: \hfill \\ +\verb:\GText(30,65){0.9}{Why?}: \hfill \\ +\verb:\SetPFont{Courier-Bold}{5}: \hfill \\ +\verb:\GText(60,25){0.75}{We wanted it that way!}: \hfill \\ +The \verb:\GText: command writes a centered box with text in it. It uses +Axodraw's current Postscript font. The third argument is the grayscale +with which +the box will be filled. 0 is black and 1 is white. +\end{minipage}\vspace{4mm} + +%--#] GText : +%--#[ CText : + +\noindent +\begin{minipage}{4.53cm} +\begin{axopicture}{(110,110)(-10,0)} +\AxoGrid(0,0)(10,10)(9,9){LightGray}{0.5} +\ArrowLine(30,65)(60,25) +\SetPFont{Times-Bold}{15} +\CText(30,65){LightYellow}{LightBlue}{Who?} +\SetPFont{Courier-Bold}{14} +\CText(60,25){Red}{Yellow}{You!} +\end{axopicture} +\end{minipage} +\begin{minipage}{10.8cm} +\label{ctext} +\verb:\ArrowLine(30,65)(60,25): \hfill \\ +\verb:\SetPFont{Times-Bold}{15}: \hfill \\ +\verb:\CText(30,65){LightYellow}{LightBlue}{Who?}: \hfill \\ +\verb:\SetPFont{Courier-Bold}{14}: \hfill \\ +\verb:\CText(60,25){Red}{Yellow}{You!}: \hfill \\ +The \verb:\CText: command writes a centered box with text in it. It uses +Axodraw's current Postscript font. The third argument is the color of +the box and +the text. The fourth argument is the color with which the box will be +filled. +\end{minipage}\vspace{4mm} + +%--#] CText : +%--#[ BTwoText : +\noindent +\begin{minipage}{4.53cm} +\begin{axopicture}{(110,110)(-10,0)} +\AxoGrid(0,0)(10,10)(9,9){LightGray}{0.5} +\ArrowLine(30,65)(60,25) +\SetPFont{Bookman-Demi}{14} +\BTwoText(30,65){Why}{Me?} +\SetPFont{AvantGarde-Book}{16} +\BTwoText(60,25){You}{did it} +\end{axopicture} +\end{minipage} +\begin{minipage}{10.8cm} +\label{btwotext} +\verb:\ArrowLine(30,65)(60,25): \hfill \\ +\verb:\SetPFont{Bookman-Demi}{14}: \hfill \\ +\verb:\BTwoText(30,65){Why}{Me?}: \hfill \\ +\verb:\SetPFont{AvantGarde-Book}{16}: \hfill \\ +\verb:\BTwoText(60,25){You}{did it}: \hfill \\ +The \verb:\BTwoText: command writes a centered box with two lines of text in +it. It uses Axodraw's current Postscript font. +\end{minipage}\vspace{4mm} + +%--#] BTwoText : +%--#[ GTwoText : + +\noindent +\begin{minipage}{4.53cm} +\begin{axopicture}{(110,110)(-10,0)} +\AxoGrid(0,0)(10,10)(10,9){LightGray}{0.5} +\ArrowLine(30,65)(60,25) +\SetPFont{Bookman-Demi}{12} +\GTwoText(30,65){0.9}{Prove}{it!} +\SetPFont{Courier-Bold}{11} +\GTwoText(60,25){0.75}{Sherlock}{says so} +\end{axopicture} +\end{minipage} +\begin{minipage}{10.8cm} +\label{gtwotext} +\verb:\ArrowLine(30,65)(60,25): \hfill \\ +\verb:\SetPFont{Bookman-Demi}{12}: \hfill \\ +\verb:\GTwoText(30,65){0.9}{Prove}{it!}: \hfill \\ +\verb:\SetPFont{Courier-Bold}{11}: \hfill \\ +\verb:\GTwoText(60,25){0.75}{Sherlock}{says so}: \hfill \\ +The \verb:\GTwoText: command writes a centered box with two lines of text in +it. It uses Axodraw's current Postscript font. The third argument is the +grayscale with which the box will be filled. 0 is black and 1 is white. +\end{minipage}\vspace{4mm} + +%--#] GTwoText : +%--#[ CTwoText : + +\noindent +\begin{minipage}{4.53cm} +\begin{axopicture}{(110,110)(-10,0)} +\AxoGrid(0,0)(10,10)(9,9){LightGray}{0.5} +\ArrowLine(30,65)(60,25) +\SetPFont{Times-Bold}{10} +\CTwoText(30,65){LightYellow}{Blue}{That is}{no proof!} +\SetPFont{Courier-Bold}{14} +\CTwoText(60,25){Red}{Yellow}{Yes}{it is} +\end{axopicture} +\end{minipage} +\begin{minipage}{10.8cm} +\label{ctwotext} +\verb:\ArrowLine(30,65)(60,25): \hfill \\ +\verb:\SetPFont{Times-Bold}{10}: \hfill \\ +\verb:\CTwoText(30,65){LightYellow}{Blue}: \\ + \verb:{That is}{no proof!}: \hfill \\ +\verb:\SetPFont{Courier-Bold}{14}: \hfill \\ +\verb:\CTwoText(60,25){Red}{Yellow}{Yes}{it is}: \hfill \\ +The \verb:\CTwoText: command writes a centered box with two lines of text in +it. It uses Axodraw's current Postscript font. The third argument is +the color of both +the box and the text. The fourth argument is the color with which the box +will be filled. +\end{minipage}\vspace{4mm} + +%--#] CTwoText : +%--#[ Features : + +Note that because you can now use \LaTeX{} commands for the text +arguments of the commands described in this section, the effects of +the \verb+\BTwoText+, \verb+\GTwoText+, and \verb+\CTwoText+ can be +achieved also by the use of regular \verb:\BText: etc commands. +Mathematics can also be used. (None of these was possible in v.\ 1 of +axodraw.) Here are some examples: \vspace{4mm} + +\noindent +\begin{minipage}{5.5cm} +\begin{axopicture}{(150,90)(-10,0)} +\AxoGrid(0,0)(10,10)(12,9){LightGray}{0.5} +\SetPFont{Helvetica}{15} +\BText(60,45){% + \begin{minipage}{4.5cm} + Here is boxed text in a larger size, including + mathematics: $\alpha^2$. + \end{minipage}% +} +\end{axopicture} +\end{minipage} +\begin{minipage}{8.5cm} +\label{btext2} +\begin{verbatim} +\SetPFont{Helvetica}{15} +\BText(70,45){% + \begin{minipage}{4.5cm} + Here is boxed text in a + larger size, including + mathematics: $\alpha^2$. + \end{minipage}% +} +\end{verbatim} +This example shows that the \verb:\BText: command can also be used +with minipages and other \LaTeX{} methods to make more complicated +boxed texts. +\end{minipage} +\vspace{4mm} + +\noindent +\begin{minipage}{5.5cm} +\begin{axopicture}{(150,90)(-10,0)} +\AxoGrid(0,0)(10,10)(13,9){LightGray}{0.5} +\SetPFont{}{15} +\BText(65,45){% + \begin{minipage}{4cm} + \sffamily Here is boxed text in a + large size, including + mathematics: $\alpha^2$. + \end{minipage}% +} +\end{axopicture} +\end{minipage} +\begin{minipage}{8.5cm} +\label{btext2.mod} +\begin{verbatim} +\SetPFont{}{15} +\BText(65,45){% + \begin{minipage}{4cm} + \sffamily Here is boxed text in a + large size, including + mathematics: $\alpha^2$. + \end{minipage}% +} +\end{verbatim} +But if you use mathematics, the text may be more elegant if you use +the document font, which has matching fonts for text and mathematics. +Use of a sans-serif font (by \verb:\sffamily:) may be better in a diagram. +\end{minipage} +\vspace{4mm} + +%--#] Features : +%>>#] Text : +%>>#[ Options : + +\subsection{Options} +\label{sec:options} + +Almost all of axodraw2's line-drawing commands take optional +arguments. The form here is familiar from many standard \LaTeX{} +commands. The optional arguments are placed in square brackets after +the command name, and are made of a comma-separated list of items of +the form: \texttt{keyword} or \texttt{keyword=value}. The required +arguments are placed afterwards. + +Optional arguments can be used to set particular characteristics of a +line, e.g., whether it is dashed or has an arrow. They can also be +used to set some of the line's parameters, to be used instead of +default values. (The default values can be adjusted by commands +listed in Sec.\ \ref{sec:settings}. Those commands are useful for +adjusting parameters that apply to multiple lines, while the optional +arguments are useful for setting parameters for individual lines.) + +The original axodraw only had different command names to determine +whether lines were dashed, or had arrows, etc. The new version +retains these commands, +but now the basic commands +(\verb:\Line:, \verb:\Arc:, \verb:\Gluon:, etc) can also be treated as +generic commands, with the different varieties (dashed, double, and/or +with an arrow) being set by options. + +The same set of options are available for all types of line. However, +not all apply or are implemented for particular types of line. Thus, +\texttt{clockwise} is irrelevant for a straight line, while +\texttt{arrow} is not implemented for gluons, photons and zigzag +lines. Warnings are given for unimplemented features, while +inapplicable arguments are ignored. + +The full set of options. +\begin{center} +\begin{tabular}{ll} + color=\colorname & Set the line in this color. \\ + colour=\colorname & Same as color=\colorname. \\ + dash & Use a dashed line. \\ + dsize=\num & Set the dash size (when a line is dashed). \\ + dashsize=\num & Same as dsize=\num. \\ + double & Use a double line. \\ + sep=\num & Sets the separation for a double line. \\ + linesep=\num & Same as sep=\num. \\ + width=\num & Sets line width for this line only.\\[2mm] + clock & For arcs, makes the arc run clockwise. \\ + clockwise & For arcs, makes the arc run clockwise. \\[2mm] + arrow & Use an arrow.\\ + flip & If there is an arrow, its direction is flipped. \\ + + arrowpos=\num & The number should be between zero and one and\\ + & indicates where along the line the arrow should be. \\ + & 1 is at the end. 0.5 is halfway (the initial default).\\ + arrowaspect=\num & See Sec.\ \ref{sec:arrows}. \\ + arrowlength=\num & See Sec.\ \ref{sec:arrows}. \\ + arrowheight=\num & See Sec.\ \ref{sec:arrows}. \\ + arrowinset=\num & See Sec.\ \ref{sec:arrows}. \\ + arrowscale=\num & See Sec.\ \ref{sec:arrows}. \\ + arrowstroke=\num & See Sec.\ \ref{sec:arrows}. \\ + arrowwidth=\num & See Sec.\ \ref{sec:arrows}. \\ + inset=\num & Same as arrowinset.\\ +\end{tabular} +\end{center} +The options without an extra argument, e.g., \texttt{arrow}, are +actually of a boolean type. That is, they can also be used with a +suffix ``\texttt{=true}'' or ``\texttt{=false}'', e.g., +\texttt{arrow=true} or \texttt{arrow=false}. + +If an option is not provided, its default value is used. Defaults are +no dashes, no double lines, anticlockwise arcs, no arrow and if an +arrow is asked for, its position is halfway along the line. Other +arrow settings are explained in Sec.\ \ref{sec:arrows}. There are +also default values for dash size (3) and the separation of double +lines (2). + +The full set of the generic line commands with their syntax is +\begin{center} + \begin{tabular}{l} + \verb+\Line[options](x1,y1)(x2,y2)+ \\ + \verb+\Arc[options](x,y)(r,theta1,theta2)+ \\ + \verb+\Bezier[options](x1,y1)(x2,y2)(x3,y3)(x4,y4)+ \\ + \verb+\Gluon[options](x1,y1)(x2,y2){amplitude}{windings}+ \\ + \verb+\GluonArc[options](x,y)(r,theta1,theta2){amplitude}{windings}+ \\ + \verb+\GluonCirc[options](x,y)(r,phase){amplitude}{windings}+ \\ + \verb+\Photon[options](x1,y1)(x2,y2){amplitude}{windings}+ \\ + \verb+\PhotonArc[options](x,y)(r,theta1,theta2){amplitude}{windings}+ \\ + \verb+\ZigZag[options](x1,y1)(x2,y2){amplitude}{windings}+ \\ + \verb+\ZigZagArc[options](x,y)(r,theta1,theta2){amplitude}{windings}+ \\ + \end{tabular} +\end{center} +The applicability of the options is as follows +\begin{center} + \begin{tabular}{lcc} + & Arrow, etc & Clockwise \\ + \verb+\Line+ & Y & N \\ + \verb+\Arc+ & Y & Y \\ + \verb+\Bezier+ & Y & N \\ + \verb+\Gluon+ & N & N \\ + \verb+\GluonArc+ & N & Y \\ + \verb+\GluonCirc+ & N & N \\ + \verb+\Photon+ & N & N \\ + \verb+\PhotonArc+ & N & Y \\ + \verb+\ZigZag+ & N & N \\ + \verb+\ZigZagArc+ & N & Y \\ + \end{tabular} +\end{center} +The arrow options include those for setting the arrow dimensions. +Options not indicated in the last table apply to all cases. + +%{\sc The next options still have to be implemented, but it seems the most +%sensible thing to do.}\vspace{3mm} +% +%The third family is the one of the shapes: +% +%\begin{center} +%\begin{minipage}{14cm} +%\begin{verbatim} +%\Box[options](x1,y1)(x2,y2) +%\Tri[options](x1,y1)(x2,y2)(x3,y3) +%\Polygon[options]{(x1,y1)(x2,y2)...(xn,yn)} +%\Circ[options](x1,y1){radius} +%\Oval[options](x1,y1)(height,width)(rotation) +%\end{verbatim} +%\end{minipage} +%\end{center} +% +%\noindent The options here are: +%\begin{center} +%\begin{tabular}{ll} +% centered & For boxes: x1,y1 is the center. x2,y2 is width, +% height \\ +% blanked & Inside is blanked out. \\ +% inside & (Over)write only the inside. \\ +% color,line=$<$color$>$ & Main color. \\ +% filled,fill=$<$color$>$ & When both the outline and the inside are written. \\ +% gray,grayscale=\num & Inside is in gray. Filled overwrites this. \\ +% rotation=\num & Only for centered boxes: rotation angle. +%\end{tabular} +%\end{center} +%The options gray and filled imply blanked. Hence it is not needed to use +%blanked when either of those options is used. The default values are that +%none of these options are used. + +Some examples are: +\begin{verbatim} + \Line[double,sep=1.5,dash,dsize=4](10,10)(70,30) + \Line[double,sep=1.5,arrow,arrowpos=0.6](10,10)(70,30) +\end{verbatim} + +The options can also be used on the more explicit commands as extra +options. Hence it is possible to use +\begin{verbatim} + \DoubleLine[dash,dsize=4](10,10)(70,30){1.5} +\end{verbatim} +instead of the first line in the previous example. + +One may notice that some of the options are not accessible with the more +explicit commands. For example, it is possible to put arrows on B\'ezier +curves only by using the option `arrow' for the B\'ezier command. + +%>>#] Options : +%>>#[ Remarks about Gluons : +% +\subsection{Remarks about Gluons} +\label{sec:gluon.remarks} + +There are 12 commands that concern gluons. This allows much freedom in +developing one's own style. Gluons can be drawn as single solid lines, as +double lines, as dashed lines and as dashed double lines. + +Gluons have an amplitude and a number of windings. By varying these +quantities one may obtain completely different gluons as in: + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,90)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\Gluon(10,70)(80,70){3}{5} +\Gluon(10,50)(80,50){3}{9} +\Gluon(10,30)(80,30){5}{7} +\Gluon(10,10)(80,10){8}{9} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluons} +\verb:\Gluon(10,70)(80,70){3}{5}: \hfill \\ +\verb:\Gluon(10,50)(80,50){3}{9}: \hfill \\ +\verb:\Gluon(10,30)(80,30){5}{7}: \hfill \\ +\verb:\Gluon(10,10)(80,10){8}{9}: +\end{minipage}\vspace{4mm} + +One may change the orientation of the windings by reversing the +direction in which the gluon is drawn and/or changing the sign of the +amplitude: + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,90)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\DoubleGluon(10,70)(80,70){5}{7}{1.2} +\DoubleGluon(80,50)(10,50){5}{7}{1.2} +\DoubleGluon(10,30)(80,30){-5}{7}{1.2} +\DoubleGluon(80,10)(10,10){-5}{7}{1.2} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluonss} +\verb:\DoubleGluon(10,70)(80,70){5}{7}{1.2}: \hfill \\ +\verb:\DoubleGluon(80,50)(10,50){5}{7}{1.2}: \hfill \\ +\verb:\DoubleGluon(10,30)(80,30){-5}{7}{1.2}: \hfill \\ +\verb:\DoubleGluon(80,10)(10,10){-5}{7}{1.2}: +\end{minipage}\vspace{4mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,70)(-10,0)} +\AxoGrid(0,0)(10,10)(9,7){LightGray}{0.5} +\GluonArc(45,20)(40,20,160){5}{8} +\GluonArc(45,0)(40,20,160){-5}{8} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluonarcA} +\verb:\GluonArc(45,20)(40,20,160){5}{8}:\hfill \\ +\verb:\GluonArc(45,0)(40,20,160){-5}{8}:\hfill \\ +Here one can see that the sign of the amplitude gives a completely +different aspect to a gluon on an arc segment. +\end{minipage}\vspace{4mm} + +There are two ways of drawing a gluon circle. One is with the command +GluonCirc and the other is an arc of 360 degrees with the GluonArc command. +The second way has a natural attachment point, because the GluonArc +command makes gluons with a begin- and endpoint. \vspace{4mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-15,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\GluonCirc(40,40)(30,0){5}{16} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +%\label{gluoncirc} +\verb:\GluonCirc(40,40)(30,0){5}{16}:\hfill \\ +This is the `complete circle'. If one likes to attach one or more lines to +it one should take into account that the best places for this are at a +distance radius+amplitude from the center of the circle. One can rotate the +circle by using the phase argument. +\end{minipage}\vspace{4mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-15,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\GluonArc(40,40)(30,0,360){5}{16} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{gluonarc360} +\verb:\GluonArc(40,40)(30,0,360){5}{16}:\hfill \\ +In the 360 degree arc there is a natural point of attachment. Of course +there is only one such point. If one needs more than one such point one +should use more than one arc segment. +\end{minipage}\vspace{4mm} + +Some examples are: + +\begin{center} \begin{axopicture}{(460,60)(0,0)} +\Gluon(7,30)(27,30){3}{3} +\GluonCirc(50,30)(20,0){3}{16} +\Gluon(73,30)(93,30){3}{3} +\Vertex(27,30){1.5} +\Vertex(73,30){1.5} +% +\Gluon(110,30)(130,30){3}{3} +\GluonArc(150,30)(20,0,180){3}{8} +\GluonArc(150,30)(20,180,360){3}{8} +\Gluon(170,30)(190,30){3}{3} +\Vertex(130,30){1.5} +\Vertex(170,30){1.5} +% +\Gluon(210,30)(230,30){3}{3} +\GluonArc(250,30)(20,0,180){-3}{8} +\GluonArc(250,30)(20,180,360){-3}{8} +\Gluon(270,30)(290,30){3}{3} +\Vertex(230,30){1.5} +\Vertex(270,30){1.5} +% +\DashLine(310,30)(330,30){3} +\GluonArc(350,30)(20,-180,180){3}{16} +\Vertex(330,30){1.5} +% +\DashLine(387,30)(407,30){3} +\GluonCirc(430,30)(20,0){3}{16} +\Vertex(407,30){1.5} +% +\end{axopicture} \end{center} +This picture was generated with the code: +\begin{verbatim} +\begin{center} \begin{axopicture}{(460,60)(0,0)} + \Gluon(7,30)(27,30){3}{3} + \GluonCirc(50,30)(20,0){3}{16} + \Gluon(73,30)(93,30){3}{3} + \Vertex(27,30){1.5} + \Vertex(73,30){1.5} + \Gluon(110,30)(130,30){3}{3} + \GluonArc(150,30)(20,0,180){3}{8} + \GluonArc(150,30)(20,180,360){3}{8} + \Gluon(170,30)(190,30){3}{3} + \Vertex(130,30){1.5} + \Vertex(170,30){1.5} + \Gluon(210,30)(230,30){3}{3} + \GluonArc(250,30)(20,0,180){-3}{8} + \GluonArc(250,30)(20,180,360){-3}{8} + \Gluon(270,30)(290,30){3}{3} + \Vertex(230,30){1.5} + \Vertex(270,30){1.5} + \DashLine(310,30)(330,30){3} + \GluonArc(350,30)(20,-180,180){3}{16} + \Vertex(330,30){1.5} + \DashLine(387,30)(407,30){3} + \GluonCirc(430,30)(20,0){3}{16} + \Vertex(407,30){1.5} +\end{axopicture} \end{center} +\end{verbatim} + +%>>#] Remarks about Gluons : +%>>#[ Arrows : + +\subsection{Remarks about arrows} +\label{sec:arrows} + +%--#[ General : + +The old Axodraw arrows were rather primitive little triangles. The JaxoDraw +program has introduced fancier arrows which the user can also customize. +There are parameters connected to this as shown in the figure: +\begin{center} +\begin{axopicture}{(150,100)(0,0)} +\AxoGrid(0,0)(10,10)(15,10){LightGray}{0.5} +\SetWidth{3} +%\Line(10,50)(130,50) +%\FilledPolygon{(140,50)(90,90)(105,50)(90,10)}{White} +%\Polygon{(140,50)(90,90)(105,50)(90,10)}{Black} +%\SetWidth{0.5} +%\LongArrow(85,50)(85,90) +%\LongArrow(90,5)(105,5) +%\LongArrow(90,95)(140,95) +%\SetPFont{Helvetica}{9} +%\PText(110,85)(0)[l]{Length} +%\PText(76,71)(90)[c]{Width} +%\PText(110,5)(0)[l]{Inset} +\Line[arrow,arrowinset=0.3,arrowaspect=1,arrowwidth=40,arrowpos=1, + arrowstroke=3](10,50)(100,50) +\SetWidth{0.5} +\LongArrow(55,50)(55,90) +\LongArrow(60,5)(84,5) +\LongArrow(60,95)(140,95) +\SetPFont{Helvetica}{9} +\PText(100,85)(0)[l]{Length} +\PText(46,71)(90)[c]{Width} +\PText(90,5)(0)[l]{Inset} +\end{axopicture}\vspace{2mm} \\ +\verb:\Line[arrow,arrowinset=0.3,arrowaspect=1,arrowwidth=40,arrowpos=1,:\\ +\verb:arrowstroke=3](10,50)(100,50): +\end{center} +The full set of parameters is: +\begin{description} +\item[aspect] A multiplicative parameter when the length is calculated +from the width. The normal formula is: +$\mbox{length}=2\times \mbox{width}\times \mbox{aspect}$. +\item[inset] The fraction of the length that is taken inward. +\item[length] The full length of the arrowhead. +\item[position] The position of the arrow in the line as a fraction of the +length of the line. +\item[scale] A scale parameter for the complete arrowhead. +\item[stroke] The width of the line that makes up the arrowhead. If the +value is not set (default value is zero) the arrow is filled and overwrites +whatever was there. In the case of a stroke value the contents are +overwritten in the background color. +\item[width] The half width of the arrowhead. +\end{description} +The parameters can be set in two ways. One is with one of the commands +\begin{center} +\begin{tabular}{ll} +\verb:\SetArrowScale{number}: & Initial value is 1. \\ +\verb:\SetArrowInset{number}: & Initial value is 0.2 \\ +\verb:\SetArrowAspect{number}: & Initial value is 1.25 \\ +\verb:\SetArrowPosition{number}: & Initial value is 0.5 \\ +\verb:\SetArrowStroke{number}: & Initial value is 0 \\ +\end{tabular} \vspace{2mm} \\ +\end{center} +(A complete list of commands for setting defaults is in +Sec.\ \ref{sec:settings}.) +These commands determine settings that will hold for all following +commands, up to the end of whatever \LaTeX{} or \TeX{} grouping the +default setting is given in. E.g., setting a default value inside an +\texttt{axopicture} environment sets it until the end of the +environment only. (Thus the settings obey the normal rules of +\LaTeX{} for scoping.) + +The other way is to use one or more of these parameters as options in a +command that uses an arrow. The general use of options is in Sec.\ +\ref{sec:options}. The options that are available are +\begin{center} +\begin{tabular}{ll} + arrow & initial default=false \\ + arrowscale=\num & initial default=1 \\ + arrowwidth=\num & initial default=0 \\ + arrowlength=\num & initial default=0 \\ + arrowpos=\num & initial default=0.5 \\ + arrowinset=\num & initial default=0.2 \\ + arrowstroke=\num & initial default=0 \\ + arrowaspect=\num & initial default=1.25 \\ + flip & initial default=false +\end{tabular} +\end{center} +The arrow option tells the program to draw an arrow. Without it no +arrow will be drawn. The flip option indicates that the direction of +the arrow should be reversed from the `natural' direction. + +When +neither the width nor the length are specified, but instead both are +given as zero, they are computed from the line width (and the line +separation when there is a double line). The formula is: +\begin{eqnarray} + \mbox{Arrowwidth} & = & + 1.2 \times \left( \mbox{linewidth} + + 0.7 \times \mbox{separation} + + 1 + \right) + \times \mbox{arrowscale}, +\\ +\label{arrowlength} + \mbox{Length} & = & + 2 \times \mbox{arrowwidth} \times \mbox{arrowaspect}. +\end{eqnarray} +%If however $\mbox{linewidth} + \frac{1}{4} \times \mbox{separation} < +%0.5$ the formula for the arrow width becomes $\mbox{arrowwidth} = 2.5 +%\times \mbox{arrowscale}$. +If, however, $1.2 \times(\mbox{linewidth}+0.7\times\mbox{separation}+1)$ is less +than 2.5, the formula for the arrow width becomes +$\mbox{arrowwidth}=2.5\times\mbox{arrowscale}$. + +If only one of the arrowwidth or the arrowlength parameters is zero, +it is computed from the other non-zero parameter using formula +(\ref{arrowlength}). When both are non-zero, those are the values that +are used. + +The position of the arrowhead is a bit tricky. The arrowpos parameter is a +fraction of the length of the line and indicates the position of the center +of the arrowhead. This means that when arrowpos is one, the arrowhead +sticks out beyond the end of the line by half the arrowlength. When for +instance the line width is 0.5, the default length of the arrowhead +defaults to 6.25. Hence if one would like to compensate for this one should +make the line 3.125 points shorter. Usually 3 pt will be sufficient. + +Because of backward compatibility axodraw2 has many individual commands for +lines with arrows. We present them here, together with some `options' +varieties.\vspace{4mm} + +%--#] General : +%--#[ ArrowLine : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,80)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\Line[arrow,arrowscale=2](10,70)(80,70) +\Line[arrow,arrowpos=0.8,flip](10,50)(80,50) +\Line[arrow](10,30)(80,30) +\ArrowLine(10,10)(80,10) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowline} +\verb:\Line[arrow,arrowscale=2](10,70)(80,70): \hfill \\ +\verb:\Line[arrow,arrowpos=0.8,flip](10,50)(80,50): \hfill \\ +\verb:\Line[arrow](10,30)(80,30): \hfill \\ +\verb:\ArrowLine(10,10)(80,10): \hfill \\ +The default position for the arrow is halfway (arrowpos=0.5). With the line +command and the options we can put the arrow in any position. +\end{minipage}\vspace{4mm} + +%--#] ArrowLine : +%--#[ LongArrow : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,60)(-10,0)} +\AxoGrid(0,0)(10,10)(9,6){LightGray}{0.5} +\Line[arrow,arrowpos=1](10,30)(80,30) +\LongArrow(10,10)(80,10) +\SetWidth{4} +\LongArrow[arrowscale=0.8](10,50)(70,50) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{longarrow} +\verb:\Line[arrow,arrowpos=1](10,30)(80,30): \hfill \\ +\verb:\LongArrow(10,10)(80,10): \hfill \\ +\verb:\SetWidth{4}: \hfill \\ +\verb:\LongArrow[arrowscale=0.8](10,50)(70,50): \hfill \\ +The \verb:\LongArrow: command just places the arrowhead at the end of the +line. The size of the arrowhead is a function of the linewidth. +\end{minipage}\vspace{4mm} + +%--#] LongArrow : +%--#[ ArrowDoubleLine : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,100)(-10,0)} +\AxoGrid(0,0)(10,10)(9,10){LightGray}{0.5} +\SetArrowStroke{1} +\Line[arrow,arrowpos=1,double,sep=5,arrowscale=1.3](10,90)(75,90) +\Line[arrow,arrowpos=1,double,sep=2,arrowscale=1.5](10,70)(80,70) +\Line[arrow,arrowpos=1,double,sep=2](10,50)(80,50) +\Line[arrow,double,sep=2](10,30)(80,30) +\ArrowDoubleLine(10,10)(80,10){2} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowdoubleline} +\verb:\SetArrowStroke{1}: \hfill \\ +\verb:\Line[arrow,arrowpos=1,double,sep=5,arrowscale=1.3]: \hfill \\ + \verb: (10,90)(75,90): \hfill \\ +\verb:\Line[arrow,arrowpos=1,double,sep=2,arrowscale=1.5]: \hfill \\ + \verb: (10,70)(80,70): \hfill \\ +\verb:\Line[arrow,arrowpos=1,double,sep=2](10,50)(80,50): \hfill \\ +\verb:\Line[arrow,double,sep=2](10,30)(80,30): \hfill \\ +\verb:\ArrowDoubleLine(10,10)(80,10){2}: \hfill \\ +As one can see, the arrows also work with double lines. +\end{minipage}\vspace{4mm} + +%--#] ArrowDoubleLine : +%--#[ ArrowDashLine : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,80)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\Line[arrow,arrowpos=0.3,dash,dsize=3,arrowscale=1.5](10,70)(80,70) +\DashArrowLine(10,50)(80,50){3} +\Line[arrow,dash,dsize=3](10,30)(80,30) +\ArrowDashLine(10,10)(80,10){3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowdashline} +\verb:\Line[arrow,arrowpos=0.3,dash,dsize=3,arrowscale=1.5]: \\ + \verb:(10,70)(80,70): \\ +\verb:\DashArrowLine(10,50)(80,50){3}: \\ +\verb:\Line[arrow,dash,dsize=3](10,30)(80,30): \\ +\verb:\ArrowDashLine(10,10)(80,10){3}: \\ +We have not taken provisions for the dashes to be centered in the +arrowhead, because at times that is nearly impossible. The commands +\verb:\ArrowDashLine: and \verb:\DashArrowLine: are identical. +\end{minipage}\vspace{4mm} + +%--#] ArrowDashLine : +%--#[ ArrowDashDoubleLine : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,80)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\SetArrowStroke{0.5} +\Line[arrow,arrowpos=1,dash,dsize=3,double,sep=1.5,arrowscale=1.5](10,70)(80,70) +\DashArrowDoubleLine(10,50)(80,50){1.5}{3} +\Line[arrow,dash,dsize=3,double,sep=1.5](10,30)(80,30) +\ArrowDashDoubleLine(10,10)(80,10){1.5}{3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowdashdoubleline} +\verb:\SetArrowStroke{0.5}: \\ +\verb:\Line[arrow,arrowpos=1,dash,dsize=3,double: \\ + \verb:,sep=1.5,arrowscale=1.5](10,70)(80,70): \\ +\verb:\DashArrowDoubleLine(10,50)(80,50){1.5}{3}: \\ +\verb:\Line[arrow,dash,dsize=3](10,30)(80,30): \\ +\verb:\ArrowDashDoubleLine(10,10)(80,10){1.5}{3}: \\ +The \verb:\ArrowDashDoubleLine: and \verb:\DashArrowDoubleLine: +commands are identical. +\end{minipage}\vspace{4mm} + +%--#] ArrowDashDoubleLine : +%--#[ LongArrowDashLine : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,80)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\Line[arrow,arrowpos=0,dash,dsize=3,arrowscale=1.5,flip](10,70)(80,70) +\DashLongArrowLine(10,50)(80,50){3} +\Line[arrow,arrowpos=1,dash,dsize=3](10,30)(80,30) +\LongArrowDashLine(10,10)(80,10){3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{longarrowdashline} +\verb:\Line[arrow,arrowpos=0,dash,dsize=3,arrowscale=1.5: \\ + \verb:,flip](10,70)(80,70): \\ +\verb:\DashLongArrowLine(10,50)(80,50){3}: \\ +\verb:\Line[arrow,arrowpos=1,dash,dsize=3](10,30)(80,30): \\ +\verb:\LongArrowDashLine(10,10)(80,10){3}: \\ +The commands +\verb:\LongArrowDashLine:, \verb:\DashLongArrowLine:, +\verb:\LongArrowDash: and \verb:\DashLongArrow: are identical. +\end{minipage}\vspace{4mm} + +%--#] LongArrowDashLine : +%--#[ ArrowArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,140)(-10,0)} +\AxoGrid(0,0)(10,10)(9,14){LightGray}{0.5} +\Arc[arrow,arrowpos=1,clock](45,95)(40,160,20) +\LongArrowArcn(45,80)(40,160,20) +\Arc[arrow,arrowpos=0.5,clock](45,65)(40,160,20) +\ArrowArcn(45,50)(40,160,20) +\Arc[arrow,arrowpos=1](45,35)(40,20,160) +\LongArrowArc(45,20)(40,20,160) +\Arc[arrow,arrowpos=0.5](45,5)(40,20,160) +\ArrowArc(45,-10)(40,20,160) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowarc} +\verb:\Arc[arrow,arrowpos=0,flip](45,95)(40,20,160): \\ +\verb:\LongArrowArcn(45,80)(40,20,160): \\ +\verb:\Arc[arrow,arrowpos=0.5](45,65)(40,20,160): \\ +\verb:\ArrowArcn(45,50)(40,20,160): \\ +\verb:\Arc[arrow,arrowpos=1](45,35)(40,20,160): \\ +\verb:\LongArrowArc(45,20)(40,20,160): \\ +\verb:\Arc[arrow,arrowpos=0.5](45,5)(40,20,160): \\ +\verb:\ArrowArc(45,-10)(40,20,160): \\ +The \verb:Arc: and the \verb:CArc: commands are identical. +\end{minipage}\vspace{4mm} + +%--#] ArrowArc : +%--#[ ArrowDashArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,110)(-10,0)} +\AxoGrid(0,0)(10,10)(9,11){LightGray}{0.5} +\Arc[arrow,dash,dsize=3,arrowpos=0.5,clock](45,65)(40,160,20) +\ArrowDashArcn(45,50)(40,160,20){3} +\Arc[arrow,dash,dsize=3,arrowpos=1](45,35)(40,20,160) +\LongArrowDashArc(45,20)(40,20,160){3} +\Arc[arrow,dash,dsize=3,arrowpos=0.5](45,5)(40,20,160) +\ArrowDashArc(45,-10)(40,20,160){3} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowdasharc} +\verb:\Arc[arrow,dash,dsize=3,arrowpos=0.5]: \\ + \verb:(45,65)(40,20,160): \\ +\verb:\ArrowDashArcn(45,50)(40,20,160){3}: \\ +\verb:\Arc[arrow,dash,dsize=3,arrowpos=1]: \\ + \verb:(45,35)(40,20,160): \\ +\verb:\LongArrowDashArc(45,20)(40,20,160){3}: \\ +\verb:\Arc[arrow,dash,dsize=3,arrowpos=0.5]: \\ + \verb:(45,5)(40,20,160): \\ +\verb:\ArrowDashArc(45,-10)(40,20,160){3}: \\ +The \verb:DashArrowArc: and the \verb:ArrowDashArc: commands are identical. +So are the commands \verb:DashArrowArcn: and \verb:ArrowDashArcn:. +\end{minipage}\vspace{4mm} + +%--#] ArrowDashArc : +%--#[ ArrowDashDoubleArc : + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(90,80)(-10,0)} +\AxoGrid(0,0)(10,10)(9,8){LightGray}{0.5} +\Arc[arrow,dash,dsize=3,double,sep=1.5,arrowpos=0.5](45,35)(40,20,160) +\ArrowDashDoubleArc(45,20)(40,20,160){1.5}{3} +\Arc[arrow,double,sep=1.5,arrowpos=0.5](45,5)(40,20,160) +\ArrowDoubleArc(45,-10)(40,20,160){1.5} +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowdashdoublearc} +\verb:\Arc[arrow,dash,dsize=3,double,sep=1.5: \\ + \verb:,arrowpos=0.5](45,35)(40,20,160): \\ +\verb:\ArrowDashDoubleArc(45,20)(40,160,20){1.5}{3}: \\ +\verb:\Arc[arrow,double,sep=1.5,arrowpos=0.5]: \\ + \verb:(45,5)(40,20,160): \\ +\verb:\ArrowDoubleArc(45,-10)(40,20,160){1.5}: \\ +Other commands involving Long do not exist. The options can take care of +their functionality. +\end{minipage}\vspace{4mm} + +%--#] ArrowDashDoubleArc : +%--#[ Bezier : + +Computing the position of the arrow in a B\'ezier curve is a bit complicated. +Let us recall the definition of a cubic B\'ezier curve: +\begin{eqnarray} + x & = & x_0 (1-t)^3 + 3 x_1 t (1-t)^2 + 3 x_2 t^2 (1-t) + x_3 t^3 + \nonumber \\ + y & = & y_0 (1-t)^3 + 3 y_1 t (1-t)^2 + 3 y_2 t^2 (1-t) + y_3 t^3 +\end{eqnarray} +Computing the length of the curve is done with the integral +\begin{eqnarray} + L & = & \int_0^1 dt + \sqrt{ \left( \frac{dx}{dt} \right)^2 + \left( \frac{dy}{dt} \right )^2 }, +\end{eqnarray} +which is an integral over the square root of a quartic polynomial. This we +do with a 16 point Gaussian quadrature and it gives us more than enough +accuracy\footnote{We need to compute the length of the B\'ezier curve also +when we want to put a dash pattern on it. The exact dash size is determined +such that an integer number of patterns fits in the line.}. Let us assume +now that we want the arrow at 0.6 of the length. To find the exact fraction +of the length involves finding the upper limit of the integral for which +the length is $0.6 L$. This requires an iteration procedure till we have a +reasonable accuracy for the position $(x,y)$. After that we have to calculate +the derivative in this point as well. + +Because the B\'ezier curves are new commands in axodraw2 there is no need for +backwards compatibility in the use of arrows. Hence all arrow commands are +done by means of the options. Some examples are: +\vspace{4mm} + +\noindent +\begin{minipage}{3.83cm} +\begin{axopicture}{(80,80)(-15,0)} +\AxoGrid(0,0)(10,10)(8,8){LightGray}{0.5} +\Bezier[arrow](10,10)(30,30)(10,50)(30,70) +\Bezier[arrow,dash,dsize=3](30,10)(50,30)(30,50)(50,70) +\Bezier[arrow,arrowpos=1,double,sep=1,arrowstroke=0.5](50,10)(70,30)(50,50)(70,70) +\end{axopicture} +\end{minipage} +\begin{minipage}{11.5cm} +\label{arrowbezier} +\verb:\Bezier[arrow](10,10)(30,30)(10,50)(30,70): \\ +\verb:\Bezier[arrow,dash,dsize=3](30,10)(50,30): \\ + \verb:(30,50)(50,70): \\ +\verb:\Bezier[arrow,arrowpos=1,double,sep=1,arrowstroke: \\ + \verb:=0.5](50,10)(70,30)(50,50)(70,70): +\end{minipage}\vspace{4mm} + +%--#] Bezier : +%>>#] Arrows : +%>>#[ Settings : + +\subsection{Units and scaling} +\label{sec:units} + +When you have constructed a diagram, you may need to change its scale, +to make it larger or smaller. Axodraw2 provides ways of doing this, +for scaling diagrams without recoding all the individual coordinates. +However the requirements for the nature of the scaling change between +different cases. For example, suppose a diagram is designed for use in +a journal article and you wish to use it in the slides for a seminar. +Then you will want to enlarge both the geometric size of the diagram's +objects and the text labels it contains. But if you wish to use a +scaled diagram in another place in a journal article, you will wish to +scale its lines etc, but will probably not wish to scale the text (to +preserve its legibility). + +Axodraw2 therefore provides tools for the different situations, so we +will now explain what to do. The commands to achieve this all appear +in the list of parameter-setting commands in Sec.\ \ref{sec:settings}. + + +\subsubsection{Scaling for slides} + +Suppose the original diagram is +\begin{center} +\begin{minipage}{10cm} +\begin{verbatim} + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{verbatim} +\end{minipage} +\end{center} +to give +\begin{center} + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{center} +Then you could double the scale of the diagram by +\begin{center} +\begin{minipage}{10cm} +\begin{verbatim} + \SetScale{2} + \fontsize{24}{26}\selectfont + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{verbatim} +\end{minipage} +\end{center} +to get +\begin{center} + \SetScale{2} + \fontsize{24}{26}\selectfont + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{center} +We have changed the size of the document font, as would be appropriate +for a make slides for a presentation; this we did by the +\verb+\fontsize+ command. The arc and the space inserted +in the document for the diagram have scaled up. The label inserted by +the \verb:\Text: command has changed to match the document font. The +postscript text in the \verb:\CText: was specified to be at +$\unit[12]{pt}$, but is now scaled up also. + +The above behavior is what axodraw2 does by default, and is what v.\ 1 +did. + + +\subsubsection{Scaling within article} + +If you wanted to make an enlarged figure in a journal article, you +would not change the document font. But the obvious modification to +the previous example is +\begin{center} +\begin{minipage}{10cm} +\begin{verbatim} + \SetScale{2} + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{verbatim} +\end{minipage} +\end{center} +which gives +\begin{center} + \SetScale{2} + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{center} +The label $\alpha P_1$ is now not enlarged, since it copies the +behavior of the document font. But the postscript text is enlarged, +which is probably undesirable. If you were scaling down the diagram +instead of scaling it up, the situation would be worse, because the +postscript font would be difficult to read. + +So in this situation, of scaling the diagram while keeping the +document font intact, you probably also want to leave unchanged the +size of the postscript font. You can achieve this by the +\verb:\PSTextScalesLikeGraphicsfalse: command: +\begin{center} +\begin{minipage}{10cm} +\begin{verbatim} + \SetScale{2} + \PSTextScalesLikeGraphicsfalse + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{verbatim} +\end{minipage} +\end{center} +\begin{center} + \SetScale{2} + \PSTextScalesLikeGraphicsfalse + \SetPFont{Helvetica-Oblique}{12} + Document text. Then diagram: + \begin{axopicture}(60,43) + \Arc[arrow](30,0)(30,0,180) + \Text(30,33)[b]{$\alpha P_1$} + \CText(30,10){Red}{Yellow}{Arc} + \end{axopicture} +\end{center} + +To achieve this on a document-wide basis, which is probably what you +want, you can use the \texttt{PStextScalesIndependently} option when you +load axodraw2 --- see Sec.\ \ref{sec:invoke}. + +Nevertheless, if you turn off the default scaling of postscript text, +%you may still want to scale text. To do this you can use the +you may still want to scale text. For this you can use the +\verb:\SetTextScale: command, as in \verb:\SetTextScale{1.2}:. This +only has an effect when you have turned off the scaling of postscript +text with graphics objects; but then it applies to \TeX{} text +inserted by axodraw2's \verb:\Text: and \verb:\rText: commands, as +well text inserted by axodraw2's ``postscript-text'' commands. + +If you are confused by the above, we recommend experimentation to +understand how to achieve the effects that you specifically need. We +could have made the set of commands and options simpler, but only at +the expense of not being able to meet the demands of the different +plausible situations that we could imagine and have to deal with +ourselves. + +\subsubsection{Canvas and object scales} + +When you use \verb:\SetScale: outside an \verb:axopicture: +environment, as above, the scaling applies to both the axodraw2 +objects and the space inserted for the \texttt{axopicture} environment +in the document, as is natural. But you may find you need to scale a +subset of objects inside the diagram, e.g., +\begin{center} + \begin{minipage}{10cm} + \verb:\begin{axopicture}:(\dots)\\ + \hspace*{1cm} (First block)\\ + \verb:\SetScale{0.5}:\\ + \hspace*{1cm} (Second block)\\ + \verb:\end{axopicture}: + \end{minipage} +\end{center} +In this case, the units for specifying the objects in the second block +are different from those for specifying the \verb:axopicture: +environment's size (as well as the first block of objects). We thus +distinguish object units from canvas units, where ``canvas'' refers to +the \verb:axopicture: environment as a whole. + +Another complication is that the \LaTeX{} \verb+picture+ environment +has is own \verb:\unitlength: parameter. In v.\ 1 of axodraw, the +canvas scale was determined by \LaTeX's \verb:\unitlength:. But there +was an independent unit for the object scale; this was the one +determined by axodraw's \verb:\SetScale: command. Also, not all +objects used the object scale. The situation therefore got quite +confusing. In v.\ 1, if, as is often natural, you wished to scale the +canvas as well as the objects, you would have needed to set \LaTeX's +\verb:\unitlength: parameter as well as using axodraw's +\verb:\SetScale: command. + +So now we have arranged things so that the canvas and object scales +are tied by default, provided that you use axodraw2's \verb:\SetScale: +command, and that axodraw diagrams are inside \verb+axopicture+ +environments (in contrast to the \verb+picture+ environment used in +the original axodraw). +However, it may be necessary to keep backward compatibility in some +cases, and we weren't certain that the new behavior is exactly what is +always desired. So in axodraw2, we have provided three choices, given +by the \texttt{canvasScaleIs1pt}, \texttt{canvasScaleIsObjectScale}, +and \texttt{canvasScaleIsUnitLength} options when loading axodraw2 --- +see Sec.\ \ref{sec:invoke}. Naturally, +\texttt{canvasScaleIsObjectScale} is the default. If you wish to +change the setting mid-document, there are corresponding commands --- +Sec.\ \ref{sec:settings}. + + + +\subsection{Settings} +\label{sec:settings} + +Axodraw2 has a number of parameters that can be set by the user. The +parameters include defaults for line types, dimensions, etc. The +parameters can be set either inside the axopicture environment or +outside. If they are set outside they modify the default value for +subsequent pictures. If set inside they only affect the current +picture. (In general, the parameters obey the usual rules for the +scope of \LaTeX{} variables.) In many cases, the parameters provide +default values for a command to draw an object and can be overridden +for a single object by using an optional parameter in invoking the +command for the object. + +The unit for lengths is the current object scale, as set by the +\verb+\SetScale+ command. + +\break + +The parameter-setting commands are: +%\begin{center} +%\def\arraystretch{1.4} +%% +%% See preamble for definition of \name +%\def\descr#1#2{% +% % #1 = command-syntax, #2 = description +% \name{#1} & #2\\ +% \hline +%} +%\def\descrL#1#2{% +% % #1 = command-syntax, #2 = description +% % Set #1 on separate line +% \multicolumn{2}{|l|}{\name{#1}} \\ +% & #2\\ +% \hline +%} +%\catcode`\#=13 +%\def#{\#} +%% +%\begin{longtable}{|p{5cm}|p{10.2cm}|} +%\hline +% Command & Commentary +%\\ +%\hline +%% +%\descr{SetLineSep\{\#1\}}{ +% This sets the default separation of double lines. Its initial value +% is 2. +%} +%% +%\descr{SetDashSize\{\#1\}}{ +% This sets the default size for the size of the dashes of dashed +% lines. Its initial value is 3. +%} +%% +%\descr{SetWidth\{\#1\}}{ +% This sets the default width of lines. Its initial value is 1. +%} +%% +%\descr{SetScale\{\#1\}}{ +% This sets a scale factor. +% This factor applies a magnification factor to all +% axodraw2 graphics objects. When the setting that +% postscript-text-scales-like-graphics is set (as is true by +% default), it also applies to axodraw2's ``postscript-text'' +% writing commands (\name{PText}, \name{BText}, etc), but not to +% its \TeX{}-text commands (\name{Text} etc). The initial scale +% factor is unity. +%} +%% +%\descr{SetTextScale\{\#1\}}{ +% This factor applies a magnification factor to all +% axodraw2 text objects, but \emph{only when} the setting that +% postscript-text-scales-like-graphics is turned off. +%} +%% +%\descr{SetOffset(\#1,\#2)}{ +% Sets an offset value +% for all commands of +% axodraw2. Its value is not affected by the scale variable. +%} +%% +%\descr{SetScaledOffset(\#1,\#2)}{ +% Sets an offset for +% all commands of axodraw2. This +% offset is affected by the scale factor. +%} +%% +%\descr{SetColor\{\#1\}}{ +% Sets the named color, +% for both axodraw2 objects and regular text. See Sec.\ +% \ref{sec:colors} for details on using color with axodraw2. +%} +%% +%\descr{textRed}{ +% Alternative command for setting named a color +% for both axodraw2 objects and regular text. See Sec.\ +% \ref{sec:colors} for details on using color with axodraw2. +% There is one such command for each axodraw2 named color. +%} +%% +%\descr{SetPFont\{\#1\}\{\#2\}}{ +% Sets the Postscript +% font, and its size in units of points. See Sec.\ \ref{sec:PSText} +% for the commands that use this font, for a table of the names of +% the fonts. An empty first argument, instead of a font name, (as in +% \name{SetPFont\{\}\{20\}} indicates that the normal document font is +% to be used at the indicated size. An empty second argument, +% instead of the font size, (as in \name{SetPFont\{Helvetica\}\{\}} or +% \name{SetPFont\{\}\{\}}) indicates that the font size is to be +% \LaTeX's document font size at the time the text-making command is +% executed. +%} +%% +%\descr{SetArrowScale\{\#1\}}{ +% A scale parameter for the +% entire head of an arrow. +%} +%% +%\descr{SetArrowInset\{\#1\}}{ +% See Sec.\ \ref{sec:arrows}. +%} +%% +%\descr{SetArrowAspect\{\#1\}}{ +% See Sec.\ \ref{sec:arrows}. +%} +%% +%\descr{SetArrowPosition\{\#1\}}{ +% Determines where the +%arrowhead is on a line. The position is the fraction of the length of the +%line. +%} +%% +%\descr{SetArrowStroke\{\#1\}}{ +% This parameter determines the linewidth of the arrowhead if it is just +% outlined. Its initial value is zero (filled arrowhead). +%} +%% +%\descr{canvasScaleOnept}{ +% Sets canvas scale to $\unit[1]{pt}$. +%} +%% +%\descr{canvasScaleObjectScale}{ +% Sets canvas scale to equal the value set by \name{SetScale} in +% units of points. This is the initial default of axodraw2, +% unless overridden. +%} +%% +%\descr{canvasScaleUnitLength}{ +% The canvas scale is the same as \LaTeX's length parameter +% \name{unitlength}. +%} +%% +%\descrL{PSTextScalesLikeGraphicsfalse}{ +% Text drawn by all of Axodraws's text commands scales with the +% factor set by \name{SetTextScale}. +% See Sec.\ \ref{sec:text}. +%} +%% +%\descrL{PSTextScalesLikeGraphicstrue}{ +% (Default setting.) Text drawn by Axodraw's postscript-text +% commands scales with the same factor as graphics objects, as set +% by \name{SetScale}. Text drawn by Axodraw's \TeX{}-text +% commands is unscaled. +% See Sec.\ \ref{sec:text}. +%} +%\end{longtable} +%\end{center} +\begin{center} +\def\arraystretch{1.4} +% +% See preamble for definition of \name +\def\descr#1#2{% + % #1 = command-syntax, #2 = description + \name{#1} & #2\\ + \hline +} +\def\descrL#1#2{% + % #1 = command-syntax, #2 = description + % Set #1 on separate line + \multicolumn{2}{|l|}{\name{#1}} \\ + & #2\\ + \hline +} +\def\category#1{% + % #1 = name of category + \multicolumn{2}{l}{#1:} + \\ + \hline +} +\catcode`\#=13 +\def#{\#} +% +\begin{longtable}{|p{5cm}|p{10.2cm}|} +\hline +\endfirsthead + Command & Commentary +\\ +\hline +%==================== +\category{Lines} +% +\descr{SetDashSize\{\#1\}}{ + This sets the default size for the size of the dashes of dashed + lines. Its initial value is 3. +} +% +\descr{SetLineSep\{\#1\}}{ + This sets the default separation of double lines. Its initial value + is 2. +} +% +\descr{SetWidth\{\#1\}}{ + This sets the default width of lines. Its initial value is 0.5. +} +%==================== +\category{Arrows} +% +\descr{SetArrowAspect\{\#1\}}{ + See Sec.\ \ref{sec:arrows}. +} +% +\descr{SetArrowInset\{\#1\}}{ + See Sec.\ \ref{sec:arrows}. +} +% +\descr{SetArrowPosition\{\#1\}}{ + Determines where the +arrowhead is on a line. The position is the fraction of the length of the +line. +} +% +\descr{SetArrowScale\{\#1\}}{ + A scale parameter for the + entire head of an arrow. +} +% +\descr{SetArrowStroke\{\#1\}}{ + This parameter determines the linewidth of the arrowhead if it is just + outlined. Its initial value is zero (filled arrowhead). +} +%==================== +\category{Scaling} +% +\descr{canvasScaleOnept}{ + Sets canvas scale to $\unit[1]{pt}$. +} +% +\descr{canvasScaleObjectScale}{ + Sets canvas scale to equal the value set by \name{SetScale} in + units of points. This is the initial default of axodraw2, + unless overridden. +} +% +\descr{canvasScaleUnitLength}{ + The canvas scale is the same as \LaTeX's length parameter + \name{unitlength}. +} +% +\descr{SetScale\{\#1\}}{ + This sets a scale factor. + This factor applies a magnification factor to all + axodraw2 graphics objects. When the setting that + postscript-text-scales-like-graphics is set (as is true by + default), it also applies to axodraw2's ``postscript-text'' + writing commands (\name{PText}, \name{BText}, etc), but not to + its \TeX{}-text commands (\name{Text} etc). The initial scale + factor is unity. +} +% +\descr{SetTextScale\{\#1\}}{ + This factor applies a magnification factor to all + axodraw2 text objects, but \emph{only when} the setting that + postscript-text-scales-like-graphics is turned off. +} +% +\descrL{PSTextScalesLikeGraphicsfalse}{ + Text drawn by all of Axodraws's text commands scales with the + factor set by \name{SetTextScale}. + See Sec.\ \ref{sec:text}. +} +% +\descrL{PSTextScalesLikeGraphicstrue}{ + (Default setting.) Text drawn by Axodraw's postscript-text + commands scales with the same factor as graphics objects, as set + by \name{SetScale}. Text drawn by Axodraw's \TeX{}-text + commands is unscaled. + See Sec.\ \ref{sec:text}. +} +% +%==================== +\category{Offsets} +% +\descr{SetOffset(\#1,\#2)}{ + Sets an offset value + for all commands of + axodraw2. Its value is not affected by the scale variable. +} +% +\descr{SetScaledOffset(\#1,\#2)}{ + Sets an offset for + all commands of axodraw2. This + offset is affected by the scale factor. +} +% +%==================== +\category{Color} +% +\descr{SetColor\{\#1\}}{ + Sets the named color, + for both axodraw2 objects and regular text. See Sec.\ + \ref{sec:colors} for details on using color with axodraw2. +} +% +\descr{textRed}{ + Alternative command for setting named a color + for both axodraw2 objects and regular text. See Sec.\ + \ref{sec:colors} for details on using color with axodraw2. + There is one such command for each axodraw2 named color. +} +%==================== +\category{Font} +% +\descr{SetPFont\{\#1\}\{\#2\}}{ + Sets the Postscript + font, and its size in units of points. See Sec.\ \ref{sec:PSText} + for the commands that use this font, for a table of the names of + the fonts. An empty first argument, instead of a font name, (as in + \name{SetPFont\{\}\{20\}} indicates that the normal document font is + to be used at the indicated size. An empty second argument, + instead of the font size, (as in \name{SetPFont\{Helvetica\}\{\}} or + \name{SetPFont\{\}\{\}}) indicates that the font size is to be + \LaTeX's document font size at the time the text-making command is + executed. +} +% +\end{longtable} +\end{center} + + +%>>#] Settings : +%>>#[ Colors : + +\subsection{Colors} +\label{sec:colors} + +\TeX{} and \LaTeX{} by themselves do not provide any means to set +colors in a document. Instead, one must use a suitable package to +achieve the effect; the current standard one is \file{color.sty}. +Such a package performs its work by passing graphics commands to the +viewable output file. Since axodraw also works in a similar fashion, +there is a potentiality for conflicts. + +Axodraw version 1, released in 1994, used the package +\file{colordvi.sty} for applying color to normal textual material, +and its own separate methods for applying color to its graphical +objects. They both defined the same convenient set of named colors +that could be used, but they had to be set separately for text and +graphics\footnote{The named colors corresponded to ones defined by the + \program{dvips} program.}. The \file{colordvi.sty} package also had +an important disadvantage that its color settings did not respect +\TeX{} grouping and \LaTeX{} environments, so that a color setting +made for text in an environment continued to apply after the end of +the environment. + +Since then, the available tools, notably in the powerful +\file{color.sty}, have greatly improved. But this has introduced +both real and potential incompatibilities with the older methods. +Note that \file{color.sty} is currently the most standard way for +implementing color, and is a required part of \LaTeX{} distributions, +as part of the graphics bundle. + +In the new version of axodraw, we have arranged to have compatibility +with \file{color.sty}, while allowing as much backward compatibility +as we could with the user interface from v.\ 1. We fully rely on +\file{color.sty} for setting color\footnote{Except for certain hard + wired settings in double lines and stroked arrows.}. But to keep +the best of the old methods, we have defined all the named colors that +were defined in the old version, together with a few extra ones. We +have also defined color-setting commands in the style of +\file{colordvi.sty}, but they now apply uniformly to both text and +axodraw graphical objects, and they respect \TeX{} and \LaTeX{} +grouping and environments. + +This results in some changes in behavior in certain situations. We +think the new behavior is more natural from the user's point of view; +but it is a change. + +There are two classes of graphics-drawing command in axodraw. One +class has no explicit color argument, and uses the currently set +color; the line-drawing commands are typical of these. Other commands +have explicit color arguments, and these arguments are named colors. +The named colors are a union of those axodraw defines, with those +defined by \file{color.sty} together with any further ones defined +by the user. + +\subsubsection{How to use colors} + +Axodraw works with named colors --- see Sec.\ \ref{sec:defined.colors} +--- which are a standard set of 68 originally defined by the \program{dvips} +program and the \file{colordvi.sty}, plus 5 extra colors defined in +axodraw2. (In addition there are several named colors that are +normally defined by default by \file{color.sty}, and that can also +be used.) + +To use them we have several possibilities to specify colors. Which to +use is mostly a matter of user preference or convenience. +\begin{itemize} + +\item The axodraw command \verb+\SetColor{colorname}+: sets the color + to be the named color for everything until the end of the current + environment (or \TeX{} group, as relevant.) The initial default + color is Black, of course. An example: + \begin{center} + \begin{minipage}{4cm} + \SetColor{Red} + Now red is used:\\ + \begin{axopicture}(0,40) + \Line(0,10)(40,30) + \end{axopicture} + \end{minipage} + \begin{minipage}{7cm} + \label{SetColor} + \begin{verbatim} + \SetColor{Red} + Now red is used:\\ + \begin{axopicture}(0,40) + \Line(0,10)(40,30) + \end{axopicture} + \end{verbatim} + \end{minipage} + \end{center} + +\item Completely equivalently, one can use the command + \verb+\color{colorname}+ defined by the standard \file{color.sty} + package, with any of its options, e.g., \verb+\color{Red}+ or + \verb+\color[rgb]{1,0,0}+. In fact \verb+\SetColor+ is now a + synonym for \verb+\color+, retained for backward compatibility. + +\item The named colors defined by axodraw2 are listed in Sec.\ + \ref{sec:defined.colors}. Extra ones can be defined by axodraw2's + \verb+\newcolor+ command. + +\item For each of the named colors defined by axodraw2 (and others + defined by the use of the \verb+\newcolor+ command), there is a + macro whose name is ``text'' followed by the color name, e.g., + \verb+\textMagenta+. This behaves just like the corresponding call + to \verb+\SetColor+ or \verb+\color+. Thus we have + \begin{center} + \begin{minipage}{4cm} + \textMagenta + Now magenta is used: \hfill \\ + \begin{axopicture}(0,40) + \Line(0,10)(40,30) + \end{axopicture} + \end{minipage} + \begin{minipage}{7cm} + \label{textName} + \begin{verbatim} + \textMagenta + Now magenta is used:\\ + \begin{axopicture}(0,40) + \Line(0,10)(40,30) + \end{axopicture} + \end{verbatim} + \end{minipage} + \end{center} + These macros correspond to macros defined by the venerable + \file{colordvi.sty} package, but now have what is normally an advantage + that their scope is delimited by the enclosing environment. + \begin{center} + \begin{minipage}{5cm} + Normal text, then + \begin{center} + \Large \bf \color{Blue} + Large, bold blue\\ + \begin{axopicture}(40,20) + \Gluon(0,10)(40,10){4}{4} + \end{axopicture}\\ + \end{center} + And normal text afterward. + \end{minipage} + \begin{minipage}{7.7cm} + \label{scope} + \begin{verbatim} + Normal text, then + \begin{center} + \Large \bf \color{Blue} + Large, bold blue + \begin{axopicture}(40,20) + \Gluon(0,10)(40,10){4}{4} + \end{axopicture}\\ + \end{center} + And normal text afterward. + \end{verbatim} + \end{minipage} + \end{center} + +\item A delimited section of text can be set in a color by using a + macro named by the color (e.g., $\verb+\Red+$): + \begin{center} + \begin{minipage}{6cm} + In the middle of black text, + \textcolor{Red}{red text and + \begin{axopicture}(30,10) + \Gluon(0,5)(30,5){3}{4} + \end{axopicture}\ + gluon% + }. + Then continue \dots + \end{minipage} + \begin{minipage}{7.3cm} + \label{Red} + \begin{verbatim} + In the middle of black text, + \Red{red text and + \begin{axopicture}(30,10) + \Gluon(0,5)(30,5){3}{4} + \end{axopicture}\ + gluon% + }. + Then continue \dots + \end{verbatim} + \end{minipage} + \end{center} + These macros correspond to macros defined by the \file{colordvi.sty} + package, but they now apply to axodraw objects as well. + +\item The same effect, for named colors, can be achieved by + \file{color.sty}'s \verb+\textcolor+ macro. Thus + \verb+\textcolor{Red}{...}+ is equivalent to \verb+\Red{...}+. + +\end{itemize} + +It is also possible to define new named colors, in the CMYK +system. This means that each color is defined by four numbers. New +colors can be introduced with the \verb:\newcolor{#1}{#2}: command as +in \verb:\newcolor{LightRed}{0 0.75 0.7 0}:. This use of this command +defines a named color for use in axodraw, with corresponding macros +\verb:\LightRed: and \verb:\textLightRed{#1}:, and also makes the name +known to \file{color.sty}. (Use of \file{color.sty}'s +\verb:\definecolor: macro is not supported here: it will affect only +normal \LaTeX{} text, but not axodraw objects, and it will fail to +define the extra macros.) + +We define the CMYK values for the named colors in the +\file{axodraw2.sty} file. These override the definitions provided +by \file{color.sty} (in its file dvipsnam.def), which are the same +(at least currently). + +There can be differences in how colors render on different devices. +In principle, there should be compensations made by the driver to +compensate for individual device properties. Our experience is however +that such compensations are not always implemented well enough. Most +notorious are differences between the shades of green on the screen, +on projectors, and on output from a printer. These colors are usually +much too light on a projector and one way to correct this is to +redefine those colors when the output is prepared for a projector, +e.g., by use of axodraw's \verb:\newcolor{#1}{#2}: macro. An example +is illustrated by +\begin{center} + \color{green} + \begin{axopicture}(100,20) + \Text(25,15){color.sty's green} + \Line[width=2](0,0)(50,0) + \end{axopicture} +% + \color{Green} + \begin{axopicture}(100,20) + \Text(25,15){axodraw's Green} + \Line[width=2](0,0)(50,0) + \end{axopicture} +\end{center} +coded by +\begin{verbatim} + \color{green} + \begin{axopicture}(100,20) + \Text(25,15){color.sty's green} + \Line[width=2](0,0)(50,0) + \end{axopicture} +% + \color{Green} + \begin{axopicture}(100,20) + \Text(25,15){axodraw's Green} + \Line[width=2](0,0)(50,0) + \end{axopicture} +\end{verbatim} +On a typical screen or projector, we find that the two greens are +quite distinct, the ``green'' being much lighter than the +``Green''\footnote{The ``green'' is defined in the RGB scheme from the + values $(0,1,0)$, while ``Green'' is defined in the CMYK scheme from + the values $(1,0,1,0)$.}. But on the paper output from our +printers, they give close results. + + + +\subsubsection{Defined named colors} +\label{sec:defined.colors} + +The first set of predefined colors are those defined by dvips (and +defined in \file{colordvi.sty}, or in \file{color.sty} with the +use of both of its usenames and dvipsnames options). They are +\begin{quote} +\sloppy +\GreenYellow{GreenYellow}, +\Yellow{Yellow}, +\Goldenrod{Goldenrod}, +\Dandelion{Dandelion}, +\Apricot{Apricot}, +\Peach{Peach}, +\Melon{Melon}, +\YellowOrange{YellowOrange}, +\Orange{Orange}, +\BurntOrange{BurntOrange}, +\Bittersweet{Bittersweet}, +\RedOrange{RedOrange}, +\Mahogany{Mahogany}, +\Maroon{Maroon}, +\BrickRed{BrickRed}, +\Red{Red}, +\OrangeRed{OrangeRed}, +\RubineRed{RubineRed}, +\WildStrawberry{WildStrawberry}, +\Salmon{Salmon}, +\CarnationPink{CarnationPink}, +\Magenta{Magenta}, +\VioletRed{VioletRed}, +\Rhodamine{Rhodamine}, +\Mulberry{Mulberry}, +\RedViolet{RedViolet}, +\Fuchsia{Fuchsia}, +\Lavender{Lavender}, +\Thistle{Thistle}, +\Orchid{Orchid}, +\DarkOrchid{DarkOrchid}, +\Purple{Purple}, +\Plum{Plum}, +\Violet{Violet}, +\RoyalPurple{RoyalPurple}, +\BlueViolet{BlueViolet}, +\Periwinkle{Periwinkle}, +\CadetBlue{CadetBlue}, +\CornflowerBlue{CornflowerBlue}, +\MidnightBlue{MidnightBlue}, +\NavyBlue{NavyBlue}, +\RoyalBlue{RoyalBlue}, +\Blue{Blue}, +\Cerulean{Cerulean}, +\Cyan{Cyan}, +\ProcessBlue{ProcessBlue}, +\SkyBlue{SkyBlue}, +\Turquoise{Turquoise}, +\TealBlue{TealBlue}, +\Aquamarine{Aquamarine}, +\BlueGreen{BlueGreen}, +\Emerald{Emerald}, +\JungleGreen{JungleGreen}, +\SeaGreen{SeaGreen}, +\Green{Green}, +\ForestGreen{ForestGreen}, +\PineGreen{PineGreen}, +\LimeGreen{LimeGreen}, +\YellowGreen{YellowGreen}, +\SpringGreen{SpringGreen}, +\OliveGreen{OliveGreen}, +\RawSienna{RawSienna}, +\Sepia{Sepia}, +\Brown{Brown}, +\Tan{Tan}, +\Gray{Gray}, +\Black{Black}, +White. +\end{quote} +In addition \file{axodraw2.sty} defines the following extra colors: +\begin{quote} +\LightYellow{LightYellow}, +\LightRed{LightRed}, +\LightBlue{LightBlue}, +\LightGray{LightGray}, +\VeryLightBlue{VeryLightBlue}. +\end{quote} + +Note that \file{color.sty} by default also defines a set of other +named colors: black, white, red, green, blue, cyan, magenta, and +yellow (with purely lower-case names). Depending on properties of +your screen, projector or printer, these may or may not agree with the +similarly named axodraw colors (which have capitalized names). These +names can also be used in the \verb+\SetColor+ and \verb+\color+ +commands and for color names to those axodraw commands that take named +colors for arguments. + + +%\subsection{Background issues on color} +%\label{sec:color.issues} + + + + +%>>#] Colors : +%>>#[ Some examples : + +\section{Some examples} +\label{sec:examples} + +\subsection{A Feynman diagram} + +When computing the singlet part of structure functions in polarized Deep +Inelastic Scattering one approach is to use spin two currents to determine +all anomalous dimensions. At the three loop level this can give diagrams +like the following: +\begin{center} +\begin{axopicture}{(200,140)(0,0)} +\SetArrowStroke{0.5} +\SetArrowScale{0.8} +\Photon(7,70)(37,70){4}{3} +\Photon(7,70)(37,70){-4}{3} +\GluonArc(70,70)(30,90,270){3}{10} +\Line[arrow](100,100)(70,100) +\Line[arrow](130,100)(100,100) +\Line[arrow,arrowpos=0.25](70,100)(130,40) +\Line[arrow](100,40)(70,40) +\Line[arrow](130,40)(100,40) +\Line[arrow,arrowpos=0.75](70,40)(130,100) +\GluonArc(130,70)(30,270,450){3}{10} +\Photon(163,70)(193,70){4}{3} +\Photon(163,70)(193,70){-4}{3} +\Gluon(100,100)(100,130){3}{4} +\Gluon(100,40)(100,10){3}{4} +\Vertex(37,70){2} +\Vertex(163,70){2} +\Vertex(70,100){2} +\Vertex(70,40){2} +\Vertex(130,100){2} +\Vertex(130,40){2} +\Vertex(100,100){2} +\Vertex(100,40){2} +\end{axopicture} +\end{center} +for which the code is: +\begin{verbatim} + \begin{center} \begin{axopicture}{(200,140)(0,0)} + \SetArrowStroke{0.5} \SetArrowScale{0.8} + \Photon(7,70)(37,70){4}{3} + \Photon(7,70)(37,70){-4}{3} + \GluonArc(70,70)(30,90,270){3}{10} + \Line[arrow](100,100)(70,100) \Line[arrow](130,100)(100,100) + \Line[arrow,arrowpos=0.25](70,100)(130,40) + \Line[arrow](100,40)(70,40) \Line[arrow](130,40)(100,40) + \Line[arrow,arrowpos=0.75](70,40)(130,100) + \GluonArc(130,70)(30,270,450){3}{10} + \Photon(163,70)(193,70){4}{3} + \Photon(163,70)(193,70){-4}{3} + \Gluon(100,100)(100,130){3}{4} + \Gluon(100,40)(100,10){3}{4} + \Vertex(37,70){2} \Vertex(163,70){2} \Vertex(70,100){2} + \Vertex(70,40){2} \Vertex(130,100){2} \Vertex(130,40){2} + \Vertex(100,100){2} \Vertex(100,40){2} + \end{axopicture} \end{center} +\end{verbatim} +The diagrams can become a bit more complicated when more lines meet in a +single vertex. One could compose some lines from straight lines and arcs, +but in this case we selected some B\'ezier curves. The result is +\begin{center} +\begin{axopicture}{(200,140)(0,0)} +\SetArrowStroke{0.5} +\SetArrowScale{0.8} +\Photon(7,70)(40,70){4}{3} +\Photon(7,70)(40,70){-4}{3} +\GluonArc(70,70)(30,180,270){3}{5} +\Bezier[arrow](100,100)(55,100)(40,95)(40,70) +\Line[arrow](130,100)(100,100) +\Bezier[arrow,arrowpos=0.37](40,70)(110,70)(130,70)(130,40) +\Line[arrow](100,40)(70,40) +\Line[arrow](130,40)(100,40) +\Line[arrow,arrowpos=0.75](70,40)(130,100) +\GluonArc(130,70)(30,270,450){3}{10} +\Photon(163,70)(193,70){4}{3} +\Photon(163,70)(193,70){-4}{3} +\Gluon(100,100)(100,130){3}{4} +\Gluon(100,40)(100,10){3}{4} +\Vertex(40,70){2} +\Vertex(163,70){2} +\Vertex(70,40){2} +\Vertex(130,100){2} +\Vertex(130,40){2} +\Vertex(100,100){2} +\Vertex(100,40){2} +\end{axopicture} +\end{center} +for which the code is: +\begin{verbatim} + \begin{center} + \begin{axopicture}{(200,140)(0,0)} + \SetArrowStroke{0.5} \SetArrowScale{0.8} + \Photon(7,70)(40,70){4}{3} + \Photon(7,70)(40,70){-4}{3} + \GluonArc(70,70)(30,180,270){3}{5} + \Bezier[arrow](100,100)(55,100)(40,95)(40,70) + \Line[arrow](130,100)(100,100) + \Bezier[arrow,arrowpos=0.37](40,70)(100,70)(130,70)(130,40) + \Line[arrow](100,40)(70,40) \Line[arrow](130,40)(100,40) + \Line[arrow,arrowpos=0.75](70,40)(130,100) + \GluonArc(130,70)(30,270,450){3}{10} + \Photon(163,70)(193,70){4}{3} + \Photon(163,70)(193,70){-4}{3} + \Gluon(100,100)(100,130){3}{4} \Gluon(100,40)(100,10){3}{4} + \Vertex(40,70){2} \Vertex(163,70){2} \Vertex(70,40){2} + \Vertex(130,100){2} \Vertex(130,40){2} \Vertex(100,100){2} + \Vertex(100,40){2} + \end{axopicture} + \end{center} +\end{verbatim} + +%\subsection{A flowchart} + +%\subsection{A histogram} + +\subsection{A diagrammatic equation} + +This example is from ref~\cite{twopap}. The equations in that paper were +rather untransparent, because each Feynman diagram represents a complicated +two loop integral and to solve these integrals one needed many different +recursion relations in terms of the powers of the propagators. We defined a +number of macro's for the diagrams, each containing one picture. Here are +three of them: + +\begin{verbatim} + \def\TAA(#1,#2,#3,#4,#5,#6){ + \raisebox{-19.1pt}{ \hspace{-12pt} + \begin{axopicture}{(50,39)(0,-4)} + \SetScale{0.5}\SetColor{Blue}% + \CArc(40,35)(25,90,270) \CArc(60,35)(25,270,90) + \Line(40,60)(60,60) \Line(40,10)(60,10) \Line(50,10)(50,60) + \Line(0,35)(15,35) \Line(85,35)(100,35) + \SetColor{Black}\SetPFont{Helvetica}{14}% + \PText(55,39)(0)[lb]{#5} \PText(55,36)(0)[lt]{#6} + \PText(35,62)(0)[rb]{#1} \PText(65,62)(0)[lb]{#2} + \PText(65,8)(0)[lt]{#3} \PText(35,8)(0)[rt]{#4} + \SetColor{Red} \SetWidth{3} + \Line(50,35)(50,60) \Line(40,60)(50,60) + \CArc(40,35)(25,90,180) \Vertex(50,60){1.3} + \end{axopicture} + \hspace{-12pt} + } + } +\end{verbatim} +\def\TAA(#1,#2,#3,#4,#5,#6){ + \raisebox{-18.1pt}{ \hspace{-12pt} + \begin{axopicture}{(50,39)(0,-4)} + \SetScale{0.5}\SetColor{Blue}% + \CArc(40,35)(25,90,270) \CArc(60,35)(25,270,90) + \Line(40,60)(60,60) \Line(40,10)(60,10) \Line(50,10)(50,60) + \Line(0,35)(15,35) \Line(85,35)(100,35) + \SetColor{Black}\SetPFont{Helvetica}{14}% + \PText(55,39)(0)[lb]{#5} \PText(55,36)(0)[lt]{#6} + \PText(35,62)(0)[rb]{#1} \PText(65,62)(0)[lb]{#2} + \PText(65,8)(0)[lt]{#3} \PText(35,8)(0)[rt]{#4} + \SetColor{Red} \SetWidth{3} + \Line(50,35)(50,60) \Line(40,60)(50,60) + \CArc(40,35)(25,90,180) \Vertex(50,60){1.3} + \end{axopicture} + \hspace{-12pt} + } +} +\begin{verbatim} + \def\TABs(#1,#2,#3,#4,#5){ + \raisebox{-18.1pt}{ \hspace{-12pt} + \begin{axopicture}{(50,39)(0,-4)} + \SetScale{0.5}\SetColor{Blue}% + \CArc(40,35)(25,90,270) \CArc(60,35)(25,270,90) + \Line(40,60)(60,60) \Line(40,10)(60,10) \Line(50,10)(50,60) + \Line(0,35)(15,35) \Line(85,35)(100,35) + \SetColor{Black}\SetPFont{Helvetica}{14}% + \PText(55,38)(0)[l]{#5} + \PText(35,62)(0)[rb]{#1} \PText(65,62)(0)[lb]{#2} + \PText(65,8)(0)[lt]{#3} \PText(35,8)(0)[rt]{#4} + \SetColor{Red} \SetWidth{3} + \Line(50,10)(50,60) \Vertex(50,60){1.3} + \Line(40,60)(50,60) \CArc(40,35)(25,90,180) + \end{axopicture} + \hspace{-12pt} + } + } +\end{verbatim} +\def\TABs(#1,#2,#3,#4,#5){ + \raisebox{-18.1pt}{ \hspace{-12pt} + \begin{axopicture}{(50,39)(0,-4)} + \SetScale{0.5}\SetColor{Blue}% + \CArc(40,35)(25,90,270) \CArc(60,35)(25,270,90) + \Line(40,60)(60,60) \Line(40,10)(60,10) \Line(50,10)(50,60) + \Line(0,35)(15,35) \Line(85,35)(100,35) + \SetColor{Black}\SetPFont{Helvetica}{14}% + \PText(55,38)(0)[l]{#5} + \PText(35,62)(0)[rb]{#1} \PText(65,62)(0)[lb]{#2} + \PText(65,8)(0)[lt]{#3} \PText(35,8)(0)[rt]{#4} + \SetColor{Red} \SetWidth{3} + \Line(50,10)(50,60) \Vertex(50,60){1.3} + \Line(40,60)(50,60) \CArc(40,35)(25,90,180) + \end{axopicture} + \hspace{-12pt} + } +} +\begin{verbatim} + \def\TACs(#1,#2,#3,#4,#5){ + \raisebox{-19.1pt}{ \hspace{-12pt} + \begin{axopicture}{(50,39)(0,-4)} + \SetScale{0.5}\SetColor{Blue}% + \CArc(40,35)(25,90,270) \CArc(60,35)(25,270,90) + \Line(40,60)(60,60) \Line(40,10)(60,10) \Line(50,10)(50,60) + \Line(0,35)(15,35) \Line(85,35)(100,35) + \SetColor{Black}\SetPFont{Helvetica}{14}% + \PText(53,38)(0)[l]{#5} + \PText(35,62)(0)[rb]{#1} \PText(65,62)(0)[lb]{#2} + \PText(65,8)(0)[lt]{#3} \PText(35,8)(0)[rt]{#4} + \SetColor{Red} \SetWidth{3} + \Line(40,60)(50,60) \CArc(40,35)(25,90,180) + \end{axopicture} + \hspace{-12pt} + } + } +\end{verbatim} +\def\TACs(#1,#2,#3,#4,#5){ + \raisebox{-19.1pt}{ \hspace{-12pt} + \begin{axopicture}{(50,39)(0,-4)} + \SetScale{0.5}\SetColor{Blue}% + \CArc(40,35)(25,90,270) \CArc(60,35)(25,270,90) + \Line(40,60)(60,60) \Line(40,10)(60,10) \Line(50,10)(50,60) + \Line(0,35)(15,35) \Line(85,35)(100,35) + \SetColor{Black}\SetPFont{Helvetica}{14}% + \PText(53,38)(0)[l]{#5} + \PText(35,62)(0)[rb]{#1} \PText(65,62)(0)[lb]{#2} + \PText(65,8)(0)[lt]{#3} \PText(35,8)(0)[rt]{#4} + \SetColor{Red} \SetWidth{3} + \Line(40,60)(50,60) \CArc(40,35)(25,90,180) + \end{axopicture} + \hspace{-12pt} + } +} +and together with two extra little macro's +\begin{verbatim} +\def\plus{\!+\!} +\def\minus{\!-\!} +\end{verbatim} +\def\plus{\!+\!} +\def\minus{\!-\!} +the equations became rather transparent and easy to program. This is the +code +\begin{verbatim} + \begin{eqnarray} + \TAA({n,m},1,1,1,1,1) & = & \frac{1}{\tilde{N}\plus 5\plus n\minus + m\minus D}\ (\ n\ \ \TAA({n+1,m},0,1,1,1,1) + \ \ -n\ \ \TACs({n+1,m},1,1,1,1) \\ & & + +\ \ \TAA({n,m},1,0,2,1,1) + \ \ -\ \ \TABs({n,m},1,1,2,1) + \ \ +m\ \ \TACs({n,m-1},1,1,1,1) + \ \ -m\ \ \TABs({n,m-1},1,1,1,1)\ \ \ ) \, .\nonumber + \end{eqnarray} +\end{verbatim} +and the equation becomes +\begin{eqnarray} + \TAA({n,m},1,1,1,1,1) & = & \frac{1}{\tilde{N}\plus 5\plus n\minus + m\minus D}\ (\ n\ \ \TAA({n+1,m},0,1,1,1,1) + \ \ -n\ \ \TACs({n+1,m},1,1,1,1) \\ & & + +\ \ \TAA({n,m},1,0,2,1,1) + \ \ -\ \ \TABs({n,m},1,1,2,1) + \ \ +m\ \ \TACs({n,m-1},1,1,1,1) + \ \ -m\ \ \TABs({n,m-1},1,1,1,1)\ \ \ ) \, .\nonumber +\end{eqnarray} +The diagrams are actually four-point diagrams. A momentum $P$ flows through +the diagram (the fat red line), but because the method of computation +involves an expansion in terms of this momentum the remaining diagrams are +like two-point functions. Details are in the paper. + +%>>#] Some examples : +%>>#[ Acknowledgements : + +\section*{Acknowledgements} + +JAMV's work is part of the research program of the ``Stichting voor +Fundamenteel Onderzoek der Materie (FOM)'', which is financially supported +by the ``Nederlandse organisatie voor Wetenschappelijke Onderzoek (NWO)'' and +is also supported by the ERC Advanced Grant no.~320651, HEPGAME. +JCC is supported in part by the U.S. Department of Energy under Grant +No.\ DE-SC0008745. + +We like to thank Lucas Theussl for discussions during the development of +axodraw2. + +%>>#] Acknowledgements : +%--#[ Appendix : + +\appendix + +\section{The axohelp program: Information for developers} +\label{sec:axohelp.devel} + +This appendix provides some details on how the axohelp program works. +Most of the information is only relevant to people who wish to modify +or extend axodraw2 and therefore may need to modify axohelp as well. + +The reason for axohelp's existence is that axodraw needs to perform +substantial geometric calculations. When axodraw is used with +pdflatex to produce pdf output directly, suitable calculational +facilities are not available, neither within the PDF language nor +within \LaTeX{} itself. Therefore when axodraw is used under +pdflatex, we use our program axohelp to perform the calculations. + +The mode of operation is as follows. Let us assume that the .tex file +being compiled by the pdflatex program is called paper.tex. When one +issues the command +\begin{verbatim} + pdflatex paper +\end{verbatim} +the reaction of the system is of course to translate all \TeX{} +related objects into a PDF file. Most (but not all) axodraw objects +need non-trivial calculations and hence their +specifications are placed inside a file called paper.ax1. At the end +of the processing \program{pdflatex} will place a message on the screen +that mentions that the user should run the command +\begin{verbatim} + axohelp paper +\end{verbatim} +for the processing of this graphical information. In principle it is +possible to arrange for axohelp to be invoked automatically from +within pdflatex. But for this to be done, the running of general +external commands from pdflatex would have to be enabled. That is a +security risk, and is therefore normally disabled by default for +pdflatex. + +When run, axohelp reads the file paper.ax1, processes the contents, +and produces a file paper.ax2. For each axodraw object, it contains +both the code to be placed in the pdf file, and a copy of the +corresponding specification that was in paper.ax1. + +When pdflatex is run again, it sees that the file paper.ax2 is present +and reads it in to give essentially an array of objects, one for each +processed axodraw object. Then during the processing of the document, +whenever axodraw runs into an axodraw object in need of external +calculation, it determines whether an exactly corresponding +specification was present in the file paper.ax2. If not, it means that +the graphical information in the file paper.tex has changed since the +last run of axohelp and the graphics information is invalidated. In +that case, at the end of the program the message to run axohelp will +be printed again. But if instead there is an exact match between an +axodraw object in the current paper.tex and its specification in +paper.ax2, then the corresponding pdf code will be placed in the PDF +file. If all axodraw commands have a proper match in the paper.ax2 +file, there will be no message in the paper.log file and on the screen +about rerunning axohelp; then the PDF file should contain the correct +information for drawing the axodraw objects (at least if there are no +\TeX{} errors). + +In a sense the situation with axohelp is no different from the use of +makeindex when one prepares a document that contains an index. In that +case one also has to run \LaTeX{} once to prepare a file for the +makeindex program, then run this program which prepares another file +and finally run \LaTeX{} again. Note that if you submit a paper to +arXiv.org, it is likely that their automated system for processing the +file will not run axohelp. So together with paper.tex, you one should +also submit the .ax2 file. + +The complete source of the axohelp program can be found in the file +axohelp.c. This file contains a bit less than 4000 lines of C code but +should translate +without problems with any C compiler --- see Sec.\ \ref{sec:axohelp} +for an appropriate command line on typical Unix-like systems. + +The axohelp program functions as follows: +\begin{enumerate} +\item The .ax1 file is located, space is allocated for it and the complete +file is read and closed again. +\item The input is analysed and split in individual object + specifications, of which a list is made. +\item The list of object specifications is processed one by + one. Before the processing of each object specification, the system + is brought to a default state to avoid that there is a memory of the + previous object. +\item In the .ax2 file, for each object is written both the + corresponding pdf code and a copy of the specification of the object + as was earlier read from the .ax1 file. Before the output for an + object is written to the .ax2 file it is optimized a bit to avoid + superfluous spaces and linefeeds. +\end{enumerate} + +Processing an object from the input involves finding the proper routine for +it and testing that the number of parameters is correct. Some objects have +a special input (like the Curve, DashCurve, Polygon and FilledPolygon +commands). All relevant information is stored in an array of double +precision numbers. Then some generic action is taken (like setting the +linewidth and the color) and the right routine is +called. The output is written to an array of fixed (rather large) length. +Finally the array is optimized and written to file. + +A user who would like to extend the system with new objects should +take the above structure into account. There is an array that gives +the correspondence between axodraw object names and the corresponding +routine in axohelp. For each object, this array also gives the number +of parameters and whether the stroking or non-stroking color space +should be used. + +Naturally, when adding new kinds of object, it is necessary to add new +items to the just-mentioned array, and to add a corresponding +subroutine. One should also try to do all the writing of PDF code by +means of some routines like the ones sitting in the file in the +section named ``PDF utilities''. This is important from the viewpoint +of future action. When new graphical languages will be introduced and +it will be needed to modify axodraw2 such that it can produce code for +those languages, it should be much easier if code in the supporting +axohelp program needs to be changed in as few places as possible. +They form a set of graphics primitives used by other subroutines. +Some of these subroutines in the ``PDF utilities'' section of +axohelp.c have names similar to operators in the postscript language +that perform the same function. + +%--#] Appendix : +%>>#[ bibliography : + +\begin{thebibliography}{9} + +\bibitem{axodraw1} J.A.M. Vermaseren, + Comput.\ Phys.\ Commun.\ {\bf 83} (1994) 45--58 + +\bibitem{jaxodraw1} D. Binosi and L. Theussl, + Comput.\ Phys.\ Commun.\ {\bf 161} (2004) 76--86. + +\bibitem{jaxodraw2} +D. Binosi, J. Collins, C. Kaufhold, L. Theussl, + Comput.\ Phys.\ Commun.\ {\bf 180} (2009) 1709--1715 + +\bibitem{GPL} GNU General Public + License. \url{http://www.gnu.org/copyleft/gpl.html}. + +\bibitem{qcdbook} +J.C. Collins, ``Foundations of Perturbative QCD'' (Cambridge + University Press, 2011). + +\bibitem{twopap} S. Moch and J.A.M. Vermaseren, + Nucl.\ Phys.\ {\bf B573} (2000) 853. + %%CITATION = NUPHA,B573,853;%%. + +\end{thebibliography} + +%>>#] bibliography : +\end{document} + diff --git a/Master/texmf-dist/doc/latex/axodraw2/example.tex b/Master/texmf-dist/doc/latex/axodraw2/example.tex new file mode 100644 index 00000000000..3f87fb80185 --- /dev/null +++ b/Master/texmf-dist/doc/latex/axodraw2/example.tex @@ -0,0 +1,19 @@ +\documentclass{article} +\usepackage{axodraw2} +\begin{document} +Example of Feynman graph made by axodraw2: +\begin{center} + \begin{axopicture}(200,110) + \SetColor{Red} + \Arc[arrow](100,50)(40,0,180) + \Text(100,100)[]{$\alpha P_1 + \beta P_2 + k_\perp$} + \SetColor{Green} + \Arc[arrow](100,50)(40,180,360) + \SetColor{Blue} + \Gluon(0,50)(60,50){5}{4} + \Vertex(60,50){2} + \Gluon(140,50)(200,50){5}{4} + \Vertex(140,50){2} + \end{axopicture} +\end{center} +\end{document} diff --git a/Master/texmf-dist/source/latex/axodraw2/axohelp.c b/Master/texmf-dist/source/latex/axodraw2/axohelp.c new file mode 100644 index 00000000000..ca6b4f64df0 --- /dev/null +++ b/Master/texmf-dist/source/latex/axodraw2/axohelp.c @@ -0,0 +1,3699 @@ +/* + #[ License : + + (C) 2016 by authors: + John Collins (jcc8 at psu dot edu) + Jos Vermaseren (t68 at nikhef dot nl) + + axohelp is free software: you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation, either version 3 of the License, or (at your option) + any later version. + + axohelp is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + details. + + For the GNU General Public License see . + + #] License : + #[ Commentary + Modifications : + + This file contains the source code of the axohelp program that is used + together with axopdf.sty and pdflatex. It is a conversion of the postscript + code of axodraw.sty. + + input file contains objects of the type + [number] axohelp input + the output contains objects: + \axo@setObject{label}% + {input data}% + {output} + There may be blank lines and commentary. + + #[ About folds : (this line starts with one blank and two tabs) + + The internals of the file have been organized in folds. + These are defined as a range of lines if which the first and last + lines have a special format. Each starts with any three characters + (may include tabs), then #[ for the start line and #] for the closing + line, then both lines need identical name fields, closed by a colon. + After the colon can be anything. When a fold is closed one should see + only the first line but with the #[ replaced by ## as in + ## About folds : (this line starts with one blank and two tabs) + Folds can be nested. + This fold concept comes originally from the occam compiler for the + transputer in the second half of the 1980's although there it was + implemented differently. It was taken over by the STedi editor in its + current form. The sources of this editor are available from the form + home site: http://www.nikhef.nl/~form + Some people have managed to emulate these folds in editors like emacs + and vim. + + #] About folds : + #] Commentary + Modifications : + #[ Includes : +*/ + +#include +#include +#include +#include + +/* + #] Includes : + #[ Defines : +*/ + +#define NAME "axohelp" +#define VERSIONDATE "2016 May 23" +#define VERSION 1 +#define SUBVERSION 0 + +#define COMMENTCHAR '%' +#define TERMCHAR ';' + +#define STROKING 0 +#define NONSTROKING 1 + +char **inputs; +long *inputsizes; +double **inargs; +long numinputs = 0; +long inputallocations = 0; +char *axohelp; +FILE *outfile; +char *inname, *outname; +int VerboseFlag = 0; +char outputbuffer[1000000]; +char *outpos; +long numobject; +char *nameobject; +int witharrow = 0; +int identification = 0; + +static int lastlinefeed = 1; +static double axolinewidth = 0.5; +static struct aRRow { + double stroke; + double width; + double length; + double inset; + double where; + double scale; + double aspect; + int type; /* 0: old style arrow; 1: Jaxodraw style arrow */ + int adjust; /* whether the line length should be adjusted */ +} arrow; +double linesep = 0; +int flip = 0; +int clockwise = 0; + +void OutputString(char *); +void ArrowHead(); +void GetArrow(double *); +void BezierArrow(double *); +void ArcSegment(double,double,double); +double *ReadArray(char *,int *,int *); +double *ReadTail(char *,int *); +double LengthBezier(double,double,double,double,double,double,double); + +double M_pi; +double torad; +#define COS(x) cos((x)*torad) +#define SIN(x) sin((x)*torad) +#define TAN(x) tan((x)*torad) + +typedef void (*TFUN)(double *); + +typedef struct { + char *name; + TFUN func; + int numargs; + int colortype; +} KEYWORD; + +void GluonHelp(double *,double); +void DoubleGluonHelp(double *,double,double,double,double); +void GluonCircHelp(double *); +void GluonArcHelp(double *,double,double); +void PhotonHelp(double *,double); +void PhotonArcHelp(double *,double,int); +void ZigZagHelp(double *,double); +void ZigZagArcHelp(double *); +double ComputeDash(double *,double,double); +double ComputeDashCirc(double *,double); + +void ArrowArc(double *); +void ArrowArcn(double *); +void ArrowDoubleArc(double *); +void ArrowLine(double *); +void ArrowDoubleLine(double *); +void AxoArc(double *); +void AxoBezier(double *); +void AxoGluon(double *); +void AxoGluonArc(double *); +void AxoGluonCirc(double *); +void AxoLine(double *); +void AxoPhoton(double *); +void AxoPhotonArc(double *); +void AxoZigZag(double *); +void AxoZigZagArc(double *); +void BezierCurve(double *); +void Boxc(double *); +void CArc(double *); +void DashArrowArc(double *); +void DashArrowArcn(double *); +void DashArrowLine(double *); +void DashArrowDoubleArc(double *); +void DashArrowDoubleLine(double *); +void DashBezier(double *); +void DashCArc(double *); +void DashDoubleArc(double *); +void DashDoubleBezier(double *); +void DashDoubleLine(double *); +void DashDoublePhoton(double *); +void DashDoublePhotonArc(double *); +void DashDoubleZigZag(double *); +void DashDoubleZigZagArc(double *); +void DashGluon(double *); +void DashGluonArc(double *); +void DashGluonCirc(double *); +void DashPhoton(double *); +void DashPhotonArc(double *); +void DashZigZag(double *); +void DashZigZagArc(double *); +void DashLine(double *); +void DoubleArc(double *); +void DoubleBezier(double *); +void DoubleLine(double *); +void DoublePhoton(double *); +void DoublePhotonArc(double *); +void DoubleZigZag(double *); +void DoubleZigZagArc(double *); +void EBox(double *); +void EBoxc(double *); +void ECirc(double *); +void ETri(double *); +void FBox(double *); +void FBoxc(double *); +void FOval(double *); +void FTri(double *); +void GluonArc(double *); +void GluonCirc(double *); +void Gluon(double *); +void Grid(double *); +void LinAxis(double *); +void Line(double *); +void LogAxis(double *); +void Oval(double *); +void Photon(double *); +void PhotonArc(double *); +void Rotate(double *); +void Vertex(double *); +void ZigZag(double *); +void ZigZagArc(double *); + +void Curve(double *,int); +void DashCurve(double *,int); +void Polygon(double *,int,int); + +void Inivars(void); + +KEYWORD commands[] = { + { "Line", Line, 4, STROKING } + ,{ "ArrowArc", ArrowArc, 7, STROKING } + ,{ "ArrowArcn", ArrowArcn, 7, STROKING } + ,{ "ArrowDoubleArc", ArrowDoubleArc, 8, STROKING } + ,{ "ArrowLine", ArrowLine, 6, STROKING } + ,{ "ArrowDoubleLine", ArrowDoubleLine, 7, STROKING } + ,{ "AxoArc", AxoArc, 17, STROKING } + ,{ "AxoBezier", AxoBezier, 19, STROKING } + ,{ "AxoGluon", AxoGluon, 8, STROKING } + ,{ "AxoGluonArc", AxoGluonArc, 10, STROKING } + ,{ "AxoGluonCirc", AxoGluonCirc, 8, STROKING } + ,{ "AxoLine", AxoLine, 15, STROKING } + ,{ "AxoPhoton", AxoPhoton, 8, STROKING } + ,{ "AxoPhotonArc", AxoPhotonArc, 10, STROKING } + ,{ "AxoZigZag", AxoZigZag, 8, STROKING } + ,{ "AxoZigZagArc", AxoZigZagArc, 10, STROKING } + ,{ "Bezier", BezierCurve, 8, STROKING } + ,{ "Boxc", Boxc, 4, STROKING } + ,{ "CArc", CArc, 5, STROKING } + ,{ "DashArrowArc", DashArrowArc, 8, STROKING } + ,{ "DashArrowArcn", DashArrowArcn, 8, STROKING } + ,{ "DashArrowDoubleArc", DashArrowDoubleArc, 9, STROKING } + ,{ "DashArrowDoubleLine",DashArrowDoubleLine,8, STROKING } + ,{ "DashArrowLine", DashArrowLine, 7, STROKING } + ,{ "DashBezier", DashBezier, 9, STROKING } + ,{ "DashCArc", DashCArc, 6, STROKING } + ,{ "DashDoubleArc", DashDoubleArc, 7, STROKING } + ,{ "DashDoubleBezier", DashDoubleBezier, 10, STROKING } + ,{ "DashDoubleLine", DashDoubleLine, 6, STROKING } + ,{ "DashDoublePhoton", DashDoublePhoton, 8, STROKING } + ,{ "DashDoublePhotonArc",DashDoublePhotonArc,10, STROKING } + ,{ "DashDoubleZigZag", DashDoubleZigZag, 8, STROKING } + ,{ "DashDoubleZigZagArc",DashDoubleZigZagArc,10, STROKING } + ,{ "DashGluon", DashGluon, 7, STROKING } + ,{ "DashGluonArc", DashGluonArc, 10, STROKING } + ,{ "DashGluonCirc", DashGluonCirc, 7, STROKING } + ,{ "DashLine", DashLine, 5, STROKING } + ,{ "DashPhoton", DashPhoton, 7, STROKING } + ,{ "DashPhotonArc", DashPhotonArc, 10, STROKING } + ,{ "DashZigZag", DashZigZag, 7, STROKING } + ,{ "DashZigZagArc", DashZigZagArc, 10, STROKING } + ,{ "DoubleArc", DoubleArc, 6, STROKING } + ,{ "DoubleBezier", DoubleBezier, 9, STROKING } + ,{ "DoubleLine", DoubleLine, 5, STROKING } + ,{ "DoublePhoton", DoublePhoton, 7, STROKING } + ,{ "DoublePhotonArc", DoublePhotonArc, 8, STROKING } + ,{ "DoubleZigZag", DoubleZigZag, 7, STROKING } + ,{ "DoubleZigZagArc", DoubleZigZagArc, 8, STROKING } + ,{ "EBox", EBox, 4, STROKING } + ,{ "FBox", FBox, 4, STROKING } + ,{ "FBoxc", FBoxc, 4, STROKING } + ,{ "ECirc", ECirc, 3, STROKING } + ,{ "ETri", ETri, 6, STROKING } + ,{ "FOval", FOval, 5, NONSTROKING } + ,{ "FTri", FTri, 6, NONSTROKING } + ,{ "GluonArc", GluonArc, 7, STROKING } + ,{ "GluonCirc", GluonCirc, 6, STROKING } + ,{ "Gluon", Gluon, 6, STROKING } + ,{ "Grid", Grid, 6, STROKING } + ,{ "LinAxis", LinAxis, 8, STROKING } + ,{ "LogAxis", LogAxis, 7, STROKING } + ,{ "Oval", Oval, 5, STROKING } + ,{ "Photon", Photon, 6, STROKING } + ,{ "PhotonArc", PhotonArc, 7, STROKING } + ,{ "Rotate", Rotate, 7, NONSTROKING } + ,{ "Vertex", Vertex, 3, NONSTROKING } + ,{ "ZigZag", ZigZag, 6, STROKING } + ,{ "ZigZagArc", ZigZagArc, 7, STROKING } +}; + +/* + #] Defines : + #[ SetDefaults : +*/ + +void SetDefaults() +{ + lastlinefeed = 1; + axolinewidth = 0.5; + linesep = 0; + flip = 0; + clockwise = 0; + witharrow = 0; +} + +/* + #] SetDefaults : + #[ PDF utilities : + + These routines are included to make the program more readable and easier + to write. It also allows the easy use of the OutputString routine that + compactifies the output. +*/ + +#define Stroke outpos += sprintf(outpos," S") +#define CloseAndStroke outpos += sprintf(outpos," h S") +#define Fill outpos += sprintf(outpos," f") +#define CloseAndFill outpos += sprintf(outpos," h f") +#define SaveGraphicsState outpos += sprintf(outpos," q") +#define RestoreGraphicsState outpos += sprintf(outpos," Q") + +void Bezier(double x1,double y1,double x2,double y2,double x3,double y3) { + outpos += + sprintf(outpos,"\n %12.3f %12.3f %12.3f %12.3f %12.3f %12.3f c",x1,y1,x2,y2,x3,y3); +} + +void LineTo(double x1,double y1) { + outpos += + sprintf(outpos,"\n %12.3f %12.3f l",x1,y1); +} + +void MoveTo(double x1,double y1) { + outpos += + sprintf(outpos,"\n %12.3f %12.3f m",x1,y1); +} + +void SetLineWidth(double w) { + outpos += + sprintf(outpos," %12.3f w",w); +} + +void SetDashSize(double dashsize,double phase) { + if ( dashsize ) outpos += sprintf(outpos," [%12.3f] %12.3f d",dashsize,phase); + else outpos += sprintf(outpos," [] 0 d"); +} + +void SetTransferMatrix(double x11,double x12,double x21,double x22,double x,double y) +{ + if ( ( fabs(x11-1.) > 0.001 ) || ( fabs(x22-1.) > 0.001 ) + || ( fabs(x12) > 0.001 ) || ( fabs(x21) > 0.001 ) + || ( fabs(x) > 0.001 ) || ( fabs(y) > 0.001 ) ) { + outpos += + sprintf(outpos,"%12.3f %12.3f %12.3f %12.3f %12.3f %12.3f cm\n",x11,x12,x21,x22,x,y); + } +} + +static double BzK; + +void BezierCircle(double r,char *action) +{ + outpos += + sprintf(outpos," %12.3f 0 m %12.3f %12.3f %12.3f %12.3f 0 %12.3f c\n",-r,-r,r*BzK,-r*BzK,r,r); + outpos += + sprintf(outpos," %12.3f %12.3f %12.3f %12.3f %12.3f 0 c\n",r*BzK,r,r,r*BzK,r); + outpos += + sprintf(outpos," %12.3f %12.3f %12.3f %12.3f 0 %12.3f c\n",r,-r*BzK,r*BzK,-r,-r); + outpos += + sprintf(outpos," %12.3f %12.3f %12.3f %12.3f %12.3f 0 c %s\n",-r*BzK,-r,-r,-r*BzK,-r,action); +} + +void BezierOval(double w, double h, char *action) +{ + outpos += + sprintf(outpos," %12.3f 0 m %12.3f %12.3f %12.3f %12.3f 0 %12.3f c\n",-w,-w,h*BzK,-w*BzK,h,h); + outpos += + sprintf(outpos," %12.3f %12.3f %12.3f %12.3f %12.3f 0 c\n",w*BzK,h,w,h*BzK,w); + outpos += + sprintf(outpos," %12.3f %12.3f %12.3f %12.3f 0 %12.3f c\n",w,-h*BzK,w*BzK,-h,-h); + outpos += + sprintf(outpos," %12.3f %12.3f %12.3f %12.3f %12.3f 0 c %s\n",-w*BzK,-h,-w,-h*BzK,-w,action); +} + +void SetGray(double grayscale,int par) +{ + if ( par == STROKING ) { + outpos += sprintf(outpos," %12.3f G",grayscale); + } + else { + outpos += sprintf(outpos," %12.3f g",grayscale); + } +} + +void SetColor(double c, double m, double y, double k,int par) +{ + if ( par == STROKING ) { + outpos += sprintf(outpos," %12.3f %12.3f %12.3f %12.3f K",c,m,y,k); + } + else { + outpos += sprintf(outpos," %12.3f %12.3f %12.3f %12.3f k",c,m,y,k); + } +} + +void SetBackgroundColor(int par) +{ + if ( par == STROKING ) { outpos += sprintf(outpos," 0 0 0 0 K"); } + else { outpos += sprintf(outpos," 0 0 0 0 k"); } +} + +void Rectangle(double x,double y,double w,double h) { + outpos += sprintf(outpos,"\n %12.3f %12.3f %12.3f %12.3f re",x,y,w,h); +} + +void Triangle(double x1,double y1,double x2,double y2,double x3,double y3) { + outpos += + sprintf(outpos,"\n %12.3f %12.3f m %12.3f %12.3f l %12.3f %12.3f l h",x1,y1,x2,y2,x3,y3); +} + +/* + #] PDF utilities : + #[ Service routines : + #[ GetArrow : +*/ + +void GetArrow(double *args) +{ + witharrow = args[7]; + arrow.stroke = args[0]; + arrow.width = args[1]; + arrow.length = args[2]; + arrow.inset = args[3]; + arrow.scale = args[4]; + arrow.aspect = args[5]; + arrow.where = args[6]; + arrow.type = 1; + arrow.adjust = 0; + if ( args[8] ) flip = 1; + if ( witharrow ) { + if ( arrow.length == 0 && arrow.width == 0 ) { + arrow.width = (axolinewidth + 0.7*linesep + 1 ) * 1.2; + if (arrow.width < 2.5) arrow.width = 2.5; + arrow.length = 2*arrow.width*arrow.aspect; + } + else if ( arrow.width == 0 ) { + arrow.width = arrow.length/(2*arrow.aspect); + } + else if ( arrow.length == 0 ) { + arrow.length = 2*arrow.width*arrow.aspect; + } + arrow.width *= arrow.scale; + arrow.length *= arrow.scale; + if ( arrow.where > 1 ) { arrow.where = 1; arrow.adjust = 1; } + if ( arrow.where < 0 ) { arrow.where = 0; arrow.adjust = 1; } + } +} + +/* + #] GetArrow : + #[ ArrowHead : + + Places an arrowhead of a given size at 0 in the +x direction + The size: Full width is 2*size and full length is also 2*size. +*/ + +void ArrowHead() +/* + Jaxodraw style arrows +*/ +{ + int k; + double length; + SaveGraphicsState; + if ( flip ) length = -arrow.length; + else length = arrow.length; + SetDashSize(0,0); + if ( arrow.stroke ) { + SetLineWidth(arrow.stroke); + for (k = 1; k <= 2; k++ ) { + SaveGraphicsState; + MoveTo(length*0.5,0); + LineTo(-length*0.5,arrow.width); + LineTo(-length*0.5+length*arrow.inset,0); + LineTo(-length*0.5,-arrow.width); + if (k == 1) { + SetBackgroundColor(NONSTROKING); + outpos += sprintf(outpos," h f"); + } + else { + outpos += sprintf(outpos," s"); + } + RestoreGraphicsState; + } + } + else { + MoveTo(length*0.5,0); + LineTo(-length*0.5,arrow.width); + LineTo(-length*0.5+length*arrow.inset,0); + LineTo(-length*0.5,-arrow.width); + outpos += sprintf(outpos," h f"); + } + RestoreGraphicsState; +} + +/* + #] ArrowHead : + #[ BezierArrow : + + We compute the length of the curve. + Then we try to find the t value for which holds: + Length(t)/Length(1) = arrow.where +*/ + +void BezierArrow(double *args) +{ + double t,u,x,y,dx,dy,dr,len,tlen,tmin=0,tmax=1.0; + double x1=args[2]-args[0],x2=args[4]-args[0],x3=args[6]-args[0]; + double y1=args[3]-args[1],y2=args[5]-args[1],y3=args[7]-args[1]; + len = LengthBezier(x1,y1,x2,y2,x3,y3,1.0); + t = arrow.where; + tlen = LengthBezier(x1,y1,x2,y2,x3,y3,t); + while ( fabs(tlen/len-arrow.where) > 0.0001 ) { + if ( tlen/len > arrow.where ) { + tmax = t; + t = 0.5*(tmin+t); + } + else { + tmin = t; + t = 0.5*(tmax+t); + } + tlen = LengthBezier(x1,y1,x2,y2,x3,y3,t); + } + u = 1-t; + x = args[0]*u*u*u+(3*args[2]*u*u+(3*args[4]*u+args[6]*t)*t)*t; + y = args[1]*u*u*u+(3*args[3]*u*u+(3*args[5]*u+args[7]*t)*t)*t; + dx = 3*(-args[0]*u*u+args[2]*u*(1-3*t)+args[4]*t*(2-3*t)+args[6]*t*t); + dy = 3*(-args[1]*u*u+args[3]*u*(1-3*t)+args[5]*t*(2-3*t)+args[7]*t*t); + dr = sqrt(dx*dx+dy*dy); + SetTransferMatrix(1,0,0,1,x,y); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + ArrowHead(); +} + +/* + #] BezierArrow : + #[ ArcSegment : +*/ + +void ArcSegment(double r, double phi1, double dphi) +{ + double xphi, d, x, y, phia, phib, x1,y1,x2,y2,x3,y3; + int num, i; + + num = dphi/90.0001+1.; /* number of segments we should use. */ + xphi = dphi/num; /* arc size of each segment */ + d = 4.*TAN(xphi/4.)/3.; /* the magic distance for the control points */ + + x = r*COS(phi1); y = r*SIN(phi1); + MoveTo(x,y); + for ( i = 0; i < num; i++ ) { + phia = phi1+i*xphi; /* Start of segment */ + phib = phia+xphi; /* End of segment */ + x3 = r*COS(phib); y3 = r*SIN(phib); + x1 = x - y*d; y1 = y + x*d; + x2 = x3+y3*d; y2 = y3-x3*d; + + Bezier(x1,y1,x2,y2,x3,y3); + + x = x3; y = y3; + } +} + +/* + #] ArcSegment : + #[ ReadNumber : +*/ + +char *ReadNumber(char *s,double *num) +{ + double x3,minus = 1; + int x1,x2; + while ( *s == '+' || *s == '-' ) { + if ( *s == '-' ) minus = -minus; + s++; + } + x1 = x2 = 0; x3 = 1; + while ( *s <= '9' && *s >= '0' ) { x1 = 10*x1 + *s++ - '0'; } + if ( *s == 0 ) { *num = x1*minus; return(s); } + if ( *s == '.' ) { + s++; + while ( *s >= '0' && *s <= '9' ) { x2 = 10*x2 + *s++ - '0'; x3 *= 10; } + } + *num = minus*((double)x1 + x2/x3); + return(s); +} + +/* + #] ReadNumber : + #[ ReadArray : + + Reads a tail of floats of the type (x1,y1)(x2,y2),...,(xn,yn) or + (x1,y1)(x2,y2),...,(xn,yn) f1 ... fm + The floats may be written as integers. + Normally they are in the format ####.### + In num1 we return the number of coordinates encountered. + In num2 we return the number of extra floats encountered. + The array of the return value should be freed after it has been used. +*/ + +double *ReadArray(char *inbuf, int *num1, int *num2) +{ + int argsize = 0, newsize, num = 0, i; + double *args = 0, *newargs = 0, *extraargs, x, y; + char *s; + *num2 = 0; + s = inbuf; + while ( *s == ' ' || *s == '\t' || *s == '\n' ) s++; + if ( *s == '"' ) { + s++; + while ( *s == ' ' || *s == '\t' || *s == '\n' ) s++; + } + while ( *s == '(' ) { /* We need to read (x,y) */ + s++; + while ( *s == ' ' || *s == '\n' || *s == '\t' ) s++; + s = ReadNumber(s,&x); + while ( *s == ' ' ) s++; + if ( *s != ',' ) { + fprintf(stderr,"%s: Illegal format for array of numbers in object %ld of type %s in file %s\n" + ,axohelp,numobject,nameobject,inname); + free(args); + return(0); + } + s++; + while ( *s == ' ' || *s == '\n' || *s == '\t' ) s++; + s = ReadNumber(s,&y); + while ( *s == ' ' || *s == '\n' || *s == '\t' ) s++; + if ( *s != ')' ) { + fprintf(stderr,"%s: Illegal format for array of numbers in object %ld of type %s in file %s\n" + ,axohelp,numobject,nameobject,inname); + free(args); + return(0); + } + s++; + while ( *s == ' ' ) s++; + num += 2; + if ( num >= argsize ) { + if ( argsize == 0 ) newsize = 20; + else newsize = 2*argsize; + newargs = (double *)malloc(sizeof(double)*newsize); + if ( args == 0 ) { args = newargs; argsize = newsize; } + else { + for ( i = 0; i < argsize; i++ ) newargs[i] = args[i]; + free(args); + args = newargs; argsize = newsize; + } + } + args[num-2] = x; args[num-1] = y; + } + if ( *s == '"' ) s++; + while ( *s == ' ' || *s == '\t' || *s == '\n' ) s++; + *num1 = num/2; + + if ( *s ) { + if ( ( extraargs = ReadTail(s,num2) ) == 0 ) { + return(0); + } + if ( num+*num2 > argsize ) { + newargs = (double *)malloc(sizeof(double)*(num+*num2)); + for ( i = 0; i < num; i++ ) newargs[i] = args[i]; + free(args); + args = newargs; + argsize = num+*num2; + } + for ( i = 0; i < *num2; i++ ) args[num+i] = extraargs[i]; + free(extraargs); + } + return(args); +} + +/* + #] ReadArray : + #[ ReadTail : + + Reads a command tail that consists of floating point numbers in the + notation xxx.yyy or just as integers without even the decimal point. + The output array is allocated and should be returned in a well behaved + program. +*/ + +double *ReadTail(char *buff,int *number) +{ + char *s; + int num = 1, i; + double *outargs; + s = buff; + while ( *s ) { + if ( *s == ' ' || *s == '\t' || *s == '\n' ) { + num++; *s++ = 0; + while ( *s == ' ' || *s == '\t' || *s == '\n' ) *s++ = 0; + } + else s++; + } + outargs = (double *)malloc(num*sizeof(double)); + s = buff; + for ( i = 0; i < num; i++ ) { + while ( *s == 0 ) s++; + s = ReadNumber(s,outargs+i); + if ( *s == 'p' && s[1] == 't' ) s += 2; + if ( *s != 0 ) { + fprintf(stderr,"%s: Illegal format for number in command %ld (%s) in file %s.\n" + ,axohelp,numobject,nameobject,inname); + free(outargs); + return(0); + } + } + *number = num; + return(outargs); +} + +/* + #] ReadTail : + #[ DoCurve : + + Interpolation curve expressed as a Bezier curve. +*/ + +void DoCurve(double x0, double y0, double x1, double y1, + double x2, double y2, double x3, double y3) +{ + double xx1, yy1, xx2, yy2; + xx1 = (2*x1+x2)/3; + yy1 = ((y1-y0)/(x1-x0)*(x2-x0)+(y2-y0)/(x2-x0)*(x1-x0)+y1+2*y0)/3; + xx2 = (x1+2*x2)/3; + yy2 = ((y2-y3)/(x2-x3)*(x1-x3)+(y1-y3)/(x1-x3)*(x2-x3)+y2+2*y3)/3; + + Bezier(xx1,yy1,xx2,yy2,x2,y2); +} + +/* + #] DoCurve : + #[ LengthBezier : + + Routine computes the length of a Bezier curve. + Method: + x = x0*(1-t)^3+3*x1*t*(1-t)^2+3*x2*t^2*(1-t)+x3*t^3 + y = y0*(1-t)^3+3*y1*t*(1-t)^2+3*y2*t^2*(1-t)+y3*t^3 + We assume that x0=y0=0. (Hence call with x1-x0 etc) + --> dx/dt = 3*x1*(1-t)*(1-3*t)+3*x2*t*(2-3*t)+3*x3*t^2 + = 3*(x1+2*t*(x2-2*x1)+t^2*(x3-3*x2+3*x1)) + --> L = int_0^1 dt * sqrt(dx^2+dy^2) + We use ordinary Gaussian quadratures over the domain -1,...,+1 + + We have here quadratures for 8, 16 or 32 points. + For the moment we use the 16 point quadrature. It seems to work well. + The numbers were taken from Abramowitz and Stegun. +*/ + +typedef struct quad { + double x; + double w; +} QUAD; + +QUAD g8[4] = { + { 0.183434642495650, 0.362683783378362 } + ,{ 0.525532409916329, 0.313706645877887 } + ,{ 0.796666477413627, 0.222381034453374 } + ,{ 0.960289856497536, 0.101228536290376 } + }; +QUAD g16[8] = { + { 0.095012509837637440185, 0.189450610455068496285 } + ,{ 0.281603550779258913230, 0.182603415044923588867 } + ,{ 0.458016777657227386342, 0.169156519395002538189 } + ,{ 0.617876244402643748447, 0.149595988816576732081 } + ,{ 0.755404408355003033895, 0.124628971255533872052 } + ,{ 0.865631202387831743880, 0.095158511682492784810 } + ,{ 0.944575023073232576078, 0.062253523938647892863 } + ,{ 0.989400934991649932596, 0.027152459411754094852 } + }; +QUAD g32[16] = { + { 0.048307665687738316235, 0.096540088514727800567 } + ,{ 0.144471961582796493485, 0.095638720079274859419 } + ,{ 0.239287362252137074545, 0.093844399080804565639 } + ,{ 0.331868602282127649780, 0.091173878695763884713 } + ,{ 0.421351276130635345364, 0.087652093004403811143 } + ,{ 0.506899908932229390024, 0.083311924226946755222 } + ,{ 0.587715757240762329041, 0.078193895787070306472 } + ,{ 0.663044266930215200975, 0.072345794108848506225 } + ,{ 0.732182118740289680387, 0.065822222776361846838 } + ,{ 0.794483795967942406963, 0.058684093478535547145 } + ,{ 0.849367613732569970134, 0.050998059262376176196 } + ,{ 0.896321155766052123965, 0.042835898022226680657 } + ,{ 0.934906075937739689171, 0.034273862913021433103 } + ,{ 0.964762255587506430774, 0.025392065309262059456 } + ,{ 0.985611511545268335400, 0.016274394730905670605 } + ,{ 0.997263861849481563545, 0.007018610009470096600 } + }; + +double LengthBezier(double x1,double y1,double x2,double y2,double x3,double y3,double tmax) +{ + double xa = 3*x1, xb = 6*(x2-2*x1), xc = 3*(x3-3*x2+3*x1); + double ya = 3*y1, yb = 6*(y2-2*y1), yc = 3*(y3-3*y2+3*y1); + double t, sum = 0, dx, dy; + int j; + + for ( j = 0; j < 8; j++ ) { + t = 0.5*(1+g16[j].x)*tmax; + dx = xa+t*(xb+t*xc); + dy = ya+t*(yb+t*yc); + sum += 0.5*g16[j].w*sqrt(dx*dx+dy*dy); + t = 0.5*(1-g16[j].x)*tmax; + dx = xa+t*(xb+t*xc); + dy = ya+t*(yb+t*yc); + sum += 0.5*g16[j].w*sqrt(dx*dx+dy*dy); + } + return(sum*tmax); +} + +/* + #] LengthBezier : + #] Service routines : + #[ ScanForObjects : + + Routine reads the input buffer and sets up pointers to the commands. + Basically it is responsible for checking the input syntax and making + sure all commands will have the proper number of arguments. +*/ + +long ScanForObjects(char *buffer) +{ + char *s = buffer, *t; + if ( *s == COMMENTCHAR ) { while ( *s && *s != '\n' ) s++; } + while ( *s ) { /* here we are to look for a new command */ + if ( *s != '[' ) { /* for the case of the very first character */ + while ( *s && ( *s != '[' || ( *s == '[' && s[-1] == '\\' ) ) ) { + if ( *s == ' ' || *s == '\n' ) { + while ( *s == ' ' || *s == '\n' ) s++; /* Skip blank lines */ + } + else if ( *s == COMMENTCHAR && s[-1] != '\\' ) { + while ( *s && *s != '\n' ) s++; + } + else s++; + } + } + if ( *s == 0 ) break; +/* + if everything is correct we are now on a [ + a: look for matching ] in the same line. This defines the label. +*/ + t = s+1; + while ( *t && *t != ']' && *t != '\n' && ( *t != COMMENTCHAR || + ( *t == COMMENTCHAR && t[-1] != '\\' ) ) ) t++; + if ( *t == 0 ) { + fprintf(stderr,"%s: irregular end of file %s.\n",axohelp,inname); + return(-1); + } + else if ( *t == '\n' ) { + fprintf(stderr,"%s: a label in file %s should inside a single line.\n",axohelp,inname); + return(-1); + } + else if ( *t == COMMENTCHAR ) { + fprintf(stderr,"%s: illegal comment character inside a label in file %s.\n",axohelp,inname); + return(-1); + } + else if ( *t != ']' ) { + fprintf(stderr,"%s: internal error reading a label in file %s.\n",axohelp,inname); + return(-1); + } +/* + Store the address of this command +*/ + if ( numinputs >= inputallocations ) { /* we need more space */ + long newnum, i; + char **newadd; + if ( inputallocations == 0 ) { newnum = 100; } + else { newnum = 2*inputallocations; } + if ( ( newadd = (char **)malloc(newnum*sizeof(char *)) ) == 0 ) { + fprintf(stderr,"%s: memory error reading file %s\n",axohelp,inname); + return(-1); + } + for ( i = 0; i < inputallocations; i++ ) { newadd[i] = inputs[i]; } + if ( inputs != 0 ) free(inputs); + inputs = newadd; + inputallocations = newnum; + } + inputs[numinputs++] = s; +/* + Now scan for the first comment character. That is the end of the object. +*/ + while ( *t && ( *t != TERMCHAR || ( *t == TERMCHAR && t[-1] == '\\' ) ) + && *t != '[' ) t++; + if ( *t != '[' ) { + while ( t[-1] == ' ' || t[-1] == '\n' ) t--; + *t++ = 0; + } + s = t; + } + return(numinputs); +} + +/* + #] ScanForObjects : + #[ ReadInput : +*/ + +char *ReadInput(char *filename) +{ + FILE *finput; + long filesize, num; + char *buffer; + if ( ( finput = fopen(filename,"r") ) == 0 ) { + fprintf(stderr,"%s: Cannot open file %s\n",axohelp,filename); + exit(-1); + } + if ( ( fseek(finput,0,SEEK_END) != 0 ) + || ( ( filesize = ftell(finput) ) < 0 ) + || ( fseek(finput,0,SEEK_SET) != 0 ) ) { + fprintf(stderr,"%s: File error in file %s\n",axohelp,filename); + exit(-1); + } + if ( ( buffer = malloc((filesize+1)*sizeof(char)) ) == 0 ) { + fprintf(stderr,"%s: Error allocating %ld bytes of memory",axohelp,filesize+1); + exit(-1); + } +/* + Assume character in file is 1 byte, which is true for all cases + we currently encounter. +*/ + num = fread( buffer, 1, filesize, finput ); + if ( ferror(finput) ) { + fprintf(stderr,"%s: Error reading file %s\n",axohelp,filename); + exit(-1); + } +/* + By definition, fread reads ALL the items specified, or it gets to + end-of-file, or there is an error. + It returns the actual number of items successfully read, which + is less than the number given in the 3rd argument ONLY if a + read error or end-of-file is encountered. + We have already tested for an error. + But num could legitimately be less than filesize, because of + translation of CRLF to LF (on MSWindows with MSWindows text file). +*/ + buffer[num] = 0; + fclose(finput); + return(buffer); +} + +/* + #] ReadInput : + #[ CleanupOutput : +*/ + +void CleanupOutput(char *str) +{ + char *s, *t; + int period = 0; + s = t = str; + while ( *s && *s != '}' ) { + if ( *s == '\n' ) *s = ' '; + if ( ( *s == ' ' || *s == '\n' ) && ( s[1] == ' ' || s[1] == '\n' ) ) s++; + else *t++ = *s++; + } + while ( *s ) *t++ = *s++; + *t = 0; + s = t = str; + while ( *s ) { + if ( *s == '.' ) { period = 1; *t++ = *s++; } + else if ( *s == '-' && s[1] == '0' && s[2] == ' ' ) { s++; } + else if ( *s <= '9' && *s >= '0' ) { *t++ = *s++; } + else if ( *s == '\n' && ( t > str && t[-1] == '\n' ) ) { s++; } + else if ( period ) { + while ( t > str && t[-1] == '0' ) t--; + if ( t > str && t[-1] == '.' ) t--; + while ( *s == ' ' && s[1] == ' ' ) s++; + period = 0; *t++ = *s++; + } + else if ( *s == ' ' && s[1] == ' ' ) s++; + else { + period = 0; *t++ = *s++; + } + } + *t = 0; + s = t = str; + while ( *s ) { + if ( *s == '-' && s[1] == '0' && s[2] == ' ' ) { s++; } + else *t++ = *s++; + } + *t = 0; +} + +/* + #] CleanupOutput : + #[ DoOneObject : +*/ + +int DoOneObject(char *cinput) +{ + int num, i, num1, num2; + char *s, *t, *StartClean; + double *argbuf = 0; + SetDefaults(); + s = cinput; while ( *s != '[' ) s++; + s++; t = s; while ( *t != ']' ) t++; + *t++ = 0; while ( *t == ' ' || *t == '\t' || *t == '\n' ) t++; + outpos = outputbuffer; + outpos += sprintf(outpos,"\\axo@setObject{%s}%%\n{%s%c}%%\n{",s,t,TERMCHAR); + if ( *s == '0' && s[1] == ']' ) { +/* + The identification line. + In due time we might add more options here. +*/ + if ( strcmp(nameobject,"AxodrawWantsPDF") == 0 ) { + identification = 1; + outpos += sprintf(outpos,"Axohelp version %d.%d. PDF output.}",VERSION,SUBVERSION); + fprintf(outfile,"%s",outputbuffer); + return(0); + } + else { + fprintf(stderr,"%s: Illegal request in identification string [0]: %s\n" + ,axohelp,nameobject); + if ( argbuf ) free(argbuf); + return(-1); + } + } +/* + if ( identification == 0 ) { + fprintf(stderr,"%s: No identification string. Check versions.\n",axohelp); + if ( argbuf ) free(argbuf); + return(-1); + } +*/ + StartClean = outpos; + + nameobject = t; while ( *t != ' ' && *t != '\t' && *t != '\n' && *t ) t++; + *t++ = 0; while ( *t == ' ' || *t == '\t' || *t == '\n' ) t++; +/* + Now nameobject is the name of the command and t points at the first parameter. +*/ + if ( ( strcmp(nameobject,"Curve") == 0 ) + || ( strcmp(nameobject,"Polygon") == 0 ) + || ( strcmp(nameobject,"FilledPolygon") == 0 ) ) { +/* + #[ Curve,Polygons : +*/ + if ( ( argbuf = ReadArray(t,&num1,&num2) ) == 0 ) return(-1); + if ( num2-1 != 0 ) { + fprintf(stderr,"%s: Command %s should have no extra numbers in %s.\n", + axohelp,nameobject,inname); + free(argbuf); + return(-1); + } + else { +/* + First some 'fixed' operations to set the state right + 1: scale 2: linewidth 3: color + Then the function. + Finally the trailer and cleanup. +*/ + axolinewidth = argbuf[2*num1+num2-1]; + SetLineWidth(axolinewidth); + if ( strcmp(nameobject,"Curve") == 0 ) { + Curve(argbuf,num1); + } + else if ( strcmp(nameobject,"Polygon") == 0 ) { + Polygon(argbuf,num1,0); + } + else if ( strcmp(nameobject,"FilledPolygon") == 0 ) { + Polygon(argbuf,num1,1); + } + free(argbuf); + } +/* + #] Curve,Polygons : +*/ + } + else if ( strcmp(nameobject,"DashCurve") == 0 ) { +/* + #[ DashCurve : +*/ + if ( ( argbuf = ReadArray(t,&num1,&num2) ) == 0 ) return(-1); + if ( num2 != 2 ) { + fprintf(stderr,"%s: Command %s does not have two numbers after the coordinates\n in file %s.\n", + axohelp,nameobject,inname); + free(argbuf); + return(-1); + } + else { +/* + First some 'fixed' operations to set the state right + 1: scale 2: linewidth 3: color + Then the function. + Finally the trailer and cleanup. +*/ + axolinewidth = argbuf[2*num1+num2-1]; + SetLineWidth(axolinewidth); + DashCurve(argbuf,num1); + free(argbuf); + } +/* + #] DashCurve : +*/ + } + else { +/* + #[ Regular command : +*/ + if ( ( argbuf = ReadTail(t,&num) ) == 0 ) return(-1); + for ( i = 0; i < sizeof(commands)/sizeof(KEYWORD); i++ ) { + if ( strcmp(nameobject,commands[i].name) == 0 ) { + if ( num == commands[i].numargs+1 ) { +/* + First some 'fixed' operations to set the state right + 1: scale 2: linewidth 3: color + Then the function. + Finally the trailer and cleanup. +*/ + axolinewidth = argbuf[num-1]; + SetLineWidth(axolinewidth); + (*(commands[i].func))(argbuf); + free(argbuf); + break; + } + else { + fprintf(stderr,"%s: Command %s should have %d(+1) arguments in %s.\n" + ,axohelp,nameobject,commands[i].numargs,inname); + free(argbuf); + return(-1); + } + } + } +/* + #] Regular command : +*/ + if ( i >= sizeof(commands)/sizeof(KEYWORD) ) { + fprintf(stderr,"%s: Command %s not recognized in file %s.\n", + axohelp,nameobject,inname); + free(argbuf); + return(-1); + } + } + outpos += sprintf(outpos,"}\n"); + CleanupOutput(StartClean); + fprintf(outfile,"%s",outputbuffer); + return(0); +} + +/* + #] DoOneObject : + #[ PrintHelp : +*/ + +void PrintHelp(char *name) +{ + fprintf(stderr,"This is %s v. %d.%d of %s\n", NAME, VERSION, SUBVERSION, VERSIONDATE); + fprintf(stderr,"Proper use is: %s [-h] [-v] filename\n",name); + fprintf(stderr,"Input will then be from filename.ax1, output to filename.ax2\n"); + fprintf(stderr,"-h : prints this help information and terminates.\n"); + fprintf(stderr,"-v : prints information about each function treated in stdout.\n"); + exit(-1); +} + +/* + #] PrintHelp : + #[ Inivars : +*/ + +void Inivars() +{ + M_pi = acos(-1.); + torad = M_pi/180.; + BzK = 4.*(sqrt(2.)-1.)/3.; +} + +/* + #] Inivars : + #[ main : +*/ + +int main(int argc,char **argv) +{ + char *s, *inbuffer; + int length, error = 0; + long num,i; + + Inivars(); + argc--; + axohelp = *argv++; + if ( argc <= 0 ) PrintHelp(axohelp); + s = *argv; + while ( *s == '-' ) { /* we have arguments */ + if ( s[1] == 'h' && s[2] == 0 ) PrintHelp(axohelp); + else if ( s[1] == 'v' && s[2] == 0 ) { + VerboseFlag = 1; + } + else { + fprintf(stderr,"Illegal option %s in call to %s\n",s,axohelp); + PrintHelp(axohelp); + } + argc--; argv++; + if ( argc <= 0 ) { + fprintf(stderr,"Not enough arguments in call to %s\n",axohelp); + PrintHelp(axohelp); + } + s = *argv; + } + if ( argc != 1 ) { + fprintf(stderr,"Too many arguments in call to %s\n",axohelp); + PrintHelp(axohelp); + } +/* + The filename is now in s. We should copy it to a separate string and + paste on the extension .ax1 (if needed). We should also construct the + name of the output file. +*/ + length = strlen(s); + inname = strcpy(malloc((length+5)*sizeof(char)),s); + outname = strcpy(malloc((length+5)*sizeof(char)),s); + s = inname + length; + if ( length > 4 && s[-4] == '.' && s[-3] == 'a' && s[-2] == 'x' && s[-1] == '1' ) { + outname[length-1] = '2'; + } + else { + inname[length] = '.'; inname[length+1] = 'a'; + inname[length+2] = 'x'; inname[length+3] = '1'; inname[length+4] = 0; + outname[length] = '.'; outname[length+1] = 'a'; + outname[length+2] = 'x'; outname[length+3] = '2'; outname[length+4] = 0; + } + if ( ( inbuffer = ReadInput(inname) ) == 0 ) return(-1); + if ( ( outfile = fopen(outname,"w") ) == 0 ) { + fprintf(stderr,"%s: Cannot create file %s\n",axohelp,outname); + exit(-1); + } + num = ScanForObjects(inbuffer); + for ( i = 0; i < num; i++ ) { + numobject = i+1; + if ( DoOneObject(inputs[i]) < 0 ) { error++; } + } + fclose(outfile); + if ( error > 0 ) { + fprintf(stderr,"%s: %d objects in %s were not translated correctly.\n", + axohelp,error,inname); + return(-1); + } + return(0); +} + +/* + #] main : + #[ routines : + #[ Line routines : + #[ Line : * + + Line(x1,y1)(x2,y2) +*/ + +void Line(double *args) +{ + MoveTo(args[0],args[1]); + LineTo(args[2],args[3]); + Stroke; +} + +/* + #] Line : + #[ DoubleLine : * + + DoubleLine(x1,y1)(x2,y2){sep} +*/ + +void DoubleLine(double *args) +{ + SaveGraphicsState; + if ( args[4] > 0 ) { + SetLineWidth(args[4]+axolinewidth); + Line(args); + SetLineWidth(args[4]-axolinewidth); + SetBackgroundColor(STROKING); + } + Line(args); + RestoreGraphicsState; +} + +/* + #] DoubleLine : + #[ DashLine : * + + DashLine(x1,y1)(x2,y2){dashsize} +*/ + +void DashLine(double *args) +{ + double dx = args[2]-args[0], dy = args[3]-args[1], dr = sqrt(dx*dx+dy*dy); + double dashsize = args[4]; + int num; + num = dr/dashsize; + if ( ( num%2 ) == 1 ) num++; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + Line(args); +} + +/* + #] DashLine : + #[ DashDoubleLine : * + + DashDoubleLine(x1,y1)(x2,y2){sep}{dashsize} +*/ + +void DashDoubleLine(double *args) +{ + double dx = args[2]-args[0], dy = args[3]-args[1], dr = sqrt(dx*dx+dy*dy); + double dashsize = args[5]; + int num; + num = dr/dashsize; + if ( ( num%2 ) == 1 ) num++; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + DoubleLine(args); +} + +/* + #] DashDoubleLine : + #[ ArrowLine : * + + ArrowLine(x1,y1)(x2,y2){size}{where} + + where: x of arrowhead is x1+where*(x2-x1). Same for y. + serves both ArrowLine and LongArrowLine +*/ + +void ArrowLine(double *args) +{ + double dx, dy, dr, where; + Line(args); + if ( arrow.type == 0 ) where = args[5]; + else where = arrow.where; + dx = args[2]-args[0]; + dy = args[3]-args[1]; + dr = sqrt(dx*dx+dy*dy); + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + SetTransferMatrix(1,0,0,1,dr*where,0); + if ( arrow.type == 0 ) arrow.width = args[4]; + ArrowHead(); +} + +/* + #] ArrowLine : + #[ ArrowDoubleLine : * + + ArrowDoubleLine(x1,y1)(x2,y2){sep}{size}{where} + + where: x of arrowhead is x1+where*(x2-x1). Same for y. + serves both ArrowLine and LongArrowLine +*/ + +void ArrowDoubleLine(double *args) +{ + double dx, dy, dr, where; + DoubleLine(args); + if ( arrow.type == 0 ) where = args[6]; + else where = arrow.where; + dx = args[2]-args[0]; + dy = args[3]-args[1]; + dr = sqrt(dx*dx+dy*dy); + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + SetTransferMatrix(1,0,0,1,dr*where,0); + if ( arrow.type == 0 ) arrow.width = args[5]+args[4]; + ArrowHead(); +} + +/* + #] ArrowDoubleLine : + #[ DashArrowLine : * + + DashArrowLine(x1,y1)(x2,y2){dashsize}{amplitude}{where} + + where: x of arrowhead is x1+where*(x2-x1). Same for y. + we re-adjust the position of the arrow to place it on a dash. +*/ + +void DashArrowLine(double *args) +{ + double dx = args[2]-args[0], dy = args[3]-args[1], dr = sqrt(dx*dx+dy*dy); + double dashsize = args[4], where; + int num, nw; + if ( arrow.type == 0 ) where = args[6]; + else where = arrow.where; + num = dr/dashsize; + if ( ( num%2 ) == 1 ) num++; + if ( num%4 != 0 && where > 0.499 && where < 0.501 ) num += 2; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + Line(args); + nw = where*(num/2)+0.5; + where = (2.0*nw)/num; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + SetTransferMatrix(1,0,0,1,dr*where,0); + if ( arrow.type == 0 ) arrow.width = args[5]; + ArrowHead(); +} + +/* + #] DashArrowLine : + #[ DashArrowDoubleLine : * + + DashArrowDoubleLine(x1,y1)(x2,y2){sep}{dashsize}{amplitude}{where} + + where: x of arrowhead is x1+where*(x2-x1). Same for y. + we re-adjust the position of the arrow to place it on a dash. +*/ + +void DashArrowDoubleLine(double *args) +{ + double dx = args[2]-args[0], dy = args[3]-args[1], dr = sqrt(dx*dx+dy*dy); + double dashsize = args[5], where; + int num, nw; + if ( arrow.type == 0 ) where = args[7]; + else where = arrow.where; + num = dr/dashsize; + if ( ( num%2 ) == 1 ) num++; + if ( num%4 != 0 && where > 0.499 && where < 0.501 ) num += 2; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + DoubleLine(args); + nw = where*(num/2)+0.5; + where = (2.0*nw)/num; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + SetTransferMatrix(1,0,0,1,dr*where,0); + if ( arrow.type == 0 ) arrow.width = args[6]+args[4]; + ArrowHead(); +} + +/* + #] DashArrowDoubleLine : + #] Line routines : + #[ Arc routines : + #[ CArc : * + + CArc(x1,y1)(r,phi1,phi2) + + The arc segment runs anticlockwise + + We divide the segment into a number of equal segments, each less + than 90 degrees. Then the control points are at distance + 4*tan(90/n)/3 from the endpoints, in which n=360/(phi2-phi1) + (note that if n=4 we get tan(22.5)=sqrt(2)-1). +*/ + +void CArc(double *args) +{ + double phi1 = args[3], phi2 = args[4], r = args[2]; + double dphi; + while ( phi2 < phi1 ) phi2 += 360; + dphi = phi2-phi1; + if ( dphi <= 0 ) { return; } + if ( dphi >= 360 ) { ECirc(args); return; } + SetTransferMatrix(1,0,0,1,args[0],args[1]); + ArcSegment(r,phi1,dphi); + Stroke; +} + +/* + #] CArc : + #[ DoubleArc : * + + DoubleArc(x1,y1)(r,phi1,phi2){sep} + + The arc segment runs anticlockwise + + We divide the segment into a number of equal segments, each less + than 90 degrees. Then the control points are at distance + 4*tan(90/n)/3 from the endpoints, in which n=360/(phi2-phi1) + (note that if n=4 we get tan(22.5)=sqrt(2)-1). +*/ + +void DoubleArc(double *args) +{ + double phi1 = args[3], phi2 = args[4], r = args[2]; + double dphi, sep = args[5]; + while ( phi2 < phi1 ) phi2 += 360; + dphi = phi2-phi1; + if ( dphi <= 0 ) { return; } + SetTransferMatrix(1,0,0,1,args[0],args[1]); + ArcSegment(r+sep/2,phi1,dphi); + Stroke; + ArcSegment(r-sep/2,phi1,dphi); + Stroke; +} + +/* + #] DoubleArc : + #[ DashCArc : * + + DashCArc(x1,y1)(r,phi1,phi2){dashsize} + + The arc segment runs anticlockwise +*/ + +void DashCArc(double *args) +{ + double arcsize = args[4]-args[3]; + double r = args[2], dr, dashsize = args[5]; + int num; + if ( arcsize <= 0 ) arcsize += 360; + if ( arcsize > 360 ) arcsize = 360; + dr = 2*M_pi*r*(arcsize/360); + num = dr/dashsize; + if ( (num%2) == 1 ) num++; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + CArc(args); +} + +/* + #] DashCArc : + #[ DashDoubleArc : * + + DashDoubleArc(x1,y1)(r,phi1,phi2){sep}{dashsize} + + The arc segment runs anticlockwise + The trouble here is to synchronize the two dash patterns. + This is done by a rescaling. We assume that the rescaling is + sufficiently small that the linewidth does not suffer from it. +*/ + +void DashDoubleArc(double *args) +{ + double phi1 = args[3], r = args[2]; + double arcsize = args[4]-args[3]; + double dr, dashsize = args[6], sep = args[5]; + int num; + linesep = sep; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + if ( arcsize <= 0 ) arcsize += 360; + if ( arcsize > 360 ) arcsize = 360; + dr = 2*M_pi*r*(arcsize/360); + num = dr/dashsize; + if ( (num%2) == 1 ) num++; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + SaveGraphicsState; + SetTransferMatrix(1+0.5*sep/r,0,0,1+0.5*sep/r,0,0); + ArcSegment(r,phi1,arcsize); + Stroke; + RestoreGraphicsState; + SaveGraphicsState; + SetTransferMatrix(1-0.5*sep/r,0,0,1-0.5*sep/r,0,0); + ArcSegment(r,phi1,arcsize); + Stroke; + RestoreGraphicsState; +} + +/* + #] DashDoubleArc : + #[ ArrowArc : * + + ArrowArc(x1,y1)(r,phi1,phi2){amplitude}{where} + + where: phi of arrowhead is phi1+where*(phi2-phi1) + The arc segment runs anticlockwise + serves both ArrowArc and LongArrowArc and ... (Jaxodraw addition) +*/ + +void ArrowArc(double *args) +{ + double phi1 = args[3], phi2 = args[4], r = args[2]; + double dphi, x, y, phi; + if ( arrow.type == 0 ) { + arrow.width = args[5]; + arrow.where = args[6]; + } + + while ( phi2 < phi1 ) phi2 += 360; + dphi = phi2-phi1; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + + if ( dphi <= 0 ) { return; } + ArcSegment(r,phi1,dphi); + Stroke; +/* + Now compute the position and angle of the arrowhead +*/ + phi = phi1 + arrow.where*dphi; + x = r*COS(phi); y = r*SIN(phi); + SetTransferMatrix(1,0,0,1,x,y); + SetTransferMatrix(COS(phi+90),SIN(phi+90),-SIN(phi+90),COS(phi+90),0,0); + ArrowHead(); +} + +/* + #] ArrowArc : + #[ ArrowDoubleArc : * + + ArrowDoubleArc(x1,y1)(r,phi1,phi2){sep}{amplitude}{where} + + where: phi of arrowhead is phi1+where*(phi2-phi1) + The arc segment runs anticlockwise + serves both ArrowArc and LongArrowArc and ... (Jaxodraw addition) +*/ + +void ArrowDoubleArc(double *args) +{ + double phi1 = args[3], phi2 = args[4], r = args[2]; + double dphi, x, y, phi; + linesep = args[5]; + while ( phi2 < phi1 ) phi2 += 360; + dphi = phi2-phi1; + if ( dphi <= 0 ) { return; } + SetTransferMatrix(1,0,0,1,args[0],args[1]); + ArcSegment(r+linesep/2,phi1,dphi); + Stroke; + ArcSegment(r-linesep/2,phi1,dphi); + Stroke; +/* + Now compute the position and angle of the arrowhead +*/ + if ( arrow.type == 0 ) { + arrow.width = args[6]; + arrow.where = args[7]; + } + phi = phi1 + arrow.where*dphi; + x = r*COS(phi); y = r*SIN(phi); + SetTransferMatrix(1,0,0,1,x,y); + SetTransferMatrix(COS(phi+90),SIN(phi+90),-SIN(phi+90),COS(phi+90),0,0); + ArrowHead(); +} + +/* + #] ArrowDoubleArc : + #[ DashArrowArc : + + + DashArrowArc(x1,y1)(r,phi1,phi2){dashsize}{amplitude}{where} + + where: phi of arrowhead is phi1+where*(phi2-phi1) + The arc segment runs anticlockwise +*/ + +void DashArrowArc(double *args) +{ + double dphi, x, y, phi, phi1 = args[3], phi2 = args[4]; + double r = args[2], dr, dashsize = args[5]; + int num; + if ( arrow.type == 0 ) { + arrow.width = args[6]; + arrow.where = args[7]; + } + + while ( phi2 < phi1 ) phi2 += 360; + dphi = phi2-phi1; + if ( dphi > 360 ) dphi = 360; + dr = 2*M_pi*r*(dphi/360); + num = dr/dashsize; + if ( (num%2) == 1 ) num++; + if ( num%4 != 0 && arrow.where > 0.499 && arrow.where < 0.501 ) num += 2; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + SetTransferMatrix(1,0,0,1,args[0],args[1]); + if ( dphi <= 0 ) { return; } + ArcSegment(r,phi1,dphi); + Stroke; +/* + Now compute the position and angle of the arrowhead +*/ + phi = phi1 + arrow.where*dphi; + x = r*COS(phi); y = r*SIN(phi); + SetTransferMatrix(1,0,0,1,x,y); + SetTransferMatrix(COS(phi+90),SIN(phi+90),-SIN(phi+90),COS(phi+90),0,0); + ArrowHead(); +} + +/* + #] DashArrowArc : + #[ DashArrowDoubleArc : + + + DashArrowDoubleArc(x1,y1)(r,phi1,phi2){sep}{dashsize}{amplitude}{where} + + where: phi of arrowhead is phi1+where*(phi2-phi1) + The arc segment runs anticlockwise +*/ + +void DashArrowDoubleArc(double *args) +{ + double dphi, x, y, phi, phi1 = args[3], phi2 = args[4]; + double r = args[2], dr, dashsize = args[6]; + int num; + linesep = args[5]; + if ( arrow.type == 0 ) { + arrow.width = args[7]; + arrow.where = args[8]; + } + + while ( phi2 < phi1 ) phi2 += 360; + dphi = phi2-phi1; + if ( dphi > 360 ) dphi = 360; + dr = 2*M_pi*r*(dphi/360); + num = dr/dashsize; + if ( (num%2) == 1 ) num++; + if ( num%4 != 0 && arrow.where > 0.499 && arrow.where < 0.501 ) num += 2; + dashsize = dr/num; + SetDashSize(dashsize,dashsize/2); + SetTransferMatrix(1,0,0,1,args[0],args[1]); + if ( dphi <= 0 ) { return; } + SaveGraphicsState; + SetTransferMatrix(1+0.5*linesep/r,0,0,1+0.5*linesep/r,0,0); + ArcSegment(r,phi1,dphi); + Stroke; + RestoreGraphicsState; + SaveGraphicsState; + SetTransferMatrix(1-0.5*linesep/r,0,0,1-0.5*linesep/r,0,0); + ArcSegment(r,phi1,dphi); + Stroke; + RestoreGraphicsState; +/* + Now compute the position and angle of the arrowhead +*/ + phi = phi1 + arrow.where*dphi; + x = r*COS(phi); y = r*SIN(phi); + SetTransferMatrix(1,0,0,1,x,y); + SetTransferMatrix(COS(phi+90),SIN(phi+90),-SIN(phi+90),COS(phi+90),0,0); + ArrowHead(); +} + +/* + #] DashArrowDoubleArc : + #[ ArrowArcn : + + + ArrowArcn(x1,y1)(r,phi1,phi2){amplitude}{where} + + where: phi of arrowhead is phi1+where*(phi2-phi1) + The arc segment runs clockwise +*/ + +void ArrowArcn(double *args) +{ + double newargs[7], a; + int i; + for ( i = 0; i < 7; i++ ) newargs[i] = args[i]; + newargs[6] = 1-newargs[6]; + a = newargs[3]; newargs[3] = newargs[4]; newargs[4] = a; + ArrowArc(newargs); +} + +/* + #] ArrowArcn : + #[ DashArrowArcn : + + + DashArrowArc(x1,y1)(r,phi1,phi2){amplitude}{where}{dashsize} + + where: phi of arrowhead is phi1+where*(phi2-phi1) + The arc segment runs clockwise +*/ + +void DashArrowArcn(double *args) +{ + double newargs[8], a; + int i; + for ( i = 0; i < 8; i++ ) newargs[i] = args[i]; + newargs[6] = 1-newargs[6]; + a = newargs[3]; newargs[3] = newargs[4]; newargs[4] = a; + DashArrowArc(newargs); +} + +/* + #] DashArrowArcn : + #] Arc routines : + #[ Circle routines : + #[ ECirc : + + + ECirc(x,y){radius} + Draws a circle +*/ + +void ECirc(double *args) +{ + SetTransferMatrix(1,0,0,1,args[0],args[1]); + BezierCircle(args[2],"S"); +} + +/* + #] ECirc : + #[ FOval : + + + FOval(x1,y1)(h,w) filled oval in default color + +*/ + +void FOval(double *args) +{ + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of oval */ + SetTransferMatrix(COS(args[4]),SIN(args[4]),-SIN(args[4]),COS(args[4]),0,0); + BezierOval(args[3],args[2],"f"); + BezierOval(args[3],args[2],"S"); +} + +/* + #] COval : + #[ Oval : + + + Oval(x1,y1)(h,w)(phi) + + One way would be with different scales in the x and y direction, + but that messes up the linewidth. + We need to describe quarter ovals with Bezier curves. The proper + parameters for the curves we can obtain from the circle with scaling. +*/ + +void Oval(double *args) +{ + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of oval */ + SetTransferMatrix(COS(args[4]),SIN(args[4]),-SIN(args[4]),COS(args[4]),0,0); + BezierOval(args[3],args[2],"S"); +} + +/* + #] Oval : + #] Circle routines : + #[ Box routines : + #[ EBox : * + + \EBox(#1,#2)(#3,#4) + + Draws a box with the left bottom at (x1,y1) and the right top + at (x2,y2). + Transparent interior. Current color for edge. +*/ + +void EBox(double *args) +{ + Rectangle(args[0],args[1],args[2]-args[0],args[3]-args[1]); + Stroke; +} + +/* + #] EBox : + #[ FBox : * + + \FBox(#1,#2)(#3,#4) + + Draws a filled box with the left bottom at (x1,y1) and + the right top at (x2,y2). + Current color. +*/ + +void FBox(double *args) +{ + Rectangle(args[0],args[1],args[2]-args[0],args[3]-args[1]); + Fill; +} + +/* + #] FBox : + #[ Boxc : * + + \Boxc(#1,#2)(#3,#4) + + Draws a transparent box with the center at (x1,y1). + The width and height are (3,4). Uses current color. +*/ + +void Boxc(double *args) +{ + Rectangle(args[0]-args[2]/2,args[1]-args[3]/2,args[2],args[3]); + Stroke; +} + +/* + #] Boxc : + #[ FBoxc : * + + \FBoxc(#1,#2)(#3,#4) + + Draws a filled box with the center at (x1,y1). + The width and height are (3,4). Uses current color. +*/ + +void FBoxc(double *args) +{ + Rectangle(args[0]-args[2]/2,args[1]-args[3]/2,args[2],args[3]); + Fill; +} + +/* + #] FBoxc : + #] Box routines : + #[ Triangle routines : + #[ ETri : * + + \ETri(#1,#2)(#3,#4)(#5,#6) + + Draws a triangle with the three corners. +*/ + +void ETri(double *args) +{ + Triangle(args[0],args[1],args[2],args[3],args[4],args[5]); + Stroke; +} + +/* + #] ETri : + #[ FTri : * + + \FTri(#1,#2)(#3,#4)(#5,#6) + + Draws a triangle with the three corners. +*/ + +void FTri(double *args) +{ + Triangle(args[0],args[1],args[2],args[3],args[4],args[5]); + Fill; +} + +/* + #] FTri : + #] Triangle routines : + #[ Particle routines : + #[ Vertex : + + + Vertex(x,y){radius} + Draws a filled circle +*/ + +void Vertex(double *args) +{ + SetTransferMatrix(1,0,0,1,args[0],args[1]); + BezierCircle(args[2],"f"); +} + +/* + #] Vertex : + #[ ComputeDash : +*/ + +double ComputeDash(double *args,double dr,double indash) +{ + int numwindings = args[5]+0.5, numdashes; + int numhalfwindings = 2*numwindings+2.1; + double onehalfwinding = dr/numhalfwindings; + double amp8 = fabs(args[4])*0.9; + double size = LengthBezier(-amp8,0, -amp8,2*args[4], onehalfwinding,2*args[4],1.0); + + numdashes = size/(2*indash); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*indash*numdashes) > fabs(size-2*indash*(numdashes+1)) ) + numdashes++; + return(size/(2*numdashes)); +} + +/* + #] ComputeDash : + #[ ComputeDashCirc : +*/ + +double ComputeDashCirc(double *args,double indash) +{ + int num = args[5]+0.5, numdashes; + double ampi = args[4], radius = args[2]; + double darc; + double dr,conv,inc; + double amp1,amp2,amp4,amp5,amp8; + double x0,x1,x2,x3,y0,y1,y2,y3,xx,size; + darc = 360.; + dr = darc*torad*radius; + conv = 1.0/radius; + inc = dr/(2*num); /* increment per half winding */ + amp8 = ampi*0.9; + amp1 = radius+ampi; + amp2 = radius-ampi; + amp4 = amp1/cos((inc+amp8)*conv); + amp5 = amp2/cos(amp8*conv); + if ( amp8 < 0 ) amp8 = -amp8; + xx = 2*inc; + x0 = amp1*cos(inc*conv); + y0 = amp1*sin(inc*conv); + x1 = amp4*cos((xx+amp8)*conv)-x0; + y1 = amp4*sin((xx+amp8)*conv)-y0; + x2 = amp5*cos((xx+amp8)*conv)-x0; + y2 = amp5*sin((xx+amp8)*conv)-y0; + x3 = amp2*cos(xx*conv)-x0; + y3 = amp2*sin(xx*conv)-y0; + size = LengthBezier(x1,y1,x2,y2,x3,y3,1.0); + numdashes = size/(2*indash); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*indash*numdashes) > fabs(size-2*indash*(numdashes+1)) ) + numdashes++; + return(size/(2*numdashes)); +} + +/* + #] ComputeDashCirc : + #[ ComputeDashPhotonArc : +*/ + +double ComputeDashPhotonArc(double *args,double darc,double dashsize,double *dashstart) +{ + int numdashes, numd; + double len1, len2, size, size2, ampli = args[5], radius = args[2]; + double cp = cos(darc); + double sp = sin(darc); + double cp2 = cos(darc/2.); + double sp2 = sin(darc/2.); + double beta = radius*darc/(M_pi*ampli); + double tt = (sp-cp*beta)/(cp+sp*beta); + double x2 = ((radius+ampli)*8*(beta*cp2-sp2)-(beta*(4+cp) + +(tt*cp*3.-sp*4.))*radius)/((beta-tt)*3.); + double x1 = ((radius+ampli)*8.*cp2-(1+cp)*radius)/3.-x2; + double y1 = (x1-radius)*beta; + double y2 = (x2-radius*cp)*tt+radius*sp; + double x3 = radius*cp; + double y3 = radius*sp; + len1 = LengthBezier(x1-radius,y1,x2-radius,y2,x3-radius,y3,1.0); + ampli = -ampli; + beta = radius*darc/(M_pi*ampli); + tt = (sp-cp*beta)/(cp+sp*beta); + x2 = ((radius+ampli)*8*(beta*cp2-sp2)-(beta*(4+cp) + +(tt*cp*3.-sp*4.))*radius)/((beta-tt)*3.); + x1 = ((radius+ampli)*8.*cp2-(1+cp)*radius)/3.-x2; + y1 = (x1-radius)*beta; + y2 = (x2-radius*cp)*tt+radius*sp; + x3 = radius*cp; + y3 = radius*sp; + len2 = LengthBezier(x1-radius,y1,x2-radius,y2,x3-radius,y3,1.0); + size = (len1+len2)/2; + size2 = len1/2; + numdashes = size/(2*dashsize); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = size/(2*numdashes); + numd = size2/(2*dashsize); + *dashstart = -(size2 - 2*numd*dashsize) + dashsize/2; + if ( *dashstart < 0 ) *dashstart += 2*dashsize; + return(dashsize); +} + +/* + #] ComputeDashPhotonArc : + #[ ComputeDashGluonArc : +*/ + +double ComputeDashGluonArc(double *args,double darc,double dashsize) +{ + int numdashes, num = args[6]; + double radius = args[2], ampi = args[5]; + double dr,conv,inc, size; + double amp1,amp2,amp4,amp5,amp8; + double x1,x2,x3,y1,y2,y3,xx,x3p,y3p; + dr = darc*torad*radius; + conv = 1.0/radius; + inc = dr/(2*num+2); /* increment per half winding */ + amp8 = ampi*0.9; + amp1 = radius+ampi; + amp2 = radius-ampi; + amp4 = amp1/cos((inc+amp8)*conv); + amp5 = amp2/cos(amp8*conv); + if ( amp8 < 0 ) amp8 = -amp8; + + xx = 2*inc; + x3p = amp2*cos(xx*conv); + y3p = amp2*sin(xx*conv); + x1 = amp5*cos((xx-amp8)*conv)-x3p; + y1 = amp5*sin((xx-amp8)*conv)-y3p; + x2 = amp4*cos((xx-amp8)*conv)-x3p; + y2 = amp4*sin((xx-amp8)*conv)-y3p; + x3 = amp1*cos((xx+inc)*conv)-x3p; + y3 = amp1*sin((xx+inc)*conv)-y3p; + size = LengthBezier(x1,y1,x2,y2,x3,y3,1.0); + + numdashes = size/(2*dashsize); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = size/(2*numdashes); + return(dashsize); +} + +/* + #] ComputeDashGluonArc : + #[ GluonHelp : + + We draw the gluon in two strokes. This is due to the possibility + of a dash pattern. We want the dashes to be nicely symmetric on + the central windings. That means that either the start and end need + a different size dashes, or we draw the start 'backwards'. + We have chosen for the last solution. +*/ + +void GluonHelp(double *args,double dr) +{ + int numwindings = args[5]+0.5; + int numhalfwindings = 2*numwindings+2.1; + double onehalfwinding = dr/numhalfwindings; + double amp8 = fabs(args[4])*0.9; + double xx = 2*onehalfwinding; + int i; + MoveTo(xx,-args[4]); + Bezier(xx+amp8,-args[4],xx+amp8,args[4],1.4*onehalfwinding,args[4]); + Bezier(0.5*onehalfwinding,args[4], + 0.1*onehalfwinding,args[4]*0.5,0,0); + Stroke; + MoveTo(xx,-args[4]); + for ( i = 0; i < numwindings-1; i++ ) { + Bezier(xx-amp8,-args[4], xx-amp8,args[4], xx+onehalfwinding,args[4]); + xx += 2*onehalfwinding; + Bezier(xx+amp8,args[4], xx+amp8,-args[4], xx,-args[4]); + } + Bezier(xx-amp8,-args[4], xx-amp8,args[4], xx+onehalfwinding*0.6,args[4]); + Bezier(dr-onehalfwinding*0.5,args[4], + dr-onehalfwinding*0.1,args[4]*0.5, + dr,0); + Stroke; +} + +/* + #] GluonHelp : + #[ GluonCircHelp : +*/ + +void GluonCircHelp(double *args) +{ + int num = args[5], i; + double ampi = args[4], radius = args[2]; + double darc; + double dr,conv,inc; + double amp1,amp2,amp4,amp5,amp8; + double x1,x2,x3,y1,y2,y3,xx; + darc = 360.; + dr = darc*torad*radius; + conv = 1.0/radius; + inc = dr/(2*num); /* increment per half winding */ + amp8 = ampi*0.9; + amp1 = radius+ampi; + amp2 = radius-ampi; + amp4 = amp1/cos((inc+amp8)*conv); + amp5 = amp2/cos(amp8*conv); + if ( amp8 < 0 ) amp8 = -amp8; + xx = 2*inc; + x3 = amp1*cos(inc*conv); + y3 = amp1*sin(inc*conv); + MoveTo(x3,y3); +/* + Now the loop +*/ + for ( i = 0; i < num; i++ ) { + x1 = amp4*cos((xx+amp8)*conv); + y1 = amp4*sin((xx+amp8)*conv); + x2 = amp5*cos((xx+amp8)*conv); + y2 = amp5*sin((xx+amp8)*conv); + x3 = amp2*cos(xx*conv); + y3 = amp2*sin(xx*conv); + Bezier(x1,y1,x2,y2,x3,y3); + x1 = amp5*cos((xx-amp8)*conv); + y1 = amp5*sin((xx-amp8)*conv); + x2 = amp4*cos((xx-amp8)*conv); + y2 = amp4*sin((xx-amp8)*conv); + x3 = amp1*cos((xx+inc)*conv); + y3 = amp1*sin((xx+inc)*conv); + Bezier(x1,y1,x2,y2,x3,y3); + xx += 2*inc; + } + Stroke; +} + +/* + #] GluonCircHelp : + #[ GluonArcHelp : +*/ + +void GluonArcHelp(double *args, double darc, double ampi) +{ + int num = args[6], i; + double radius = args[2]; + double dr,conv,inc; + double amp1,amp2,amp3,amp4,amp5,amp6,amp7,amp8; + double x1,x2,x3,y1,y2,y3,xx,x1p,y1p,x2p,y2p,x3p,y3p; + dr = darc*torad*radius; + conv = 1.0/radius; + inc = dr/(2*num+2); /* increment per half winding */ + amp8 = ampi*0.9; + amp1 = radius+ampi; + amp2 = radius-ampi; + amp3 = radius+ampi/2; + amp4 = amp1/cos((inc+amp8)*conv); + amp5 = amp2/cos(amp8*conv); + amp6 = amp1/cos((inc*0.6+amp8)*conv); + amp7 = amp1/cos(inc*0.9*conv); + if ( amp8 < 0 ) amp8 = -amp8; + xx = 2*inc; +/* + First the starting part. We draw it separately because there could + be a dashing pattern. This way the windings come out best. +*/ + x1 = amp3*cos(inc*0.1*conv); + y1 = amp3*sin(inc*0.1*conv); + x2 = amp7*cos(inc*0.5*conv); + y2 = amp7*sin(inc*0.5*conv); + x3 = amp1*cos(inc*1.4*conv); + y3 = amp1*sin(inc*1.4*conv); + x1p = amp6*cos((xx+amp8)*conv); + y1p = amp6*sin((xx+amp8)*conv); + x2p = amp5*cos((xx+amp8)*conv); + y2p = amp5*sin((xx+amp8)*conv); + x3p = amp2*cos(xx*conv); + y3p = amp2*sin(xx*conv); + MoveTo(x3p,y3p); + Bezier(x2p,y2p,x1p,y1p,x3,y3); + Bezier(x2,y2,x1,y1,radius,0); + Stroke; +/* + Now the loop +*/ + MoveTo(x3p,y3p); + for ( i = 1; i < num; i++ ) { + x1 = amp5*cos((xx-amp8)*conv); + y1 = amp5*sin((xx-amp8)*conv); + x2 = amp4*cos((xx-amp8)*conv); + y2 = amp4*sin((xx-amp8)*conv); + x3 = amp1*cos((xx+inc)*conv); + y3 = amp1*sin((xx+inc)*conv); + Bezier(x1,y1,x2,y2,x3,y3); + xx += 2*inc; + x1 = amp4*cos((xx+amp8)*conv); + y1 = amp4*sin((xx+amp8)*conv); + x2 = amp5*cos((xx+amp8)*conv); + y2 = amp5*sin((xx+amp8)*conv); + x3 = amp2*cos(xx*conv); + y3 = amp2*sin(xx*conv); + Bezier(x1,y1,x2,y2,x3,y3); + } +/* + And now the end point +*/ + x1 = amp5*cos((xx-amp8)*conv); + y1 = amp5*sin((xx-amp8)*conv); + x2 = amp6*cos((xx-amp8)*conv); + y2 = amp6*sin((xx-amp8)*conv); + x3 = amp1*cos((xx+inc*0.6)*conv); + y3 = amp1*sin((xx+inc*0.6)*conv); + Bezier(x1,y1,x2,y2,x3,y3); + x1 = amp7*cos((xx+inc*1.5)*conv); + y1 = amp7*sin((xx+inc*1.5)*conv); + x2 = amp3*cos((dr-inc*0.1)*conv); + y2 = amp3*sin((dr-inc*0.1)*conv); + x3 = radius*cos(dr*conv); + y3 = radius*sin(dr*conv); + + Bezier(x1,y1,x2,y2,x3,y3); + + Stroke; +} + +/* + #] GluonArcHelp : + #[ PhotonHelp : +*/ + +void PhotonHelp(double *args, double dr) +{ + int numhalfwindings = args[5]*2+0.5; + double onehalfwinding = dr/numhalfwindings; + double y = 4.*args[4]/3; + double x, xx; + int i; + MoveTo(0,0); +/* + Now loop over the half windings, alternating the sign of the y's +*/ + x = (4*onehalfwinding)/3/M_pi; xx = 0; + for ( i = 0; i < numhalfwindings; i++, y = -y ) { + Bezier(xx+x,y, xx+onehalfwinding-x,y, xx+onehalfwinding,0); + xx += onehalfwinding; + } + Stroke; +} +/* + #] PhotonHelp : + #[ PhotonArcHelp : +*/ + +void PhotonArcHelp(double *args,double arcend,int num) +{ + int i; + double ampli = args[5], radius = args[2]; + double cp,sp,cp2,sp2,cpi,spi; + double x1,x2,x3,y1,y2,y3,beta,tt; + + cp = cos(arcend); + sp = sin(arcend); + cp2 = cos(arcend/2.); + sp2 = sin(arcend/2.); + + MoveTo(radius,0); + for ( i = 0; i < num; i++, ampli = -ampli ) { + cpi = cos(i*arcend); + spi = sin(i*arcend); + beta = radius*arcend/(M_pi*ampli); + tt = (sp-cp*beta)/(cp+sp*beta); + x2 = ((radius+ampli)*8*(beta*cp2-sp2)-(beta*(4+cp) + +(tt*cp*3.-sp*4.))*radius)/((beta-tt)*3.); + x1 = ((radius+ampli)*8.*cp2-(1+cp)*radius)/3.-x2; + y1 = (x1-radius)*beta; + y2 = (x2-radius*cp)*tt+radius*sp; + x3 = radius*cp; + y3 = radius*sp; + Bezier(cpi*x1-spi*y1,cpi*y1+spi*x1, + cpi*x2-spi*y2,cpi*y2+spi*x2, + cpi*x3-spi*y3,cpi*y3+spi*x3); + } + Stroke; +} + +/* + #] PhotonArcHelp : + #[ ZigZagHelp : +*/ + +void ZigZagHelp(double *args, double dr) +{ + int numhalfwindings = args[5]*2+0.5; + double onehalfwinding = dr/numhalfwindings; + double x = onehalfwinding, y = args[4]; + int i; + MoveTo(0,0); +/* + Now loop over the half windings, alternating the sign of the y's +*/ + for ( i = 0; i < numhalfwindings; i++, y = -y ) { + LineTo(x-onehalfwinding/2.,y); LineTo(x,0); + x += onehalfwinding; + } + Stroke; +} + +/* + #] ZigZagHelp : + #[ ZigZagArcHelp : +*/ + +void ZigZagArcHelp(double *args) +{ + int num = 2*args[6]-0.5, i; + double amp = args[5], r = args[2]; + double arcstart = args[3], arcend = args[4], darc; + if ( arcend < arcstart ) arcend += 360.; + darc = (arcend-arcstart)/(num+1); + MoveTo(r*COS(arcstart),r*SIN(arcstart)); + arcstart += darc/2; + for ( i = 0; i <= num; i++, amp = -amp ) { + LineTo((r+amp)*COS(arcstart+darc*i),(r+amp)*SIN(arcstart+darc*i)); + } + LineTo(r*COS(arcend),r*SIN(arcend)); + Stroke; +} + +/* + #] ZigZagArcHelp : + #[ Gluon : * + + Gluon(x1,y1)(x2,y2){amplitude}{windings} + + Each half winding is one cubic Bezier curve. + In addition the end points are different Bezier curves. +*/ + +void Gluon(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + GluonHelp(args,dr); +} + +/* + #] Gluon : + #[ DashGluon : * + + DashGluon(x1,y1)(x2,y2){amplitude}{windings}{dashsize} + + Each half winding is one cubic Bezier curve. + In addition the end points are different Bezier curves. +*/ + +void DashGluon(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + double dashsize; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + + dashsize = ComputeDash(args,dr,args[6]); + SetDashSize(dashsize,dashsize/2); + GluonHelp(args,dr); +} + +/* + #] DashGluon : + #[ GluonCirc : * + + GluonCirc(x1,y1)(r,phi){amplitude}{windings} + + Draws a gluon on a circle + x_center,y_center,radius,phase_angle,gluon_radius,num + in which num is the number of windings of the gluon. + Method: Same as GluonArc, but without special start and end +*/ + +void GluonCirc(double *args) +{ + int num = args[5]; + double arcstart = args[3]; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + arcstart += 360./(2*num); /* extra phase to make 0 angle more accessible */ + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + + GluonCircHelp(args); +} + +/* + #] GluonCirc : + #[ DashGluonCirc : * + + DashGluonCirc(x1,y1)(r,phi){amplitude}{windings}{dashsize} + + Draws a gluon on a circle + x_center,y_center,radius,phase_angle,gluon_radius,num + in which num is the number of windings of the gluon. + Method: Same as GluonArc, but without special start and end +*/ + +void DashGluonCirc(double *args) +{ + int num = args[5]; + double arcstart = args[3], dashsize; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + arcstart += 360./(2*num); /* extra phase to make 0 angle more accessible */ + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + + dashsize = ComputeDashCirc(args,args[6]); + + SetDashSize(dashsize,dashsize/2); + GluonCircHelp(args); +} + +/* + #] DashGluonCirc : + #[ GluonArc : * + + GluonArc(x1,y1)(r,phi1,phi2){amplitude}{windings} + + Draws a gluon on an arcsegment + x_center,y_center,radius,stat_angle,end_angle,gluon_radius,num + in which num is the number of windings of the gluon. + Method: + 1: compute length of arc. + 2: generate gluon in x and y as if the arc is a straight line + 3: x' = (radius+y)*cos(x*const) + y' = (radius+y)*sin(x*const) +*/ + +void GluonArc(double *args) +{ + double darc, arcstart = args[3],arcend = args[4], ampi = args[5]; +/* + When arcend comes before arcstart we have a problem. The solution is + to flip the order and change the sign on ampi +*/ + if ( arcend < arcstart ) { + darc = arcstart; arcstart = arcend; arcend = darc; ampi = -ampi; + } + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + darc = arcend-arcstart; + GluonArcHelp(args,darc,ampi); +} + +/* + #] GluonArc : + #[ DashGluonArc : * + + DashGluonArc(x1,y1)(r,phi1,phi2){amplitude}{windings}{dashsize} + + Draws a gluon on an arcsegment + x_center,y_center,radius,stat_angle,end_angle,gluon_radius,num + in which num is the number of windings of the gluon. + Method: + 1: compute length of arc. + 2: generate gluon in x and y as if the arc is a straight line + 3: x' = (radius+y)*cos(x*const) + y' = (radius+y)*sin(x*const) +*/ + +void DashGluonArc(double *args) +{ + double darc, arcstart = args[3],arcend = args[4], ampi = args[5]; + double dashsize = args[7]; +/* + When arcend comes before arcstart we have a problem. The solution is + to flip the order and change the sign on ampi +*/ + if ( arcend < arcstart ) { + darc = arcstart; arcstart = arcend; arcend = darc; ampi = -ampi; + } + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + darc = arcend-arcstart; + dashsize = ComputeDashGluonArc(args,darc,dashsize); + SetDashSize(dashsize,dashsize/2); + GluonArcHelp(args,darc,ampi); +} + +/* + #] DashGluonArc : + #[ Photon : * + + Photon(x1,y1)(x2,y2){amplitude}{windings} + + Each half winding is one cubic Bezier curve. +*/ + +void Photon(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + + PhotonHelp(args,dr); +} + +/* + #] Photon : + #[ DoublePhoton : * + + DoublePhoton(x1,y1)(x2,y2){amplitude}{windings}{sep} + + Each half winding is one cubic Bezier curve. +*/ + +void DoublePhoton(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + linesep = args[6]; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + PhotonHelp(args,dr); + RestoreGraphicsState; + + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + PhotonHelp(args,dr); + RestoreGraphicsState; +} + +/* + #] DoublePhoton : + #[ DashPhoton : * + + DashPhoton(x1,y1)(x2,y2){amplitude}{windings}{dashsize} + + Each half winding is one cubic Bezier curve. +*/ + +void DashPhoton(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + int numdashes, numhalfwindings = args[5]*2+0.5; + double x, y, size; + double dashsize = args[6], onehalfwinding = dr/numhalfwindings; + x = (4*onehalfwinding)/3/M_pi; y = 4.*args[4]/3; + size = 0.5*LengthBezier(x,y, onehalfwinding-x,y, onehalfwinding,0,1.0); + numdashes = size/(2*args[6]); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = size/(2*numdashes); + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + + SetDashSize(dashsize,dashsize/2); + PhotonHelp(args,dr); +} + +/* + #] DashPhoton : + #[ DashDoublePhoton : * + + DashDoublePhoton(x1,y1)(x2,y2){amplitude}{windings}{sep}{dashsize} + + Each half winding is one cubic Bezier curve. +*/ + +void DashDoublePhoton(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + int numdashes, numhalfwindings = args[5]*2+0.5; + double x, y, size; + double dashsize = args[7], onehalfwinding = dr/numhalfwindings; + x = (4*onehalfwinding)/3/M_pi; y = 4.*args[4]/3; + size = 0.5*LengthBezier(x,y, onehalfwinding-x,y, onehalfwinding,0,1.0); + numdashes = size/(2*args[6]); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = size/(2*numdashes); + + linesep = args[6]; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + SetDashSize(dashsize,dashsize/2); + + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + PhotonHelp(args,dr); + RestoreGraphicsState; + +/* SetDashSize(0,0); */ + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + PhotonHelp(args,dr); + RestoreGraphicsState; +} + +/* + #] DashDoublePhoton : + #[ PhotonArc : * + + PhotonArc(x1,y1)(r,phi1,phi2){amplitude}{windings} + + This routine follows the Postscript routine closely, except for that + we do not put a transfer matrix inside the loop. The corresponding + moveto messes up the path. One would have to put stroking operations + in there each time. +*/ + +void PhotonArc(double *args) +{ + double arcstart = args[3],arcend = args[4]; + int num = 2*args[6]+0.5; + + if ( arcend < arcstart ) arcend += 360.; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + arcend = torad*(arcend-arcstart)/num; + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + + PhotonArcHelp(args,arcend,num); +} + +/* + #] PhotonArc : + #[ DoublePhotonArc : * + + DoublePhotonArc(x1,y1)(r,phi1,phi2){amplitude}{windings}{sep} +*/ + +void DoublePhotonArc(double *args) +{ + double arcstart = args[3],arcend = args[4]; + int num = 2*args[6]+0.5; + linesep = args[7]; + + if ( arcend < arcstart ) arcend += 360.; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + arcend = torad*(arcend-arcstart)/num; + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + PhotonArcHelp(args,arcend,num); + RestoreGraphicsState; + + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + PhotonArcHelp(args,arcend,num); + RestoreGraphicsState; +} + +/* + #] DoublePhotonArc : + #[ DashPhotonArc : * + + DashPhotonArc(x1,y1)(r,phi1,phi2){amplitude}{windings}{dashsize} +*/ + +void DashPhotonArc(double *args) +{ + double arcstart = args[3],arcend = args[4]; + double dashsize = args[7], dashstart; + int num = 2*args[6]+0.5; + + if ( arcend < arcstart ) arcend += 360.; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + arcend = torad*(arcend-arcstart)/num; + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + + dashsize = ComputeDashPhotonArc(args,arcend,dashsize,&dashstart); + SetDashSize(dashsize,dashstart); + PhotonArcHelp(args,arcend,num); +} + +/* + #] DashPhotonArc : + #[ DashDoublePhotonArc : * + + DashDoublePhotonArc(x1,y1)(r,phi1,phi2){amplitude}{windings}{sep}{dashsize} +*/ + +void DashDoublePhotonArc(double *args) +{ + double arcstart = args[3],arcend = args[4]; + double dashsize = args[8], dashstart; + int num = 2*args[6]+0.5; + linesep = args[7]; + + if ( arcend < arcstart ) arcend += 360.; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + + arcend = torad*(arcend-arcstart)/num; + + SetTransferMatrix(COS(arcstart),SIN(arcstart) + ,-SIN(arcstart),COS(arcstart),0,0); + dashsize = ComputeDashPhotonArc(args,arcend,dashsize,&dashstart); + + SaveGraphicsState; + SetDashSize(dashsize,dashstart); + SetLineWidth(linesep+axolinewidth); + PhotonArcHelp(args,arcend,num); + RestoreGraphicsState; + + SaveGraphicsState; + SetDashSize(0,0); + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + PhotonArcHelp(args,arcend,num); + RestoreGraphicsState; +} + +/* + #] DashDoublePhotonArc : + #[ ZigZag : * + + ZigZag(x1,y1)(x2,y2){amplitude}{windings} + + We draw each half winding as two straight lines. + This can be done better! +*/ + +void ZigZag(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + ZigZagHelp(args,dr); +} + +/* + #] ZigZag : + #[ DoubleZigZag : * + + DoubleZigZag(x1,y1)(x2,y2){amplitude}{windings}{sep} + + We draw each half winding as two straight lines. + This can be done better! +*/ + +void DoubleZigZag(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + linesep = args[6]; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + ZigZagHelp(args,dr); + RestoreGraphicsState; + + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + ZigZagHelp(args,dr); + RestoreGraphicsState; +} + +/* + #] DoubleZigZag : + #[ DashZigZag : * + + DashZigZag(x1,y1)(x2,y2){amplitude}{windings}{dashsize} + + We should recalculate the size of the dashes. Otherwise the points + of the teeth can become messy. +*/ + +void DashZigZag(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + double dashsize = args[6]; + int n = args[5]*2+0.5; + double size = dr/(n*2); + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + + size = sqrt(size*size+args[4]*args[4]); + n = size/(2*dashsize); /* number of complete dash patterns rounded down */ +/* + Now test what is closer to dash: size/n or size/(n+1) +*/ + if ( n == 0 ) n = 1; + if ( fabs(size-2*dashsize*n) > fabs(size-2*dashsize*(n+1)) ) n++; + dashsize = size/(2*n); + + SetDashSize(dashsize,dashsize/2); + ZigZagHelp(args,dr); +} + +/* + #] DashZigZag : + #[ DashDoubleZigZag : * + + DashDoubleZigZag(x1,y1)(x2,y2){amplitude}{windings}{sep}{dashsize} + + We draw each half winding as two straight lines. + This can be done better! +*/ + +void DashDoubleZigZag(double *args) +{ + double dx = args[2] - args[0]; + double dy = args[3] - args[1]; + double dr = sqrt(dx*dx+dy*dy); + double dashsize = args[7]; + int n = args[5]*2+0.5; + double size = dr/(n*2); + linesep = args[6]; + + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + + size = sqrt(size*size+args[4]*args[4]); + n = size/(2*dashsize); /* number of complete dash patterns rounded down */ +/* + Now test what is closer to dash: size/n or size/(n+1) +*/ + if ( n == 0 ) n = 1; + if ( fabs(size-2*dashsize*n) > fabs(size-2*dashsize*(n+1)) ) n++; + dashsize = size/(2*n); + + SetDashSize(dashsize,dashsize/2); + + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + ZigZagHelp(args,dr); + RestoreGraphicsState; + + SetDashSize(0,0); + + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + ZigZagHelp(args,dr); + RestoreGraphicsState; +} + +/* + #] DashDoubleZigZag : + #[ ZigZagArc : * + + ZigZagArc(x1,y1)(r,phi1,phi2){amplitude}{windings} +*/ + +void ZigZagArc(double *args) +{ + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + ZigZagArcHelp(args); +} + +/* + #] ZigZagArc : + #[ DoubleZigZagArc : * + + DoubleZigZagArc(x1,y1)(r,phi1,phi2){amplitude}{windings}{sep} +*/ + +void DoubleZigZagArc(double *args) +{ + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + linesep = args[7]; + + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + ZigZagArcHelp(args); + RestoreGraphicsState; + + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + ZigZagArcHelp(args); + RestoreGraphicsState; +} + +/* + #] DoubleZigZagArc : + #[ DashZigZagArc : * + + DashZigZagArc(x1,y1)(r,phi1,phi2){amplitude}{windings}{dashsize} +*/ + +void DashZigZagArc(double *args) +{ + double dashsize = args[7], dashstart; + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + { + int num = 2*args[6]-0.5, numdashes; + double amp = args[5], r = args[2], size, size2; + double arcstart = args[3], arcend = args[4], darc; + if ( arcend < arcstart ) arcend += 360.; + darc = (arcend-arcstart)/(num+1); + size = sqrt(0.5*(amp*amp+r*r-(r*r-amp*amp)*COS(darc))); + size2 = sqrt(amp*amp+2*(amp+r)*r*(1-COS(darc/2))); + numdashes = size/(2*dashsize); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = size/(2*numdashes); + num = size2/(2*dashsize); + dashstart = -(size2 - 2*num*dashsize) + dashsize/2; + if ( dashstart < 0 ) dashstart += 2*dashsize; + } + SetDashSize(dashsize,dashstart); + ZigZagArcHelp(args); +} + +/* + #] DashZigZagArc : + #[ DashDoubleZigZagArc : * + + DashDoubleZigZagArc(x1,y1)(r,phi1,phi2){amplitude}{windings}{sep}{dashsize} +*/ + +void DashDoubleZigZagArc(double *args) +{ + double dashsize = args[8], dashstart; + SetTransferMatrix(1,0,0,1,args[0],args[1]); /* Move to center of circle */ + linesep = args[7]; + { + int num = 2*args[6]-0.5, numdashes; + double amp = args[5], r = args[2], size, size2; + double arcstart = args[3], arcend = args[4], darc; + if ( arcend < arcstart ) arcend += 360.; + darc = (arcend-arcstart)/(num+1); + size = sqrt(0.5*(amp*amp+r*r-(r*r-amp*amp)*COS(darc))); + size2 = sqrt(amp*amp+2*(amp+r)*r*(1-COS(darc/2))); + numdashes = size/(2*dashsize); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = size/(2*numdashes); + num = size2/(2*dashsize); + dashstart = -(size2 - 2*num*dashsize) + dashsize/2; + if ( dashstart < 0 ) dashstart += 2*dashsize; + } + + SaveGraphicsState; + SetDashSize(dashsize,dashstart); + SetLineWidth(linesep+axolinewidth); + ZigZagArcHelp(args); + RestoreGraphicsState; + + SaveGraphicsState; + SetDashSize(0,0); + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + ZigZagArcHelp(args); + RestoreGraphicsState; +} + +/* + #] DashDoubleZigZagArc : + #] Particle routines : + #[ Drawing routines : + #[ Polygon : +*/ + +void Polygon(double *args,int num,int type) +{ + int i; + MoveTo(args[0],args[1]); + args += 2; + for ( i = 1; i < num; i++, args += 2 ) { + LineTo(args[0],args[1]); + } + if ( type == 0 ) { CloseAndStroke; } + else if ( type == 1 ) { CloseAndFill; } +} + +/* + #] Polygon : + #[ Curve : + + + Curve{(x1,y1),...,(xn,yn)} + + num is the number of pairs in points. +*/ + +void Curve(double *points,int num) +{ + int i, ss; + double x0,y0,x1,y1,x2,y2,x3,y3; + + if ( num < 2 ) return; + if ( num == 2 ) { Line(points); return; } + + ss = 2*num; + + x1 = points[0]; y1 = points[1]; + x2 = points[2]; y2 = points[3]; + x3 = points[4]; y3 = points[5]; + x0 = 2*x1-x2; + y0 = 2*((y3-y2)/(x3-x2)-(y2-y1)/(x2-x1))*((x2-x1)*(x2-x1)/(x3-x1))+2*y1-y2; + + MoveTo(x1,y1); + DoCurve(x0,y0,x1,y1,x2,y2,x3,y3); + + for ( i = 0; i < ss-6; i += 2 ) { + DoCurve(points[i ],points[i+1],points[i+2],points[i+3], + points[i+4],points[i+5],points[i+6],points[i+7]); + } + if ( ss > 6 ) { + x0 = points[ss-6]; y0 = points[ss-5]; + x1 = points[ss-4]; y1 = points[ss-3]; + x2 = points[ss-2]; y2 = points[ss-1]; + x3 = 2*x2-x1; + y3 = 2*((y2-y1)/(x2-x1)-(y1-y0)/(x1-x0))*((x2-x1)*(x2-x1)/(x2-x0))+2*y2-y1; + + DoCurve(x0,y0,x1,y1,x2,y2,x3,y3); + } + Stroke; +} + +/* + #] Curve : + #[ DashCurve : + + + DashCurve{(x1,y1),...,(xn,yn)}{dashsize} +*/ + +void DashCurve(double *args,int num1) +{ + double dashsize = args[2*num1]; + if ( num1 == 2 ) { + DashLine(args); + } + else if ( num1 > 2 ) { + SetDashSize(dashsize,dashsize/2); + Curve(args,num1); + } +} + +/* + #] DashCurve : + #[ LogAxis : + + Draws a line with logarithmic hash marks along it. + LogAxis(x1,y1)(x2,y2)(num_logs,hashsize,offset,width) + The line is from (x1,y1) to (x2,y2) and the marks are on the left side + when hashsize is positive, and right when it is negative. + num_logs is the number of orders of magnitude and offset is the number + at which one starts at (x1,y1) (like if offset=2 we start at 2) + When offset is 0 we start at 1. Width is the linewidth. +*/ + +void LogAxis(double *args) +{ + double dx = args[2]-args[0], dy = args[3]-args[1], dr = sqrt(dx*dx+dy*dy); + double width = args[7], size, nlogs = args[4], hashsize = args[5]; + double offset = args[6], x; + int i, j; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + MoveTo(0,0); LineTo(dr,0); Stroke; +/* + Now compute the hash marks. +*/ + size = dr/nlogs; + if ( offset <= 0 ) { offset = 0; } + else { offset = log10(offset); } +/* + Big hash marks +*/ + for ( i = 1; i <= nlogs; i++ ) { + MoveTo((i-offset)*size,0); + LineTo((i-offset)*size,hashsize*1.2); + Stroke; + } +/* + Little hash marks +*/ + SetLineWidth(0.6*width); + for ( i = 0; i <= nlogs; i++ ) { + for ( j = 2; j < 10; j++ ) { + x = (i-offset+log10(j))*size; + if ( x >= 0 && x <= dr ) { + MoveTo(x,0); LineTo(x,hashsize*0.8); Stroke; + } + } + } +} + +/* + #] LogAxis : + #[ LinAxis : + + Draws a line with linear hash marks along it. + LinAxis(x1,y1)(x2,y2)(num_decs,per_dec,hashsize,offset,width) + The line is from (x1,y1) to (x2,y2) and the marks are on the left side + when hashsize is positive, and right when it is negative. + num_decs is the number of accented marks, per_dec the number of + divisions between them and offset is the number + at which one starts at (x1,y1) (like if offset=2 we start at the second + small mark) Width is the linewidth. +*/ + +void LinAxis(double *args) +{ + double width = args[8], hashsize = args[6], x; + double dx = args[2]-args[0], dy = args[3]-args[1], dr = sqrt(dx*dx+dy*dy); + double num_decs = args[4], per_dec = args[5], size, size2; + int i, j, numperdec = per_dec+0.5, offset = args[7]; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(dx/dr,dy/dr,-dy/dr,dx/dr,0,0); + MoveTo(0,0); LineTo(dr,0); Stroke; + size = dr/num_decs; + if ( numperdec > 1 ) size2 = size / numperdec; + else { size2 = size; numperdec = 1; } + if ( offset > numperdec ) offset = numperdec; + else if ( offset <= 0 ) offset = 0; +/* + Big hashes +*/ + for ( i = 0; i <= num_decs; i++ ) { + x = i*size-offset*size2; + if ( x >= 0 && x <= dr ) { + MoveTo(x,0); LineTo(x,hashsize*1.2); Stroke; + } + } +/* + Little hash marks. +*/ + j = num_decs*numperdec+0.5; + SetLineWidth(0.6*width); + for ( i = 0; i <= j; i++ ) { + if ( (i+offset)%numperdec != 0 ) { + x = i*size2; + if ( x >= 0 && x <= dr ) { + MoveTo(x,0); LineTo(x,hashsize*0.8); Stroke; + } + } + } +} + +/* + #] LinAxis : + #[ BezierCurve : + + Draws a Bezier curve. Starts at (x1,y1). + The control points are (x2,y2),(x3,y3),(x4,y4) +*/ + +void BezierCurve(double *args) +{ + MoveTo(args[0],args[1]); + Bezier(args[2],args[3],args[4],args[5],args[6],args[7]); + Stroke; + if ( witharrow ) BezierArrow(args); +} + +/* + #] BezierCurve : + #[ DoubleBezier : + + Draws a Bezier curve. Starts at (x1,y1). + The control points are (x2,y2),(x3,y3),(x4,y4) +*/ + +void DoubleBezier(double *args) +{ + linesep = args[8]; + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + MoveTo(args[0],args[1]); + Bezier(args[2],args[3],args[4],args[5],args[6],args[7]); + Stroke; + RestoreGraphicsState; + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + MoveTo(args[0],args[1]); + Bezier(args[2],args[3],args[4],args[5],args[6],args[7]); + Stroke; + RestoreGraphicsState; + if ( witharrow ) BezierArrow(args); +} + +/* + #] DoubleBezier : + #[ DashBezier : + + Draws a Bezier curve. Starts at (x1,y1). + The control points are (x2,y2),(x3,y3),(x4,y4) +*/ + +void DashBezier(double *args) +{ + int numdashes; + double size, dashsize = args[8]; + size = LengthBezier(args[2]-args[0],args[3]-args[1] + ,args[4]-args[0],args[5]-args[1],args[6]-args[0],args[7]-args[1],1.0); + + numdashes = size/(2*dashsize); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = (size/(2*numdashes)); + + SetDashSize(dashsize,dashsize/2); + MoveTo(args[0],args[1]); + Bezier(args[2],args[3],args[4],args[5],args[6],args[7]); + Stroke; + if ( witharrow ) BezierArrow(args); +} + +/* + #] DashBezier : + #[ DashDoubleBezier : + + Draws a Bezier curve. Starts at (x1,y1). + The control points are (x2,y2),(x3,y3),(x4,y4) +*/ + +void DashDoubleBezier(double *args) +{ + int numdashes; + double size, dashsize = args[9]; + size = LengthBezier(args[2]-args[0],args[3]-args[1] + ,args[4]-args[0],args[5]-args[1],args[6]-args[0],args[7]-args[1],1.0); + + numdashes = size/(2*dashsize); + if ( numdashes == 0 ) numdashes = 1; + if ( fabs(size-2*dashsize*numdashes) > fabs(size-2*dashsize*(numdashes+1)) ) + numdashes++; + dashsize = (size/(2*numdashes)); + + SetDashSize(dashsize,dashsize/2); + linesep = args[8]; + SaveGraphicsState; + SetLineWidth(linesep+axolinewidth); + MoveTo(args[0],args[1]); + Bezier(args[2],args[3],args[4],args[5],args[6],args[7]); + Stroke; + RestoreGraphicsState; + SaveGraphicsState; + SetLineWidth(linesep-axolinewidth); + SetBackgroundColor(STROKING); + MoveTo(args[0],args[1]); + Bezier(args[2],args[3],args[4],args[5],args[6],args[7]); + Stroke; + RestoreGraphicsState; + if ( witharrow ) BezierArrow(args); +} + +/* + #] DashDoubleBezier : + #] Drawing routines : + #[ Wrapper routines : + #[ AxoArc : + + Draws arc centered at (#1,#2), radius #3, starting and ending + angles #4, #5. + Double, dashing, arrow, flip, clockwise +*/ + +void AxoArc(double *args) +{ + double dashsize = args[6]; + linesep = args[5]; + GetArrow(args+7); + if ( args[16] ) { /* If clockwise: reverse the angles and the arrow */ + double e; + clockwise = 1; /* In principle not needed */ + flip = 1-flip; + arrow.where = 1-arrow.where; + e = args[3]; args[3] = args[4]; args[4] = e; + } + + if ( witharrow ) { + if ( arrow.where > 1 ) arrow.where = 1; + if ( arrow.where < 0 ) arrow.where = 0; + if ( dashsize > 0 ) { + if ( linesep > 0 ) { + DashArrowDoubleArc(args); + } + else { + args[5] = args[6]; + DashArrowArc(args); + } + } + else { + if ( linesep > 0 ) { + ArrowDoubleArc(args); + } + else { + ArrowArc(args); + } + } + } + else { + if ( dashsize > 0 ) { + if ( linesep > 0 ) { + DashDoubleArc(args); + } + else { + args[5] = args[6]; + DashCArc(args); + } + } + else { + if ( linesep > 0 ) { + DoubleArc(args); + } + else { + CArc(args); + } + } + } +} + +/* + #] AxoArc : + #[ AxoBezier : +*/ + +void AxoBezier(double *args) +{ + linesep = args[8]; + GetArrow(args+10); + if ( witharrow ) { + if ( arrow.where > 1 ) arrow.where = 1; + if ( arrow.where < 0 ) arrow.where = 0; + } + if ( args[9] ) { /* dashes */ + if ( args[8] ) { /* double */ + DashDoubleBezier(args); + } + else { + args[8] = args[9]; + DashBezier(args); + } + } + else { + if ( args[8] ) { /* double */ + DoubleBezier(args); + } + else { + BezierCurve(args); /* The name Bezier was already taken */ + } + } +} + +/* + #] AxoBezier : + #[ AxoGluon : +*/ + +void AxoGluon(double *args) +{ + SetLineWidth(axolinewidth + args[6]); + if ( args[7] ) { /* dashes */ + args[6] = args[7]; + DashGluon(args); + } + else { + Gluon(args); + } +} + +/* + #] AxoGluon : + #[ AxoGluonArc : +*/ + +void AxoGluonArc(double *args) +{ + SetLineWidth(axolinewidth + args[7]); + if ( args[9] ) { /* Clockwise */ + double a = args[3]; args[3] = args[4]; args[4] = a; + } + if ( args[8] ) { /* Dashes */ + args[7] = args[8]; + DashGluonArc(args); + } + else { + GluonArc(args); + } +} + +/* + #] AxoGluonArc : + #[ AxoGluonCirc : +*/ + +void AxoGluonCirc(double *args) +{ + SetLineWidth(axolinewidth + args[6]); + if ( args[7] ) { /* dashes */ + args[6] = args[7]; + DashGluonCirc(args); + } + else { + GluonCirc(args); + } +} + +/* + #] AxoGluonCirc : + #[ AxoLine : + + AxoLine(x1,y1)(x2,y2){sep}{dashsize}{stroke width length inset}{where} + + Generic switchyard to the various routines for compatibility + with Jaxodraw and axodraw4j + + Note: because the specific routines can be called either in the + direct way or by means of the generic routine, they have to know + what arrow to use. This is regulated by arrow.type. 0=old arrows. +*/ + +void AxoLine(double *args) +{ + linesep = args[4]; + GetArrow(args+6); + if ( witharrow ) { + if ( arrow.where > 1 ) arrow.where = 1; + if ( arrow.where < 0 ) arrow.where = 0; + if ( args[5] == 0 ) { + if ( linesep == 0 ) ArrowLine(args); + else { ArrowDoubleLine(args); } + } + else { + if ( linesep == 0 ) { + args[4] = args[5]; + DashArrowLine(args); + } + else { DashArrowDoubleLine(args); } + } + } + else { + if ( args[5] == 0 ) { /* No dashing */ + if ( linesep == 0 ) Line(args); + else DoubleLine(args); + } + else { + if ( linesep == 0 ) { + args[4] = args[5]; DashLine(args); + } + else DashDoubleLine(args); + } + } +} + +/* + #] AxoLine : + #[ AxoPhoton : +*/ + +void AxoPhoton(double *args) +{ + if ( args[7] ) { /* dashes */ + if ( args[6] ) { /* double */ + DashDoublePhoton(args); + } + else { + args[6] = args[7]; + DashPhoton(args); + } + } + else { + if ( args[6] ) { /* double */ + DoublePhoton(args); + } + else { + Photon(args); + } + } +} + +/* + #] AxoPhoton : + #[ AxoPhotonArc : +*/ + +void AxoPhotonArc(double *args) +{ + if ( args[9] ) { /* Clockwise */ + int num = 2*args[6]+0.5; + double a = args[3]; args[3] = args[4]; args[4] = a; + if ( ( num & 1 ) == 0 ) args[5] = -args[5]; + } + if ( args[8] ) { /* dash */ + if ( args[7] ) { /* double */ + DashDoublePhotonArc(args); + } + else { + args[7] = args[8]; + DashPhotonArc(args); + } + } + else { + if ( args[7] ) { /* double */ + DoublePhotonArc(args); + } + else { + PhotonArc(args); + } + } +} + +/* + #] AxoPhotonArc : + #[ AxoZigZag : +*/ + +void AxoZigZag(double *args) +{ + if ( args[7] ) { /* dashes */ + if ( args[6] ) { /* double */ + DashDoubleZigZag(args); + } + else { + args[6] = args[7]; + DashZigZag(args); + } + } + else { + if ( args[6] ) { /* double */ + DoubleZigZag(args); + } + else { + ZigZag(args); + } + } +} + +/* + #] AxoZigZag : + #[ AxoZigZagArc : +*/ + +void AxoZigZagArc(double *args) +{ + if ( args[9] ) { /* Clockwise */ + int num = 2*args[6]+0.5; + double a = args[3]; args[3] = args[4]; args[4] = a; + if ( ( num & 1 ) == 0 ) args[5] = -args[5]; + } + if ( args[8] ) { /* dash */ + if ( args[7] ) { /* double */ + DashDoubleZigZagArc(args); + } + else { + args[7] = args[8]; + DashZigZagArc(args); + } + } + else { + if ( args[7] ) { /* double */ + DoubleZigZagArc(args); + } + else { + ZigZagArc(args); + } + } +} + +/* + #] AxoZigZagArc : + #] Wrapper routines : + #[ Various routines : + #[ Rotate : + + + Rotate: x y angle hmode vmode textwidth textheight + Note, the textwidth/textheight have been scaled already; +*/ + +void Rotate(double *args) +{ + double textheight = args[6]*args[4]/2/65536.; + double textwidth = args[5]*args[3]/2/65536.; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + SetTransferMatrix(COS(args[2]),SIN(args[2]),-SIN(args[2]),COS(args[2]),0,0); + SetTransferMatrix(1,0,0,1,-textwidth,textheight); +} + +/* + #] Rotate : + #[ Grid : + + Makes a coordinate grid in the indicated color. + (x0,y0)(incx,incy)(nx,ny){color}{linewidth} +*/ + +void Grid(double *args) +{ + int i, nx = args[4]+0.01, ny = args[5]+0.01; + double maxx = args[2]*args[4]; + double maxy = args[3]*args[5]; + SetTransferMatrix(1,0,0,1,args[0],args[1]); + for ( i = 0; i <= nx; i++ ) { + MoveTo(i*args[2],0); + LineTo(i*args[2],maxy); + Stroke; + } + for ( i = 0; i <= ny; i++ ) { + MoveTo(0,i*args[3]); + LineTo(maxx,i*args[3]); + Stroke; + } +} + +/* + #] Grid : + #] Various routines : + #] routines : +*/ diff --git a/Master/texmf-dist/tex/latex/axodraw2/axodraw2.sty b/Master/texmf-dist/tex/latex/axodraw2/axodraw2.sty new file mode 100644 index 00000000000..b8dba9b5aad --- /dev/null +++ b/Master/texmf-dist/tex/latex/axodraw2/axodraw2.sty @@ -0,0 +1,4728 @@ +% This is axodraw2.sty +% +% (C) 1994-2016 by authors: +% John Collins (jcc8 at psu dot edu) +% Jos Vermaseren (t68 at nikhef dot nl) +% +% +% Conditions of use: +% +% axodraw is free software: you can redistribute it and/or modify it under +% the terms of the GNU General Public License as published by the Free +% Software Foundation, either version 3 of the License, or (at your option) +% any later version. +% +% axodraw is distributed in the hope that it will be useful, but WITHOUT ANY +% WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +% FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +% details. +% +% For the GNU General Public License see . +% +% Code necessities: +% +% 1. \ignorespaces at end of commands that draw things. Often it won't +% matter, but occasionally a command in a picture environment +% will set material and a following uncommented end-of-line in +% the user's code will shift the insertion point. +% 2. Use end-of-line comments whereever TeX might use the end-of-line as +% a space to be typeset. +% +% Conventions +% +% 1. Any font and color changes that are supposed to be local should +% be made local, either by explicit TeX grouping or by being +% inside commands (e.g., box-making commands) that enforce groups. +% Braces work, but \begingroup and \endgroup are easier to see in +% multiline groups. +% 2. Scaling: +% \unitlength is the unit for the canvas (as in picture environment). +% \axoscale is for the unit for coordinates, widths, etc +% \axotextscale is for all text objects, BUT only when +% PSText is NOT set to scale as graphics objects +% When PSText is set to scale as graphics objects, PSText +% scales by \axoscale, but TeX-text has unit scaling. +% Given a specification of a position (x,y) as in a call to \Line, +% the position of the point relative to the origin is +% x_act = (x + \axoxo ) \axoscale pt + \axoxoffset \unitlength +% y_act = (y + \axoyo ) \axoscale pt + \axoyoffset \unitlength +% Widths and the like for lines are in units of \axoscale pt +% +% #[ About folds : (this line starts with one % and two tabs) +% +% The internals of the file have been organized in folds. +% These are defined as a range of lines if which the first and last +% lines have a special format. Each starts with any three characters +% (may include tabs), then #[ for the start line and #] for the closing +% line, then both lines need identical name fields, closed by a colon. +% After the colon can be anything. When a fold is closed one should see +% only the first line but with the #[ replaced by ## as in +% ## About folds : (this line starts with one % and two tabs) +% Folds can be nested. +% This fold concept comes originally from the occam compiler for the +% transputer in the second half of the 1980's although there it was +% implemented differently. It was taken over by the STedi editor in its +% current form. The sources of this editor are available from the form +% home site: http://www.nikhef.nl/~form +% Some people have managed to emulate these folds in editors like emacs +% and vim. +% +% #] About folds : +% +\ProvidesPackage{axodraw2}[2016/06/02 v2.1.0b] +% +% axodraw.sty file, both for .tex -> .dvi -> .ps and for .tex -> .pdf +% +% #[ Common LaTeX code : +% #[ Variables : +% +% +\RequirePackage{keyval} +\RequirePackage{ifthen} +\RequirePackage{graphicx} +\RequirePackage{color} +\RequirePackage{ifxetex} +% +% +\DeclareOption{v1compatible}{ + \def\B2Text{\BTwoText} + \def\G2Text{\GTwoText} + \def\C2Text{\CTwoText} +} +\DeclareOption{canvasScaleIs1pt}{\canvasScaleOnept} +\DeclareOption{canvasScaleIsObjectScale}{\canvasScaleObjectScale} +\DeclareOption{canvasScaleIsUnitLength}{\canvasScaleUnitLength} +\DeclareOption{PSTextScalesIndependently}{\PSTextScalesLikeGraphicsfalse} +\DeclareOption{PSTextScalesLikeGraphics}{\PSTextScalesLikeGraphicstrue} + +% N.B. Option processing is deferred to end of this file, so that all +% definitions and initializations have been done first. + +% Settings for pdf v. dvi/ps output: +% We need to be able to run under latex, pdflatex, lualatex, and +% xelatex, and use (if possible) \pdfoutput and \pdfliteral +% +% latex: Initially \pdfoutput is 0, and \pdfliteral is defined but +% not usable. +% pdflatex: Initially \pdfoutput is 1, and \pdfliteral is defined and +% usable. +% lualatex: same as pdflatex in versions up to 0.80 +% But in versions from 0.85, pdfouput and pdfliteral aren't +% defined; instead \outputmode, \pdfextension literal{...} +% are available instead. +% xelatex: Both \pdfoutput and \pdfliteral are undefined +% but special{pdf:literal ...} gives same effect as +% \pdfliteral would, and we can assume pdf mode always. +% When \pdfoutput is defined, the user can change its value to change +% the type of output. This must be done before the first page is +% created. But various packages (including graphics and ifpdf, as +% well as axodraw) take actions when the package is loaded that depend +% on current state of \pdfoutput (or its equivalent). So it is +% reasonable to require that \pdfoutput be set only before packages +% are loaded and not set later. +% +% We define \axo@pdfoutput and \axo@pdfliteral for our uses to have +% function of \pdfoutput and \pdfliteral, but to be defined always. +% We initialize them to a default suitable for dvi mode, and override +% these definitions to cover the situations listed above. This needs +% tests for whether \pdfoutput, \outputmode, etc are undefined of +% defined. We put these inside a group, to evade the side effect that +% \@ifundefined defines the object being tested. +% +% Default values: +\newcount\axo@pdfoutput +\axo@pdfoutput=0 +\def\axo@pdfliteral#1% + {\PackageWarning{axo}{Bug: pdfliteral accessed but not available}} +\bgroup + \@ifundefined{pdfoutput}% + {}% + {\global\axo@pdfoutput=\pdfoutput}% + % + \@ifundefined{pdfliteral}% + {}% + {% Define \axo@pdfliteral to call \pdfliteral, so that if the + % definition of \pdfliteral were to be overridden, we get to + % use the changed definition + \gdef\axo@pdfliteral#1{\pdfliteral{#1}}}% + \@ifundefined{outputmode}% + {}% + {\global\axo@pdfoutput=\outputmode} + \@ifundefined{pdfextension}% + {}% + {\gdef\axo@pdfliteral#1{\pdfextension literal{#1}}} +\egroup +\ifxetex + \axo@pdfoutput=1 + \def\axo@pdfliteral#1{\special{pdf:literal #1}} +\fi + +% +% For communicating with axohelp with global file +% +\newif\ifaxo@axohelpRerun +\axo@axohelpRerunfalse +% +\newcounter{axo@objectIndex} +\setcounter{axo@objectIndex}{0} +\newwrite\axo@spec +\newread\axo@axohelpFile +% +\newcommand\axo@setObject[3]{ + \expandafter\gdef\csname axo@input@#1\endcsname{#2} + \expandafter\gdef\csname axo@output@#1\endcsname{#3} +} +% +\ifcase\axo@pdfoutput +\else + \IfFileExists{\jobname.ax2}% + {{% For comparisons between current definition of object + % and previously processed definition, spaces must be preserved. + \obeyspaces + \openin\axo@axohelpFile=\jobname.ax2 + }}% + {% + \PackageWarning{axo}{File `\jobname.ax2' not found.} + \axo@axohelpReruntrue + } + \AtBeginDocument{\immediate\openout\axo@spec\jobname.ax1} + \AtEndDocument{\immediate\closeout\axo@spec + \ifaxo@axohelpRerun + \PackageWarning{axodraw2}{Run `axohelp \jobname' + and then rerun pdflatex.} + \fi + } +\fi + +% Commands to set parameters +% +% Arrow scale: +\newcommand{\AXO@DefaultArrowScale}{1} +\newcommand\SetArrowScale[1]{% + \renewcommand\AXO@DefaultArrowScale{#1}% +} +% Alternative name +\newcommand\DefaultArrowScale[1]{\SetArrowScale{#1}} +\SetArrowScale{1} + +% Arrow inset: +\newcommand\AXO@ArrowInset{0.2} +%\renewcommand\AXO@ArrowInset{-1 } +\newcommand\SetArrowInset[1]{% + \renewcommand\AXO@ArrowInset{#1}% +} + +% Arrow aspect: +\newcommand\AXO@DefaultArrowAspect{1.25} +\newcommand\SetArrowAspect[1]{% + \renewcommand\AXO@DefaultArrowAspect{#1}% +} + +% Arrow position (fractional position along line): +\newcommand\AXO@ArrowPos{0.5} +\newcommand\SetArrowPosition[1]{% + \renewcommand\AXO@ArrowPos{#1}% +} + +% Arrow stroke width +\newcommand{\AXO@DefaultArrowStroke}{0 } +\newcommand\SetArrowStroke[1]{% + \renewcommand\AXO@DefaultArrowStroke{#1}% +} + +\newlength{\axounitlength} +% The next two are scratch registers +\newlength\axo@x +\newlength\axo@y +% Initializations +\axounitlength=\unitlength +\def\axocanvas{1} % How unitlength is set in axopicture environment + % 0 => 1 pt + % 1 => \axoscale pt + % 2 => Don't set it +\def\axominusone{-1} +\def\axoone{1} +\def\axozero{0} +\def\axowidth{0.5} +\def\axoscale{1.0} +\def\axotextscale{1.0} +\newif\ifPSTextScalesLikeGraphics +\PSTextScalesLikeGraphicstrue +\def\axoxoff{0} +\def\axoyoff{0} +\def\axoxo{0} +\def\axoyo{0} +\def\axoarrowsize{2} +% +% +% Now the user callable routines, and their immediate helpers +% +% Commands for setting parameters applicable to subsequent graphical objects: +% +\def\SetLineSep#1{\def\AXO@Sep{#1}\ignorespaces}\relax +\let\SetSep=\SetLineSep\relax +\def\SetDashSize#1{\def\AXO@DashSize{#1}\ignorespaces}\relax +\def\SetWidth#1{\def\axowidth{#1}\ignorespaces} +\def\SetArrowSize#1{\def\axoarrowsize{#1}} + +\def\SetObjectScale#1{\def\axoscale{#1}\ignorespaces} +\def\SetCanvasScale#1{\unitlength = #1 pt\ignorespaces} +\def\SetTextScale#1{\def\axotextscale{#1}\ignorespaces} +\let\SetScale = \SetObjectScale + +\def\SetOffset(#1,#2){\def\axoxoff{#1}\def\axoyoff{#2}\ignorespaces} +\def\SetScaledOffset(#1,#2){\def\axoxo{#1}\def\axoyo{#2}\ignorespaces} + +\def\canvasScaleOnept{\def\axocanvas{0}} +\def\canvasScaleObjectScale{\def\axocanvas{1}} +\def\canvasScaleUnitLength{\def\axocanvas{2}} + +% +% +% #] Variables : +% #[ Defining commands with optional arguments : +% +\def\defWithOption#1#2#3{% + \@namedef{#1}% + {% + \@ifnextchar[%] + {\@nameuse{#1@A}}% + {\@nameuse{#1@A}[]}% + }% + \@namedef{#1@A}[##1]#2% + {#3}% +} +% +% #] Defining commands with optional arguments : +% #[ axopicture : +% +% Version of picture environment with unitlength set to 1pt +% as assumed by axodraw. We also store some variables and reset them +% afterwards. This makes the picture environment also local from the +% axodraw viewpoint. To change the global settings one should issue +% the corresponding command from outside the axopicture environment. +% Use: \begin{axopicture}(width,height)(xshift,yshift) +% \end{axopicture} +% The old use with the regular picture environment will still work, +% but it will have the old shortcomings connected to it. +% +\let\OLDpicture=\picture +\let\endOLDpicture=\endpicture +\newenvironment{axopicture} +{% + \ifcase \axocanvas + \setlength{\unitlength}{1 pt}% + \or + \setlength{\unitlength}{\axoscale\space pt}% + \else + % Leave \unitlength as whatever the user set + \fi + \begin{OLDpicture}% +} +{% + \end{OLDpicture}% + \ignorespacesafterend +} +% +% #] axopicture : +% #[ AXO@keys : +% + +% Diagnostics for unimplemented features: +\newif\ifAXONotImplemented +\AXONotImplementedfalse +\def\AXO@NOTIMPLEMENTED#1{% + \global\AXONotImplementedtrue + \PackageWarning{axodraw2}{#1}% +} +\AtEndDocument{% + \ifAXONotImplemented + \PackageWarningNoLine{axodraw2}{unimplemented features used + somewhere in document}% + \fi +} + +% The next is used temporarily, it gives the result of parsing an +% arrow-using command to give the Postscript code for setting the +% arrow. +% +% Keys for optional arguments: +% First the variables used, with some defaults. +\newif\ifAXO@arrow +\AXO@arrowfalse +\newif\ifAXO@clock +\AXO@clockfalse +\newif\ifAXO@dash +\AXO@dashfalse +\newif\ifAXO@double +\AXO@doublefalse +\newif\ifAXO@flip % Flip arrow orientation, as in JaxoDraw +\AXO@flipfalse +\newif\ifAXO@linecolor % Option sets color for current line +\AXO@linecolorfalse + +\def\AXO@Sep{2} % Double line separation +\def\AXO@DashSize{3} + +% Then the definitions of the keys +\define@key{axo}{arrowscale}{% + \def\AXO@CurrentArrowScale{#1}% +} +\define@key{axo}{arrowwidth}{% + \def\AXO@CurrentArrowWidth{#1}% +} +\define@key{axo}{arrowlength}{% + \def\AXO@CurrentArrowLength{#1}% +} +% Make arrowheight a synonym for arrowlength +\let\KV@axo@arrowheight=\KV@axo@arrowlength +% +\define@key{axo}{arrowpos}{% + \def\AXO@CurrentArrowPos{#1 } +} +% +\define@key{axo}{arrowaspect}{% + \def\AXO@CurrentArrowAspect{#1 } +} +% +\define@key{axo}{arrowinset}{% + \def\AXO@CurrentArrowInset{#1 } +} +% Make inset a synonym for arrowinset +\let\KV@axo@inset=\KV@axo@arrowinset +% +\define@key{axo}{arrowstroke}{% + \def\AXO@CurrentArrowStroke{#1 } +} +% +\define@key{axo}{arrow}[true]{% + \AXO@boolkey{#1}{arrow}% +} +\define@key{axo}{clock}[true]{% + \AXO@boolkey{#1}{clock}% +} +\define@key{axo}{clockwise}[true]{% + \AXO@boolkey{#1}{clock}% +} +\define@key{axo}{color}{% + \def\AXO@CurrentColor{#1}% + \AXO@linecolortrue +} +% Make colour a synonym for color +\let\KV@axo@colour=\KV@axo@color +% +\define@key{axo}{dash}[true]{% + \AXO@boolkey{#1}{dash}% +} +\define@key{axo}{dashsize}{% + \def\AXO@CurrentDashSize{#1 } +} +\define@key{axo}{dsize}{% + \def\AXO@CurrentDashSize{#1 } +} +\define@key{axo}{double}[true]{% + \AXO@boolkey{#1}{double}% +} +\define@key{axo}{flip}[true]{% + \AXO@boolkey{#1}{flip}% +} +\define@key{axo}{linesep}{% + \def\AXO@CurrentSep{#1} +} +\define@key{axo}{sep}{% + \def\AXO@CurrentSep{#1} +} +\define@key{axo}{width}{% + \def\AXO@CurrentWidth{#1}% +} +% +% #] AXO@keys : +% #[ AXO@Parse : +% +% Parsing of optional arguments, etc +% +\def\AXO@Parse#1#2{% + % Usage: \AXO@Parse#1#2 or \AXO@Parse#1#2[#3] + % #1 is a command for setting an object, that takes no optional argument + % #2 and the optional #3 are keyword settings. + % There then follow the compulsory arguments for the command in #1. + % + % E.g., \AXO@Parse{\AXO@Line}{double}(x1,y1)(x2,y2) + % \AXO@Parse{\AXO@Line}{double}[arrow](x1,y1)(x2,y2) + % + % I will + % (a) Set standard initial settings (arrows, etc) + % (b) Parse the keyword settings in #2 and #3, e.g., scale = 3, + % (c) Call #1 to make the object + \AXO@arrowfalse + \AXO@clockfalse + \AXO@dashfalse + \AXO@doublefalse + \AXO@flipfalse + \AXO@linecolorfalse + \let\AXO@CurrentWidth\axowidth + \let\AXO@CurrentArrowPos\AXO@ArrowPos + \let\AXO@CurrentArrowWidth\relax + \let\AXO@CurrentArrowLength\relax + \let\AXO@CurrentArrowInset\AXO@ArrowInset + \let\AXO@CurrentArrowScale\AXO@DefaultArrowScale + \let\AXO@CurrentArrowStroke\AXO@DefaultArrowStroke + \let\AXO@CurrentArrowAspect\AXO@DefaultArrowAspect + \let\AXO@CurrentDashSize\AXO@DashSize + \let\AXO@CurrentSep=\AXO@Sep + \@ifnextchar[{\AXO@Options{#1}{#2}}% + {\AXO@Options{#1}{#2}[]}% +} +% +% #] AXO@Parse : +% #[ AXO@Options : +% +\def\AXO@Options#1#2[#3]{% + % #1 is command to execute, #2 and #3 are options. + \setkeys{axo}{#2}% + \setkeys{axo}{#3}% + \ifx\AXO@CurrentArrowLength\relax + \def\AXO@CurrentArrowLength{0 }% + \fi + \ifx\AXO@CurrentArrowWidth\relax + \def\AXO@CurrentArrowWidth{0 }% + \fi + \ifAXO@arrow + \def\AXO@ArrowArg{ + \AXO@CurrentArrowStroke \space % + \AXO@CurrentArrowWidth \space % + \AXO@CurrentArrowLength \space % + \AXO@CurrentArrowInset \space % + \AXO@CurrentArrowScale \space % + \AXO@CurrentArrowAspect \space % + \AXO@CurrentArrowPos \space % + \ifcase\axo@pdfoutput + true \space % Indicates that an arrow should be drawn. + \else + 1 \space % Indicates that an arrow should be drawn. + \fi + }% + \else + \ifcase\axo@pdfoutput + \def\AXO@ArrowArg{ 0 0 0 0 0 0 0 false }% + \else + \def\AXO@ArrowArg{ 0 0 0 0 0 0 0 0 }% + \fi + \fi + #1% +} +% +\def\AXO@useopts{% + % Override global settings by those from options + % HACK: The \@killglue solves problem that setting color + % causes a shift in horizontal position. + % Motivation: From definition of \put. + \@killglue + \ifAXO@linecolor \SetColor{\AXO@CurrentColor}\fi +} +% +% Now ensure there is a setting for the current arrow +\AXO@Parse{}{} +% +% #] AXO@Options : +% #[ AXO@varia : +% +% Now ensure there is a setting for the current arrow +\AXO@Parse{}{} + +\def\AXO@PrependOption#1#2{% + % Run command #1, which has an optional argument, with #2 prepended + % to the command's optional arguments. If there are no optional + % arguments, just run the command with #2 as the optional arguments + \@ifnextchar[{\AXO@TwoOption{#1}{#2}}% + {#1[#2]}% +} +\def\AXO@TwoOption#1#2[#3]{% + #1[#2,#3]% +} +% +% Copied from graphicx.sty, for use with boolean keys +% Modified to do lower casing here +\def\AXO@boolkey#1#2{% + \lowercase{\AXO@boolkeyA{#1}}{#2}% +} +\def\AXO@boolkeyA#1#2{% + \csname AXO@#2\ifx\relax#1\relax true\else#1\fi\endcsname +} +% +% #] AXO@varia : +% #[ Colors : +% +% Here we make an interface, compatible with both: color.sty, +% with the commands of axodraw v. 1, and with the commands of +% colordvi.sty (used by axodraw v. 1). +% +% 1. We make a set of named colors suitable for use with both +% axodraw's commands that take color arguments and with +% color.sty's \color command. +% 2. We define a command \SetColor to set a named color as the +% current color. It is now identical to \color. +% 3. For each of the colors that we define here, we make +% named color setting commands, e.g., \Red +% \textRed. \Red sets its (one) argument in Red, \textRed +% is a "declaration" that changes the current color. +% All the commands for setting color apply to both regular LaTeX +% material and to axodraw objects. Their setting of color +% respects LaTeX environments and TeX groups. +% +% We also define +% a. Named-color commands like \textRed and \Red for named +% colors to give the same interface as the colordvi +% package (and hence axodraw v. 1). +% b. \SetColor command to set a named color. + + +\let\SetColor=\color + +% For v. 1 compatibility: +\def\IfColor#1#2{#1} + +\newcommand\newcolor[2]{% + % Define a named color both in the color.sty style + % and in the colordvi.sty, with also a command giving the CMYK value. + % #1 is the color's name, #2 is its CMYK definition, space + % separated. + % + % Invoke color.sty's \definecolor after change of argument format: + \axo@new@color #1 #2\@% + % Define commands to use this color, + % E.g., if #1 is Red, then define \Red and \textRed: + \expandafter\def\csname #1\endcsname##1{{\SetColor{#1}##1}\ignorespaces} + \expandafter\def\csname text#1\endcsname{\SetColor{#1}\ignorespaces} + % The following to give the cmyk value of a color, e.g., \cmykRed, + % is no longer needed, since we no longer do color setting in + % postscript and pdf code: +%% \expandafter\def\csname cmyk#1\endcsname{#2} +} + +% Command to invoke color.sty's \definecolor, which needs a translation +% of our space-separated CMYK vector to a comma-separated vector: +\def\axo@new@color #1 #2 #3 #4 #5\@{\definecolor{#1}{cmyk}{#2,#3,#4,#5}} + + +% For consistency we define our named colors here, rather than +% using color.sty's mechanisms. The +% first 68 are standard colors, as defined by dvips, and +% implemented in both colordvi.ps, and in color.sty with its +% usenames and dvipsnames options (in the file dvipsnam.def +% provided by the LaTeX graphics package). +% +% We define an extra 5 colors at the end +% +% The 68 dvips-defined colors are: +% +\newcolor{GreenYellow}{0.15 0 0.69 0} +\newcolor{Yellow}{0 0 1 0} +\newcolor{Goldenrod}{0 0.10 0.84 0} +\newcolor{Dandelion}{0 0.29 0.84 0} +\newcolor{Apricot}{0 0.32 0.52 0} +\newcolor{Peach}{0 0.50 0.70 0} +\newcolor{Melon}{0 0.46 0.50 0} +\newcolor{YellowOrange}{0 0.42 1 0} +\newcolor{Orange}{0 0.61 0.87 0} +\newcolor{BurntOrange}{0 0.51 1 0} +\newcolor{Bittersweet}{0 0.75 1 0.24} +\newcolor{RedOrange}{0 0.77 0.87 0} +\newcolor{Mahogany}{0 0.85 0.87 0.35} +\newcolor{Maroon}{0 0.87 0.68 0.32} +\newcolor{BrickRed}{0 0.89 0.94 0.28} +\newcolor{Red}{0 1 1 0} +\newcolor{OrangeRed}{0 1 0.50 0} +\newcolor{RubineRed}{0 1 0.13 0} +\newcolor{WildStrawberry}{0 0.96 0.39 0} +\newcolor{Salmon}{0 0.53 0.38 0} +\newcolor{CarnationPink}{0 0.63 0 0} +\newcolor{Magenta}{0 1 0 0} +\newcolor{VioletRed}{0 0.81 0 0} +\newcolor{Rhodamine}{0 0.82 0 0} +\newcolor{Mulberry}{0.34 0.90 0 0.02} +\newcolor{RedViolet}{0.07 0.90 0 0.34} +\newcolor{Fuchsia}{0.47 0.91 0 0.08} +\newcolor{Lavender}{0 0.48 0 0} +\newcolor{Thistle}{0.12 0.59 0 0} +\newcolor{Orchid}{0.32 0.64 0 0} +\newcolor{DarkOrchid}{0.40 0.80 0.20 0} +\newcolor{Purple}{0.45 0.86 0 0} +\newcolor{Plum}{0.50 1 0 0} +\newcolor{Violet}{0.79 0.88 0 0} +\newcolor{RoyalPurple}{0.75 0.90 0 0} +\newcolor{BlueViolet}{0.86 0.91 0 0.04} +\newcolor{Periwinkle}{0.57 0.55 0 0} +\newcolor{CadetBlue}{0.62 0.57 0.23 0} +\newcolor{CornflowerBlue}{0.65 0.13 0 0} +\newcolor{MidnightBlue}{0.98 0.13 0 0.43} +\newcolor{NavyBlue}{0.94 0.54 0 0} +\newcolor{RoyalBlue}{1 0.50 0 0} +\newcolor{Blue}{1 1 0 0} +\newcolor{Cerulean}{0.94 0.11 0 0} +\newcolor{Cyan}{1 0 0 0} +\newcolor{ProcessBlue}{0.96 0 0 0} +\newcolor{SkyBlue}{0.62 0 0.12 0} +\newcolor{Turquoise}{0.85 0 0.20 0} +\newcolor{TealBlue}{0.86 0 0.34 0.02} +\newcolor{Aquamarine}{0.82 0 0.30 0} +\newcolor{BlueGreen}{0.85 0 0.33 0} +\newcolor{Emerald}{1 0 0.50 0} +\newcolor{JungleGreen}{0.99 0 0.52 0} +\newcolor{SeaGreen}{0.69 0 0.50 0} +\newcolor{Green}{1 0 1 0} +\newcolor{ForestGreen}{0.91 0 0.88 0.12} +\newcolor{PineGreen}{0.92 0 0.59 0.25} +\newcolor{LimeGreen}{0.50 0 1 0} +\newcolor{YellowGreen}{0.44 0 0.74 0} +\newcolor{SpringGreen}{0.26 0 0.76 0} +\newcolor{OliveGreen}{0.64 0 0.95 0.40} +\newcolor{RawSienna}{0 0.72 1 0.45} +\newcolor{Sepia}{0 0.83 1 0.70} +\newcolor{Brown}{0 0.81 1 0.60} +\newcolor{Tan}{0.14 0.42 0.56 0} +\newcolor{Gray}{0 0 0 0.50} +\newcolor{Black}{0 0 0 1} +\newcolor{White}{0 0 0 0} +% +% Our extra colors +% +\newcolor{LightYellow}{0 0 0.7 0} +\newcolor{LightRed}{0 0.75 0.7 0} +\newcolor{LightBlue}{0.7 0.5 0 0} +\newcolor{LightGray}{0 0 0 0.1} +\newcolor{VeryLightBlue}{0.15 0.07 0 0} +% +\SetColor{Black} +% +% #] Colors : +% #] Common LaTeX code : +% #[ LaTeX primitives : +% +% #[ Putting material +% + +% Some utilities that remove extra space that creeps in, particularly +% when extra groups are inserted before the use of \put. +% Use the definition of \@killglue used in latex.ltx for \put, +% but copy it here, since \@killglue is internal and not documented. +\gdef\AXO@killglue{\unskip\@whiledim \lastskip >\z@\do{\unskip}} + +% Special purpose versions of \put and \special +\long\gdef\putLen(#1,#2)#3{% + % Like LaTeX's \put, except that #1 and #2 are lengths instead of numbers + % giving lengths in units of \unitlength. + \AXO@killglue\raise#2\relax + \hbox to 0pt{\kern#1\relax #3\hss}% + \ignorespaces +} +% +\def\AxoPut(#1,#2)#3{% + % Like \put, but shifted by axodraw's offsets. + % This provides a way of coding the offsets in one place. + % But we are only using it in a limited set of cases so far. + \AXO@killglue + \bgroup + \axounitlength = \axoscale pt + \axo@x = \axoxoff \unitlength + \advance\axo@x by \axoxo \axounitlength + \advance\axo@x by #1 \axounitlength + \axo@y = \axoyoff \unitlength + \advance\axo@y by \axoyo \axounitlength + \advance\axo@y by #2 \axounitlength + \putLen(\axo@x,\axo@y){% + % If there are axodraw objects in #3, they should not also + % apply shifts, that would be double + % counting! Hence: + \SetOffset(0,0)% + \SetScaledOffset(0,0)% + #3% + }% + \egroup +\ignorespaces +} + +\def\AXOspecial#1{% + % Insertion of postscript code: + % Replacement for \special{" ...}, with the color initialized + % to the color befor the \special. (Ordinary \special{"...} + % initializes color to black.) + % Definitions made by \special{!...} are in dictionary SDict + % (as stated in dvips documentation), and we save color there. + \special{ps:: SDict begin savecolor end }% + \special{" restorecolor #1 }% +} + +\def\AXOputPS#1{% + % Insert postscript code after allowing for offsets. + \AxoPut(0,0){\AXOspecial{#1}}% +} + +\def\AXOputPDF#1{ + % Insert pdf code after allowing for offsets. + \AxoPut(0,0){\axo@pdfliteral{#1}}% +} + +% +% Now variables and routines for setting material in boxes (used by +% the BText etc commands. +% +\newdimen\tmpX +\newdimen\tmpY +\newsavebox{\tmpBox} +\newsavebox{\tmpBoxA} +% +\newcount\axo@tmp +\newcount\axo@tmpA +\newcount\axo@tmpB + +\newcount\bpinsp +\bpinsp = 65782 +\newcount\ptinsp +\ptinsp = 65536 + +\def\AssignDecDiv#1#2#3{% + % Assign the variable of name #1 to the result of dividing integer + % #2 by integer #3, with result as a textual decimal. Absolute + % accuracy: 0.001. + % Typical use: conversion of lengths to points and big points. + % \AssignDecDiv{cachedscale}{\unitlength}{65536} + % \AssignDecDiv{cachedscale}{\unitlength}{\ptinsp} + % to get length in points. + % Notes on conversion + % 1 sp = 2^{-16} pt = (1/65536) pt + % 1 pt = (1/72.27) in + % 1 bp = (1/72) in + % 1 sp = (1/65781.76) bp + % Use \relax at end of lines setting count registers. + % This ensures that the code works both when the arguments are + % given as numbers, e.g., \AxoDecDiv{100}{3}, as well as when they are + % given as lengths, etc, e.g., \AxoDecDiv{\unitlength}{256} + % + \axo@tmp = #2\relax + \axo@tmpA = \axo@tmp + \divide \axo@tmpA by #3\relax + \axo@tmpB=\axo@tmpA + \multiply \axo@tmpA by #3\relax + \advance \axo@tmp by -\axo@tmpA + \multiply \axo@tmp by 1000 + \divide \axo@tmp by #3\relax + \expandafter\edef\csname #1\endcsname{\the\axo@tmpB.\the\axo@tmp}% +} + +\def\SetTmpBox#1{% + % Sets the box \tmpBox to the contents of #1 set with current PS + % font and size. Sets \tmpX and \tmpY to the dimensions of the box + % plus some space around it, suitable for drawing an enclosing box. + % + % The vertical box setting numbers agree with those in axodraw's + % postscript code, but not (28 July 2014) with the axohelp pdf code. + % The reverse is true for the horizontal box settings. + % We can tweak them further. + % This is a standardized routine for use in all versions of postscript + % textbox routines. + % N.B. Use LaTeX's \sbox at first step, not TeX primitives to set + % box contents; it works properly with color. + \sbox{\tmpBox}{\UseCurrentPSFont #1}% + \tmpX = \axofontsize pt + \advance \tmpX by \wd\tmpBox + \tmpY = \axofontsize pt + \tmpY = 0.33333 \tmpY + \advance \tmpY by \ht\tmpBox + \advance \tmpY by \dp\tmpBox + \AssignDecDiv{tmpXT}{\tmpX}{\ptinsp}% + \AssignDecDiv{tmpYT}{\tmpY}{\ptinsp}% +} + +\def\SetTmpBoxTwo#1#2{% + % Equivalent of \SetTmpBox for two line commands. + % + % N.B. Use LaTeX's \sbox at first step, not TeX primitives to set + % box contents; it works properly with color. + \sbox{\tmpBox}{\UseCurrentPSFont #1}% + \sbox{\tmpBoxA}{\UseCurrentPSFont #2}% + \ifdim \wd\tmpBox > \wd\tmpBoxA + \tmpX = \wd\tmpBox + \else + \tmpX = \wd\tmpBoxA + \fi + \advance \tmpX by \axofontsize pt + \tmpY = \axofontsize pt + \setbox\tmpBox=% + \vbox{% + \lineskip = 0.1 \tmpY + \baselineskip = 1.1 \tmpY + \vskip 0.3 \tmpY + \hbox{\makebox[0pt]{\box\tmpBox}}% + \hbox{\makebox[0pt]{\box\tmpBoxA}}% + \vskip 0.3 \tmpY + }% + \tmpY = \ht\tmpBox + \advance \tmpY by \dp\tmpBox + \AssignDecDiv{tmpXT}{\tmpX}{\ptinsp}% + \AssignDecDiv{tmpYT}{\tmpY}{\ptinsp}% +} +% +% #] Putting +% #[ Point setting and using : +% +\def\SetPoint#1(#2,#3){% + % Define a named point in 2D + \@namedef{AXO@p.X@#1}{#2}% + \@namedef{AXO@p.Y@#1}{#3}% +} +\def\useX#1{% + % Use a named point + \@nameuse{AXO@p.X@#1}% +} +\def\useY#1{% + % Use a named point + \@nameuse{AXO@p.Y@#1}% +} +% +% #] Point setting and using : +% #[ Particle routines : +% #[ Gluon : +% +\def\Gluon{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \AXO@Parse{\AXO@Gluon}{}% +} +% +% #] Gluon : +% #[ DoubleGluon : +% +\defWithOption{DoubleGluon}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \Gluon[double,sep=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DoubleGluon : +% #[ DashGluon : +% +\defWithOption{DashGluon}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \Gluon[dash,dashsize=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashGluon : +% #[ DashDoubleGluon : +% +\defWithOption{DashDoubleGluon}{(#2,#3)(#4,#5)#6#7#8#9}{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \Gluon[double,sep=#8,dash,dashsize=#9,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashDoubleGluon : +% #[ GluonCirc : +% +% Draws a gluon on a circle. The center of the circle is at (#1,#2) +% The radius and the phase angle are (#3,#4), #5 is the +% amplitude of the gluon, and #6 is the number of windings. +% +\def\GluonCirc{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \AXO@Parse{\AXO@GluonCirc}{}% +} +% +% #] GluonCirc : +% #[ DoubleGluonCirc : +% +\defWithOption{DoubleGluonCirc}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \GluonCirc[double,sep=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DoubleGluonCirc : +% #[ DashGluonCirc : +% +\defWithOption{DashGluonCirc}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \GluonCirc[dash,dashsize=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashGluonCirc : +% #[ DashDoubleGluonCirc : +% +\defWithOption{DashDoubleGluonCirc}{(#2,#3)(#4,#5)#6#7#8#9}{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \GluonCirc[double,sep=#8,dash,dashsize=#9,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashDoubleGluonCirc : +% #[ GluonArc : +% +\def\GluonArc{% +% \GluonArc(x,y)(r,theta1,theta2){amplitude}{numwind} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \AXO@Parse{\AXO@GluonArc}{}% +} +% +\let\GlueArc=\GluonArc % For backward compatibility +% +% #] GluonArc : +% #[ DoubleGluonArc : +% +\defWithOption{DoubleGluonArc}{(#2)(#3)#4#5#6}{% +% +% \DoubleGluonArc(x,y)(r,theta1,theta2){amplitude}{numwind}{sep} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \GluonArc[double,sep=#6,#1](#2)(#3){#4}{#5}% +} +% +\let\DoubleGlueArc=\DoubleGluonArc % For backward compatibility +% +% #] DoubleGluonArc : +% #[ DashGluonArc : +% +\defWithOption{DashGluonArc}{(#2)(#3)#4#5#6}{% +% +% \DashGluonArc(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \GluonArc[dash,dashsize=#6,#1](#2)(#3){#4}{#5}% +} +% +\let\DashGlueArc=\DashGluonArc % For backward compatibility +% +% #] DashGluonArc : +% #[ DashDoubleGluonArc : +% +\defWithOption{DashDoubleGluonArc}{(#2)(#3)#4#5#6#7}{% +% +% \DashGluonArc(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \GluonArc[double,sep=#6,dash,dashsize=#7,#1](#2)(#3){#4}{#5}% +} +% +\let\DashDoubleGlueArc=\DashDoubleGluonArc % For backward compatibility +% +% #] DashDoubleGluonArc : +% #[ GluonArcn : +% +\defWithOption{GluonArcn}{(#2)(#3)#4#5}{% +% \GluonArcn(x,y)(r,theta1,theta2){amplitude}{numwind} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings. The n stands for clockwise +% + \GluonArc[clockwise,#1](#2)(#3){#4}{#5}% +} +% +\let\GlueArcn=\GluonArcn % For backward compatibility +% +% #] GluonArcn : +% #[ DoubleGluonArcn : +% +\defWithOption{DoubleGluonArcn}{(#2)(#3)#4#5#6}{% +% +% \DoubleGluonArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{sep} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings. Clockwise. +% + \GluonArc[clockwise,double,sep=#6,#1](#2)(#3){#4}{#5}% +} +% +\let\DoubleGlueArcn=\DoubleGluonArcn % For backward compatibility +% +% #] DoubleGluonArcn : +% #[ DashGluonArcn : +% +\defWithOption{DashGluonArcn}{(#2)(#3)#4#5#6}{% +% +% \DashGluonArc(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings. Clockwise. +% + \GluonArc[clockwise,dash,dashsize=#6,#1](#2)(#3){#4}{#5}% +} +% +\let\DashGlueArcn=\DashGluonArcn % For backward compatibility +% +% #] DashGluonArcn : +% #[ DashDoubleGluonArcn : +% +\defWithOption{DashDoubleGluonArcn}{(#2)(#3)#4#5#6#7}{% +% +% \DashGluonArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a gluon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings. Clockwise. +% + \GluonArc[clockwise,double,sep=#6,dash,dashsize=#7,#1](#2)(#3){#4}{#5}% +} +% +\let\DashDoubleGlueArcn=\DashDoubleGluonArcn % For backward compatibility +% +% #] DashDoubleGluonArcn : +% #[ Photon : +% +\def\Photon{% +% \Photon[opt](x1,y1)(x2,y2){amplitude}{numwind} +% Draws a photon from (x1,y1) to (x2,y2) with given amplitude and +% number of windings +% Supported options: double, sep, linesep +% + \AXO@Parse{\AXO@Photon}{}% +} +% +% #] Photon : +% #[ DoublePhoton : +% +\defWithOption{DoublePhoton}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a photon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \Photon[double,sep=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DoublePhoton : +% #[ DashPhoton : +% +\defWithOption{DashPhoton}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a photon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \Photon[dash,dashsize=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashPhoton : +% #[ DashDoublePhoton : +% +\defWithOption{DashDoublePhoton}{(#2,#3)(#4,#5)#6#7#8#9}{% +% +% Draws a photon from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \Photon[double,sep=#8,dash,dashsize=#9,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashDoublePhoton : +% #[ PhotonArc : +% +\def\PhotonArc{% +% \PhotonArc(x,y)(r,theta1,theta2){amplitude}{numwind} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \AXO@Parse{\AXO@PhotonArc}{}% +} +% +% #] PhotonArc : +% #[ DoublePhotonArc : +% +\defWithOption{DoublePhotonArc}{(#2,#3)(#4,#5,#6)#7#8#9}{% +% +% \PhotonArc(x,y)(r,theta1,theta2){amplitude}{numwind}{sep} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \PhotonArc[double,sep=#9,#1](#2,#3)(#4,#5,#6){#7}{#8}% +} +% +% #] DoublePhotonArc : +% #[ DashPhotonArc : +% +\defWithOption{DashPhotonArc}{(#2,#3)(#4,#5,#6)#7#8#9}{% +% +% \DashPhotonArc(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \PhotonArc[dash,dashsize=#9,#1](#2,#3)(#4,#5,#6){#7}{#8}% +} +% +% +% #] DashPhotonArc : +% #[ DashDoublePhotonArc : +% +\defWithOption{DashDoublePhotonArc}{(#2)(#3)#4#5#6#7}{% +% Note that there are actually ten arguments with the optional #1, +% which LaTeX/TeX can't handle. I consolidate the comma separated +% arguments into one, and then pass them to \PhotonArc +% +% \DashPhotonArc(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \PhotonArc[double,sep=#6,dash,dashsize=#7,#1](#2)(#3){#4}{#5}% +} +% +% +% #] DashDoublePhotonArc : +% #[ PhotonArcn : +% +\defWithOption{PhotonArcn}{(#2,#3)(#4,#5,#6)#7#8}{% +% \PhotonArcn(x,y)(r,theta1,theta2){amplitude}{numwind} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \PhotonArc[clockwise,#1](#2,#3)(#4,#5,#6){#7}{#8}% +} +% +% #] PhotonArcn : +% #[ DoublePhotonArcn : +% +\defWithOption{DoublePhotonArcn}{(#2)(#3)#4#5#6}{% +% I consolidate the comma separated arguments into one, and then pass +% them to \PhotonArc +% +% \PhotonArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{sep} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \PhotonArc[clockwise,double,sep=#6,#1](#2)(#3){#4}{#5}% +} +% +% #] DoublePhotonArcn : +% #[ DashPhotonArcn : +% +\defWithOption{DashPhotonArcn}{(#2)(#3)#4#5#6}{% +% I consolidate the comma separated arguments into one, and then pass +% them to \PhotonArc +% +% \DashPhotonArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings.Clockwise. +% + \PhotonArc[clockwise,dash,dashsize=#6,#1](#2)(#3){#4}{#5}% +} +% +% +% #] DashPhotonArcn : +% #[ DashDoublePhotonArcn : +% +\defWithOption{DashDoublePhotonArcn}{(#2)(#3)#4#5#6#7}{% +% I consolidate the comma separated arguments into one, and then pass +% them to \PhotonArc +% +% \DashPhotonArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a photon on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings. Clockwise. +% + \PhotonArc[clockwise,double,sep=#6,dash,dashsize=#7,#1](#2)(#3){#4}{#5}% +} +% +% +% #] DashDoublePhotonArcn : +% #[ ZigZag : +% +\def\ZigZag{% +% \ZigZag[opt](x1,y1)(x2,y2){amplitude}{numwind} +% Draws a zigzag from (x1,y1) to (x2,y2) with given amplitude and +% number of windings +% Supported options: double, sep, linesep +% + \AXO@Parse{\AXO@ZigZag}{}% +} +% +% #] ZigZag : +% #[ DoubleZigZag : +% +\defWithOption{DoubleZigZag}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a zigzag from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \ZigZag[double,sep=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DoubleZigZag : +% #[ DashZigZag : +% +\defWithOption{DashZigZag}{(#2,#3)(#4,#5)#6#7#8}{% +% +% Draws a zigzag from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \ZigZag[dash,dashsize=#8,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashZigZag : +% #[ DashDoubleZigZag : +% +\defWithOption{DashDoubleZigZag}{(#2,#3)(#4,#5)#6#7#8#9}{% +% +% Draws a zigzag from (x1,y1) to (x2,y2) with amplitude and number of windings +% + \ZigZag[double,sep=#8,dash,dashsize=#9,#1](#2,#3)(#4,#5){#6}{#7}% +} +% +% #] DashDoubleZigZag : +% #[ ZigZagArc : +% +\def\ZigZagArc{% +% \ZigZagArc(x,y)(r,theta1,theta2){amplitude}{numwind} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \AXO@Parse{\AXO@ZigZagArc}{}% +} +% +% #] ZigZagArc : +% #[ DoubleZigZagArc : +% +\defWithOption{DoubleZigZagArc}{(#2,#3)(#4,#5,#6)#7#8#9}{% +% +% \ZigZagArc(x,y)(r,theta1,theta2){amplitude}{numwind}{sep} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \ZigZagArc[double,sep=#9,#1](#2,#3)(#4,#5,#6){#7}{#8}% +} +% +% #] DoubleZigZagArc : +% #[ DashZigZagArc : +% +\defWithOption{DashZigZagArc}{(#2)(#3)#4#5#6}{% +% +% \DashZigZagArc(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \ZigZagArc[dash,dashsize=#6,#1](#2)(#3){#4}{#5}% +} +% +% +% #] DashZigZagArc : +% #[ DashDoubleZigZagArc : +% +\defWithOption{DashDoubleZigZagArc}{(#2)(#3)#4#5#6#7}{% +% +% \DashZigZagArc(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \ZigZagArc[double,sep=#6,dash,dashsize=#7,#1](#2)(#3){#4}{#5}% +} +% +% +% #] DashDoubleZigZagArc : +% #[ ZigZagArcn : +% +\defWithOption{ZigZagArcn}{(#2)(#3)#4#5}{% +% \ZigZagArcn(x,y)(r,theta1,theta2){amplitude}{numwind} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \ZigZagArc[clockwise,#1](#2)(#3){#4}{#5}% +} +% +% #] ZigZagArcn : +% #[ DoubleZigZagArcn : +% +\defWithOption{DoubleZigZagArcn}{(#2)(#3)#4#5#6}{% +% +% \ZigZagArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{sep} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings +% + \ZigZagArc[clockwise,double,sep=#6,#1](#2)(#3){#4}{#5}% +} +% +% #] DoubleZigZagArcn : +% #[ DashZigZagArcn : +% +\defWithOption{DashZigZagArcn}{(#2)(#3)#4#5#6}{% +% +% \DashZigZagArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings.Clockwise. +% + \ZigZagArc[clockwise,dash,dashsize=#6,#1](#2)(#3){#4}{#5}% +} +% +% +% #] DashZigZagArcn : +% #[ DashDoubleZigZagArcn : +% +\defWithOption{DashDoubleZigZagArcn}{(#2)(#3)#4#5#6#7}{% +% +% \DashZigZagArcn(x,y)(r,theta1,theta2){amplitude}{numwind}{dashsize} +% draws a zigzag on an arc centered at (x,y) of radius r, starting +% at theta1, and ending at theta2, with given amplitude and +% number of windings. Clockwise. +% + \ZigZagArc[clockwise,double,sep=#6,dash,dashsize=#7,#1](#2)(#3){#4}{#5}% +} +% +% #] DashDoubleZigZagArcn : +% #] Particle routines : +% #[ Line routines : +% #[ Line : +% +\def\Line{% +% \Line[opt](x1,y1)(x2,y2) +% draws a line from (x1,y1) to (x2,y2). NO arrow by default. +% Supported options: all arrow settings, all double line settings, +% all dash line settings. +% + \AXO@Parse{\AXO@Line}{}% +} +% +% #] Line : +% #[ DoubleLine : +% +\defWithOption{DoubleLine}{(#2,#3)(#4,#5)#6}{% +% +% \DoubleLine[opt](x1,y1)(x2,y2){sep} +% Draws a double line, with NO arrow by default, from (x1,y1) to (x2,y2), +% with separation sep +% + \Line[arrow=false,double,sep=#6,#1](#2,#3)(#4,#5)% +} +% +% #] DoubleLine : +% #[ DashLine : +% +\defWithOption{DashLine}{(#2,#3)(#4,#5)#6}{% +% \DashLine[opt](x1,y1)(x2,y2){sep} +% Draws a line from (x1,y1) to (x2,y2) with a dash pattern of which the +% alternating black and white pieces are approximately sep points long +% + \Line[dash,dashsize=#6,#1](#2,#3)(#4,#5)% +} +% +% #] DashLine : +% #[ DashDoubleLine : +% +\defWithOption{DashDoubleLine}{(#2,#3)(#4,#5)#6#7}{% +% \DashDoubleLine[opt](x1,y1)(x2,y2){sep}{dashsize} +% Draws a double line from (x1,y1) to (x2,y2) with separation sep, +% and with a dash pattern of which the +% alternating black and white pieces are approximately sep points long +% Arrow off. + \Line[arrow=off,dash,dashsize=#7,double,sep=#6,#1](#2,#3)(#4,#5)% +} +% +% #] DashDoubleLine : +% #[ ArrowLine : +% +\defWithOption{ArrowLine}{(#2,#3)(#4,#5)}{% +% \ArrowLine[opt](x1,y1)(x2,y2) +% draws a line from (x1,y1) to (x2,y2). Arrow by default. +% + \Line[arrow,#1](#2,#3)(#4,#5)% +} +% +% #] ArrowLine : +% #[ ArrowDoubleLine : +% +\defWithOption{ArrowDoubleLine}{(#2,#3)(#4,#5)#6}{% +% +% \ArrowDoubleLine[opt](x1,y1)(x2,y2){sep} +% Draws a double line, with arrow by default, from (x1,y1) to (x2,y2), +% with separation sep +% + \Line[arrow,double,sep=#6,#1](#2,#3)(#4,#5)% +} +% +% #] ArrowDoubleLine : +% #[ DashArrowLine : +% +\defWithOption{DashArrowLine}{(#2,#3)(#4,#5)#6}{% +% \DashArrowLine[opt](x1,y1)(x2,y2){sep} +% Draws a line from (x1,y1) to (x2,y2) with a dash pattern of which the +% alternating black and white pieces are approximately sep points +% long. Arrow by default. +% + \Line[arrow,dash,dashsize=#6,#1](#2,#3)(#4,#5)% +} +% +\let\ArrowDashLine=\DashArrowLine% +% +% #] DashArrowLine : +% #[ DashArrowDoubleLine : +% +\defWithOption{DashArrowDoubleLine}{(#2,#3)(#4,#5)#6#7}{% +% \DashArrowDoubleLine[opt](x1,y1)(x2,y2){sep}{dashsize} +% Draws a double line from (x1,y1) to (x2,y2) with separation sep, +% and with a dash pattern of which the +% alternating black and white pieces are approximately sep points long +% Arrow on. +% + \Line[arrow,dash,dashsize=#7,double,sep=#6,#1](#2,#3)(#4,#5)% +} +% +\let\ArrowDashDoubleLine=\DashArrowDoubleLine% +% +% #] DashArrowDoubleLine : +% #[ LongArrow : +% +\defWithOption{LongArrow}{(#2,#3)(#4,#5)}{% + \Line[arrow,arrowpos=1,#1](#2,#3)(#4,#5)% +} +% +% #] LongArrow : +% #[ DashLongArrowLine : +% +\defWithOption{DashLongArrowLine}{(#2,#3)(#4,#5)#6}{% +% \DashLongArrowLine[opt](x1,y1)(x2,y2){sep} +% Draws a line from (x1,y1) to (x2,y2) with a dash pattern of which the +% alternating black and white pieces are approximately sep points +% long. Arrow by default. +% +% + \Line[arrow,arrowpos=1,dash,dashsize=#6,#1](#2,#3)(#4,#5)% +} +\let\DashLongArrow=\DashLongArrowLine +\let\LongArrowDash=\DashLongArrowLine +\let\LongArrowDashLine=\DashLongArrowLine +% +% #] DashLongArrowLine : +% #] Line routines : +% #[ Arc routines : +% #[ Arc : +% +\def\Arc{% +% \Arc[opt](x,y)(r,theta1,theta2) +% draws an arc centered at (x,y) of radius r, starting at theta1, +% and ending at theta2. By default: no arrow, undashed, single, +% anticlockwise. +% Supported options: all arrow settings, all double line settings, +% all dash line settings, clock +% + \AXO@Parse{\AXO@Arc}{}% +} +% +% #] Arc : +% #[ CArc : +% +\let\CArc=\Arc +% +% #] CArc : +% #[ DoubleArc : +% +\defWithOption{DoubleArc}{(#2,#3)(#4,#5,#6)#7}{% +% +% Draws a double lined arc segment. The center of the curve +% is at (1,2). +% The radius, start angle and target angle are (#3,#4,#5). +% The arc segment runs anticlockwise +% #6 is the separation of the lines. +% + \Arc[double,sep=#7,#1](#2,#3)(#4,#5,#6)% +} +\let\DoubleCArc=\DoubleArc +% +% #] DoubleArc : +% #[ DashArc : +% +\defWithOption{DashArc}{(#2,#3)(#4,#5,#6)#7}{% +% +% Draws a dashed arc segment. The center of the curve +% is at (1,2). +% The radius, start angle and target angle are (#3,#4,#5). +% The arc segment runs anticlockwise +% #6 is the dashsize. this is rounded to make things come +% out right. +% + \Arc[dash,dsize=#7,#1](#2,#3)(#4,#5,#6)% +} +\let\DashCArc=\DashArc +% +% #] DashArc : +% #[ DashDoubleArc : +% +\defWithOption{DashDoubleArc}{(#2,#3)(#4,#5,#6)#7#8}{ +% +% Draws a dashed arc segment. The center of the curve +% is at (1,2). +% The radius, start angle and target angle are (#3,#4,#5). +% The arc segment runs anticlockwise +% #6 is the line separation. +% #7 is the dashsize. this is rounded to make things come +% out right. +% + \Arc[double,sep=#7,dash,dsize=#8,#1](#2,#3)(#4,#5,#6)% +} +\let\DashDoubleCArc=\DashDoubleArc +% +% #] DashDoubleArc : +% #[ ArrowArc : +% +\def\ArrowArc{% + \AXO@PrependOption{\Arc}{arrow}% +} +\let\ArrowCArc=\ArrowArc +% +% #] ArrowArc : +% #[ ArrowDoubleArc : +% +\defWithOption{ArrowDoubleArc}{(#2,#3)(#4,#5,#6)#7}{% + \Arc[arrow,double,sep=#7,#1](#2,#3)(#4,#5,#6)% +} +\let\ArrowDoubleCArc=\ArrowDoubleArc +% +% #] ArrowDoubleArc : +% #[ ArrowDashArc : +% +\defWithOption{ArrowDashArc}{(#2,#3)(#4,#5,#6)#7}{% + \Arc[arrow,dash,dsize=#7,#1](#2,#3)(#4,#5,#6)% +} +\let\ArrowDashCArc=\ArrowDashArc +\let\DashArrowCArc=\ArrowDashArc +\let\DashArrowArc=\ArrowDashArc +% +% #] ArrowDashArc : +% #[ ArrowDashDoubleArc : +% +\defWithOption{ArrowDashDoubleArc}{(#2,#3)(#4,#5,#6)#7#8}{% + \Arc[arrow,double,sep=#7,dash,dsize=#8,#1](#2,#3)(#4,#5,#6)% +} +\let\ArrowDashDoubleCArc=\ArrowDashDoubleArc +\let\DashArrowDoubleCArc=\ArrowDashDoubleArc +\let\DashArrowDoubleArc=\ArrowDashDoubleArc +% +% +% #] ArrowDashDoubleArc : +% #[ LongArrowArc : +% +\def\LongArrowArc{% + \AXO@PrependOption{\Arc}{arrow,arrowpos=1}% +} +% +% #] LongArrowArc : +% #[ LongDashArrowArc : +% +\defWithOption{LongArrowDashArc}{(#2,#3)(#4,#5,#6)#7}{% + \Arc[arrow,arrowpos=1,dash,dsize=#7,#1](#2,#3)(#4,#5,#6)% +} +\let\LongArrowDashCArc=\LongArrowDashArc +\let\LongDashArrowCArc=\LongArrowDashArc +\let\LongDashArrowArc=\LongArrowDashArc +% +% +% #] LongDashArrowArc : +% #[ ArrowArcn : +% +\def\ArrowArcn{% + \AXO@PrependOption{\Arc}{arrow,clock}% +} +% +% #] ArrowArcn : +% #[ LongArrowArcn : +% +\def\LongArrowArcn{% + % \ArrowArcn, but with arrow at end by default + \AXO@PrependOption{\Arc}{arrow, clock, arrowpos=1}% +} +% +% #] LongArrowArcn : +% #[ DashArrowArcn : +% +\defWithOption{DashArrowArcn}{(#2,#3)(#4,#5,#6)#7}{% +% (x,y)(radius,start,end){dashsize} +% Draws a dashed arc segment with an arrow in it. The center of the curve +% is at (x,y), with given radius, start angle, and end angle +% The arc segment runs anticlockwise + \Arc[clock,arrow,dash,dashsize=#7,#1](#2,#3)(#4,#5,#6)% +} +% +\let\ArrowDashArcn=\DashArrowArcn% +% +% +% #] DashArrowArcn : +% #] Arc routines : +% #[ Bezier : +% +\def\Bezier{% +% \Bezier[opt](x1,y1)(x2,y2)(x3,y3)(x4,y4) +% Draws a Bezier cubic with the control points (x1,y1), (x2,y2), (x3,y3), (x4,y4) +% Supported options: dash, dashsize and dashsize + \AXO@Parse{\AXO@Bezier}{}% +} +% +\defWithOption{DoubleBezier}{(#2,#3)(#4,#5)(#6,#7)(#8)#9}{% +% +% Draws a Bezier cubic with control points (x1,y1), (x2,y2), +% (x3,y3), (x4,y4) in a double line +% + \Bezier[double,sep=#9,#1](#2,#3)(#4,#5)(#6,#7)(#8)% +} +% +\defWithOption{DashBezier}{(#2,#3)(#4,#5)(#6,#7)(#8)#9}{% +% +% Draws a Bezier cubic with control points (x1,y1), (x2,y2), +% (x3,y3), (x4,y4) with a dash pattern of which the +% alternating black and white pieces are approximately #9 points long +% + \Bezier[dash,dashsize=#9,#1](#2,#3)(#4,#5)(#6,#7)(#8)% +} +% +\defWithOption{DashDoubleBezier}{(#2,#3)(#4,#5)(#6)(#7)#8#9}{% +% +% Draws a Bezier cubic with control points (x1,y1), (x2,y2), +% (x3,y3), (x4,y4) with a dash pattern of which the +% alternating black and white pieces are approximately #9 points long +% The line is a double line +% + \Bezier[double,sep=#8,dash,dashsize=#9,#1](#2,#3)(#4,#5)(#6)(#7)% +} +% +% #] Bezier : +% #] LaTeX primitives : +% #[ Mixed routines : +% +% Here we have routines that make different calls depending on the value +% of the variable \axo@pdfoutput +% +% #[ EBox : +% +\def\EBox(#1,#2)(#3,#4){% +% +% Draws a transparent box with the left bottom at (x1,y1) andthe +% right top at (x2,y2). +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add \axowidth\space \axoscale\space ebox }} +\else + \getaxohelp{EBox}{#1 #2 #3 #4 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] EBox : +% #[ FBox : +% +\def\FBox(#1,#2)(#3,#4){% +% +% Draws a filled box with the left bottom at (x1,y1) and the right top +% at (x2,y2). +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add \axowidth\space \axoscale\space fbox }} +\else + \getaxohelp{FBox}{#1 #2 #3 #4 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] FBox : +% #[ BBox : +% +\def\BBox(#1,#2)(#3,#4){% +% +% Draws a box with the left bottom at (x1,y1) and the right top +% at (x2,y2). The contents are blanked out. +% + {% + \SetColor{White}% + \FBox(#1,#2)(#3,#4)% + }% + \EBox(#1,#2)(#3,#4)% +} +% +% #] BBox : +% #[ GBox : +% +\def\GBox(#1,#2)(#3,#4)#5{% +% +% Draws a box with the left bottom at (x1,y1) and the right top +% at (x2,y2). The contents are in Grayscale#5 (0=black,1=white). +% + {% + \color[gray]{#5}% + \FBox(#1,#2)(#3,#4)% + \color[gray]{0}% + \EBox(#1,#2)(#3,#4)% + }% +\ignorespaces +} +% +% #] GBox : +% #[ CBox : +% +\def\CBox(#1,#2)(#3,#4)#5#6{% +% +% Draws a box with the left bottom at (x1,y1) and the right top +% at (x2,y2). The outside is color#5 and the inside color #6. +% + {% + \SetColor{#6}% + \FBox(#1,#2)(#3,#4)% + \SetColor{#5}% + \EBox(#1,#2)(#3,#4)% + }% +\ignorespaces +} +% +% #] CBox : +% #[ EBoxc : +% +\def\EBoxc(#1,#2)(#3,#4){% +% +% Draws a centered box with the center at (x1,y1). +% The other parameters are the width and the height. +% Uses current color +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #3 2 div sub #2 \axoyo\space add + #4 2 div sub #1 \axoxo\space add #3 2 div add #2 + \axoyo\space add #4 2 div add \axowidth\space \axoscale\space ebox }} +\else + \getaxohelp{Boxc}{#1 #2 #3 #4 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +\let\Boxc=\EBoxc +% +% #] EBoxc : +% #[ FBoxc : +% +\def\FBoxc(#1,#2)(#3,#4){% +% +% Draws a filled centered box with the center at (x1,y1). +% The other parameters are the width and the height. +% Current color +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #3 2 div sub #2 \axoyo\space add + #4 2 div sub #1 \axoxo\space add #3 2 div add #2 \axoyo\space add #4 2 div add + \axowidth\space \axoscale\space fbox }} +\else + \getaxohelp{FBoxc}{#1 #2 #3 #4 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] FBoxc : +% #[ BBoxc : +% +\def\BBoxc(#1,#2)(#3,#4){% +% +% Draws a centered box with the center at (x1,y1). +% The other parameters are the width and the height. +% The contents are blanked out. +% +\bgroup + \SetColor{White}% + \FBoxc(#1,#2)(#3,#4)% +\egroup +\EBoxc(#1,#2)(#3,#4)% +} +% +% #] BBoxc : +% #[ GBoxc : +% +\def\GBoxc(#1,#2)(#3,#4)#5{% +% +% Draws a centered box with the center at (x1,y1). +% The other parameters are the width and the height. +% The contents are in Grayscale#5 (0=black,1=white). +% + {% + \color[gray]{#5}% + \FBoxc(#1,#2)(#3,#4)% + \color[gray]{0}% + \EBoxc(#1,#2)(#3,#4)% + }% +\ignorespaces +} +% +% #] GBoxc : +% #[ CBoxc : +% +\def\CBoxc(#1,#2)(#3,#4)#5#6{% +% +% Draws a centered box with the center at (x1,y1). +% The other parameters are the width and the height. +% The outside is color#5 and the inside color #6. +% + {% + \SetColor{#6}% + \FBoxc(#1,#2)(#3,#4)% + \SetColor{#5}% + \EBoxc(#1,#2)(#3,#4)% + }% +\ignorespaces +} +% +% #] CBoxc : +% #[ RotatedBox : +% +\def\RotatedBox(#1,#2)(#3,#4)#5#6{% +% +% Draws a centered box with the center at (#1,#2) +% with width #3, height #4, anticlockwise rotated by #5, and in +% color #6. +% + \AxoPut(#1,#2){% + {\SetColor{#6}% + \rotatebox{#5}{\EBoxc(0,0)(#3,#4)}% + }}% +} +% +% #] RotatedBox : +% #[ FilledRotatedBox : +% +\def\FilledRotatedBox(#1,#2)(#3,#4)#5#6{% +% +% Draws a filled centered box with the center at (#1,#2) +% with width #3, height #4, anticlockwise rotated by #5, and in +% color #6. +% + \AxoPut(#1,#2){% + {\SetColor{#6}% + \rotatebox{#5}{\FBoxc(0,0)(#3,#4)}% + }}% +} +% +% #] FilledRotatedBox : +% #[ ETri : +% +% Draws a triangle. No filling. +% The corners are (x1,y1), (x2,y2), (x3,y3) +% +\def\ETri(#1,#2)(#3,#4)(#5,#6){% +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add + #5 \axoxo\space add #6 \axoyo\space add + \axowidth\space \axoscale\space triangle }} +\else + \getaxohelp{ETri}{#1 #2 #3 #4 #5 #6 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] ETri : +% #[ FTri : +% +% Draws a filled triangle. +% The corners are (x1,y1), (x2,y2), (x3,y3) +% +\def\FTri(#1,#2)(#3,#4)(#5,#6){% +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add + #5 \axoxo\space add #6 \axoyo\space add + \axowidth\space \axoscale\space ftriangle }} +\else + \getaxohelp{FTri}{#1 #2 #3 #4 #5 #6 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] FTri : +% #[ BTri : +% +% Draws a triangle. The contents are blanked out. +% The corners are (x1,y1), (x2,y2), (x3,y3) +% +\def\BTri(#1,#2)(#3,#4)(#5,#6){% + {% + \SetColor{White}% + \FTri(#1,#2)(#3,#4)(#5,#6)% + }% + \ETri(#1,#2)(#3,#4)(#5,#6)% +} +% +% #] BTri : +% #[ GTri : +% +% Draws a triangle. The contents are given in Grayscale #7 (0=black,1=white) +% The corners are (x1,y1), (x2,y2), (x3,y3) +% +\def\GTri(#1,#2)(#3,#4)(#5,#6)#7{% +% + {% + \color[gray]{#7}% + \FTri(#1,#2)(#3,#4)(#5,#6)% + \color[gray]{0}% + \ETri(#1,#2)(#3,#4)(#5,#6)% + }% +\ignorespaces +} +% +% #] GTri : +% #[ CTri : +% +% Draws a colored(#7) triangle. The contents are blanked out in color #8 +% The corners are (x1,y1), (x2,y2), (x3,y3) +% +\def\CTri(#1,#2)(#3,#4)(#5,#6)#7#8{% + {% + \SetColor{#7}% + \FTri(#1,#2)(#3,#4)(#5,#6)% + \SetColor{#8}% + \ETri(#1,#2)(#3,#4)(#5,#6)% + }% +\ignorespaces +} +% +% #] CTri : +% #[ Vertex : +% +\def\Vertex(#1,#2)#3{% +% +% Draws a fat dot at (1,2). The radius of the dot is given by 3. +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add #3 + \axoscale\space vertex }} +\else + \getaxohelp{Vertex}{#1 #2 #3 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] Vertex : +% #[ ECirc : +% +\def\ECirc(#1,#2)#3{% +% +% Draws a circle at (1,2) and radius 3, with current color. +% Nothing is written inside. +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add #3 + \axowidth\space \axoscale\space ecirc }}% +\else + \getaxohelp{ECirc}{#1 #2 #3 \axowidth}% + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% +\fi +} +% +% #] ECirc : +% #[ FCirc : +% +\let\FCirc=\Vertex +% +% #] FCirc : +% #[ BCirc : +% +\def\BCirc(#1,#2)#3{% +% +% Draws a circle at (1,2) and radius 3 that is blanked out. + {% + \SetColor{White}% + \FCirc(#1,#2){#3} + }% + \ECirc(#1,#2){#3}% +} +% +% #] BCirc : +% #[ GCirc : +% +\def\GCirc(#1,#2)#3#4{% +% +% Draws a circle at (1,2) and radius 3 that is blanked out. +% Then it fills the circle with a gray scale 4 (0 = black, 1 is white) +% + {% + \color[gray]{#4}% + \FCirc(#1,#2){#3}% + \color[gray]{0}% + \ECirc(#1,#2){#3}% + }% +\ignorespaces +} +% +% #] GCirc : +% #[ CCirc : +% +% Draws a circle at (1,2) and radius 3 that is blanked out. +% #4 is the color of the circle, #5 the color of the contents +% +\def\CCirc(#1,#2)#3#4#5{% +% +% Draws a circle at (1,2) and radius 3 that is blanked out. +% #4 is the color of the circle, #5 the color of the contents +% +{% + \SetColor{#5}% + \FCirc(#1,#2){#3}% + \SetColor{#4}% + \ECirc(#1,#2){#3}% +}% +\ignorespaces +} +% +% #] CCirc : +% #[ GOval : +% +\def\GOval(#1,#2)(#3,#4)(#5)#6{% +% +% Draws a gray oval that overwrites whatever was there. +% \GOval(x_center,y_center)(height,width)(rotation)(grayscale) +% The grayscale: (0 = black, 1 is white) +% + {% + \color[gray]{#6}% + \FOval(#1,#2)(#3,#4)(#5)% + \color[gray]{0}% + \Oval(#1,#2)(#3,#4)(#5)% + }% + \ignorespaces +} +% +% #] GOval : +% #[ COval : +% +\def\COval(#1,#2)(#3,#4)(#5)#6#7{% +% +% Draws a colored oval that overwrites whatever was there. +% \COval(x_center,y_center)(height,width)(rotation){color1}{color2} +% + {% + \SetColor{#7}% + \FOval(#1,#2)(#3,#4)(#5)% + \SetColor{#6}% + \Oval(#1,#2)(#3,#4)(#5)% + }% + \ignorespaces +} +% +% #] COval : +% #[ FOval : +% +\def\FOval(#1,#2)(#3,#4)(#5){% +% +% Draws a colored oval that overwrites whatever was there. +% \FOval(x_center,y_center)(height,width)(rotation) +% Uses current color +% + \ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff)% + {\AXOspecial{#1 \axoxo\space add #2 \axoyo\space add #3 #4 #5 + \axowidth\space \axoscale\space foval + }}% + \else + \getaxohelp{FOval}{#1 #2 #3 #4 #5 \axowidth}% + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% + \fi +} +% +% #] FOval : +% #[ Oval : +% +\def\Oval(#1,#2)(#3,#4)(#5){% +% +% Draws an oval that does not overwrite whatever was there. +% \Oval(x_center,y_center)(height,width)(rotation) +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff)% + {\AXOspecial{#1 \axoxo\space add #2 \axoyo\space add #3 #4 #5 + \axowidth\space \axoscale\space oval + }}% +\else + \getaxohelp{Oval}{#1 #2 #3 #4 #5 \axowidth}% + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% +\fi +} +% +% #] Oval : +% #[ Polygon : +% +% Draws a curve through the points in argument 1. +% The points are given as coordinates (x1,y1)(x2,y2)(x3,y3)..... +% The curve is continous and continuous in its first and second +% derivatives. The method is linear interpolation of +% quadratic curves. +% Color name is argument 2. +% +\def\Polygon#1#2{% + {% + \SetColor{#2}% + \ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + [ \axoparray#1] \axowidth\space \axoscale\space polygon }}% + \else + \getaxohelp{Polygon}{"#1" \axowidth}% + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% + \fi + }% + \ignorespaces +} +% +% #] Polygon : +% #[ FilledPolygon : +% +% Draws a curve through the points in argument 1. +% The points are given as coordinates (x1,y1)(x2,y2)(x3,y3)..... +% The curve is continous and continuous in its first and second +% derivatives. The method is linear interpolation of +% quadratic curves. +% Color name is argument 2. +% +\def\FilledPolygon#1#2{% + {% + \SetColor{#2}% + \ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + [ \axoparray#1] \axowidth\space \axoscale\space filledpolygon }} + \else + \getaxohelp{FilledPolygon}{"#1" \axowidth}% + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% + \fi + }% + \ignorespaces +} +% +% #] FilledPolygon : +% #[ Curve : +% +% Draws a curve through the points in argument 1. +% The points are given as coordinates (x1,y1)(x2,y2)(x3,y3)..... +% The curve is continous and continuous in its first and second +% derivatives. The method is linear interpolation of quadratic curves. +% +\def\Curve#1{% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{[ \axoparray#1] + \axowidth\space \axoscale\space makecurve }} +\else + \getaxohelp{Curve}{"#1" \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] Curve : +% #[ DashCurve : +% +% Draws a curve through the points in argument 1. +% The points are given as coordinates (x1,y1)(x2,y2)(x3,y3)..... +% The curve is continous and continuous in its first and second +% derivatives. The method is linear interpolation of quadratic curves. +% Argument 2 gives a dash size. +% +\def\DashCurve#1#2{% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{[ \axoparray#1] #2 + \axowidth\space \axoscale\space makedashcurve }} +\else + \getaxohelp{DashCurve}{"#1" #2 \axowidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] DashCurve : +% #[ LinAxis : +% +\def\LinAxis(#1,#2)(#3,#4)(#5,#6,#7,#8,#9){% +% +% Draws a line with linear hash marks along it. +% LinAxis(x1,y1)(x2,y2)(num_decs,per_dec,hashsize,offset,width) +% The line is from (x1,y1) to (x2,y2) and the marks are on the left side +% when hashsize is positive, and right when it is negative. +% num_decs is the number of accented marks, per_dec the number of +% divisions between them and offset is the number +% at which one starts at (x1,y1) (like if offset=2 we start at the second +% small mark) Width is the linewidth. +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add + #5 #6 #7 #8 #9 \axoscale\space linaxis }} +\else + \getaxohelp{LinAxis}{#1 #2 #3 #4 #5 #6 #7 #8 #9} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] LinAxis : +% #[ LogAxis : +% +\def\LogAxis(#1,#2)(#3,#4)(#5,#6,#7,#8){% +% +% Draws a line with logarithmic hash marks along it. +% LogAxis(x1,y1)(x2,y2)(num_logs,hashsize,offset,width) +% The line is from (x1,y1) to (x2,y2) and the marks are on the left side +% when hashsize is positive, and right when it is negative. +% num_logs is the number of orders of magnitude and offset is the number +% at which one starts at (x1,y1) (like if offset=2 we start at 2) +% When offset is 0 we start at 1. Width is the linewidth. +% +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add + #5 #6 #7 #8 \axoscale\space logaxis }} +\else + \getaxohelp{LogAxis}{#1 #2 #3 #4 #5 #6 #7 #8} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +% #] LogAxis : +% #[ AxoGrid : +% +\def\AxoGrid(#1,#2)(#3,#4)(#5,#6)#7#8{% +% +% Makes a grid with the left bottom at #1,#2 +% The increments in x and y are #3,#4 +% The number of steps in each direction are #5,#6 (there are n+1 lines) +% #7 is the color and #8 the linewidth +% +{\SetColor{#7}% + \ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){% + \AXOspecial{% + #3 #4 #5 #6 + #1 \axoxo\space add #2 \axoyo\space add + #8 \axoscale\space axogrid + }}% + \else + \getaxohelp{Grid}{#1 #2 #3 #4 #5 #6 #8}% + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% + \fi +}% +\ignorespaces +} +% +% #] AxoGrid : +% #[ AXO@Arc : +% +% Generic Arc segment with many options. +% +% +\def\AXO@Arc(#1,#2)(#3,#4,#5){% +% +% Draws arc centered at (#1,#2), radius #3, starting and ending +% angles #4, #5. +% Double, dashing, arrow, clockwise according to current settings +% +{\AXO@useopts +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){% + \AXOspecial{% + \AXO@ArrowArg \space + \ifAXO@flip true \else false \fi + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \ifAXO@clock true \else false \fi + #3 #4 #5 + #1 \axoxo\space add #2 \axoyo\space add + \AXO@CurrentWidth\space \axoscale\space arc2 + }}% +\else + \getaxohelp{AxoArc}{#1 #2 #3 #4 #5 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@ArrowArg \space + \ifAXO@flip 1 \else 0 \fi + \ifAXO@clock 1 \else 0 \fi + \AXO@CurrentWidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +}\ignorespaces +} +% +% #] AXO@Arc : +% #[ AXO@Bezier : +% +\def\AXO@Bezier(#1,#2)(#3,#4)(#5,#6)(#7,#8){% +% +% Draws a Bezier cubic with the control points (x1,y1), (x2,y2), +% (x3,y3), (x4,y4) +% Assumes options have been set +% +{\AXO@useopts +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add + #5 \axoxo\space add #6 \axoyo\space add + #7 \axoxo\space add #8 \axoyo\space add + \AXO@ArrowArg \space + \ifAXO@flip true \else false \fi + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@CurrentWidth\space \axoscale\space dashdoublebezier + }}% +\else + \getaxohelp{AxoBezier}{#1 #2 #3 #4 #5 #6 #7 #8 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@ArrowArg \space + \ifAXO@flip 1 \else 0 \fi + \AXO@CurrentWidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +}\ignorespaces +} +% +% #] AXO@Bezier : +% #[ AXO@GluonHelper : +% +\def\AXO@GluonHelper(#1,#2)(#3,#4)#5#6#7#8{% +% +% Draws a single gluon from (x1,y1) to (x2,y2) with amplitude #5 and number +% of windings #6. Width #7 + #8 +% Assumes options have been set. +% Used as helper from \AXO@Gluon + % +\ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for gluon}\fi +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){% + \AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add + #5 #6 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + #7 #8 add \axoscale \space dashgluon + }% + }% +\else + \getaxohelp{AxoGluon}{#1 #2 #3 #4 #5 #6 + #7 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + #8}% + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% +\def\AXO@GluonHelperNEW(#1,#2)(#3,#4)#5#6#7#8{% +% IDEA: Showing cleaner code +% +% Draws a single gluon from (x1,y1) to (x2,y2) with amplitude #5 and number +% of windings #6. Width #7 + #8 +% Assumes options have been set. +% Used as helper from \AXO@Gluon +% + \ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for gluon}\fi + \ifcase\axo@pdfoutput + \AXOputPS{% + #1 #2 #3 #4 #5 #6 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + #7 #8 add \axoscale \space dashgluon + }% + \else + \getaxohelp{AxoGluon}{#1 #2 #3 #4 #5 #6 + #7 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + #8}% + \AXOputPDF{\contentspdfNoOffset}% + \fi +} +% +% #] AXO@GluonHelper : +% #[ AXO@Gluon : +% +\def\AXO@Gluon(#1,#2)(#3,#4)#5#6{% +% +% Draws a gluon from (x1,y1) to (x2,y2) with amplitude #5 and number +% of windings #6. +% Assumes options have been set +% +{\AXO@useopts + \ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for gluon}\fi + \AXO@arrowfalse % To avoid repeated errors + \ifAXO@double + \AXO@GluonHelper(#1,#2)(#3,#4){#5}{#6}{\AXO@CurrentWidth}{\AXO@CurrentSep}% + \SetColor{White}% + \AXO@dashfalse + \AXO@GluonHelper(#1,#2)(#3,#4){#5}{#6}{-\AXO@CurrentWidth}{\AXO@CurrentSep}% + \else + \AXO@GluonHelper(#1,#2)(#3,#4){#5}{#6}{0}{\AXO@CurrentWidth}% + \fi + }% +\ignorespaces +} +% #] AXO@Gluon : +% #[ AXO@GluonArcHelper : +% +\def\AXO@GluonArcHelper(#1,#2)(#3,#4,#5)#6#7#8#9{% +% +% Draws a gluon on an arc segment. The center of the curve is at (1,2) +% The radius, start angle and target angle are (#3,#4,#5), #6 is the +% amplitude of the gluon, and #7 is the number of windings. +% Assumes options have been set +% Width #8 + #9 +% Assumes options have been set. +% Used as helper from \AXO@GluonArc +\ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for gluon arc}\fi +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{#6 #7 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \ifAXO@clock true \else false \fi + #3 #4 #5 + #1 \axoxo\space add #2 \axoyo\space add + #8 #9 add \axoscale\space dashgluearc + }}% +\else + \getaxohelp{AxoGluonArc}{#1 #2 #3 #4 #5 #6 #7 + #8 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \ifAXO@clock 1 \else 0 \fi + #9} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% #] AXO@GluonArcHelper : +% #[ AXO@GluonArc : +% +\def\AXO@GluonArc(#1,#2)(#3,#4,#5)#6#7{% +% +% Draws a gluon on an arc segment. The center of the curve is at (1,2) +% The radius, start angle and target angle are (#3,#4,#5), #6 is the +% amplitude of the gluon, and #7 is the number of windings. +% Assumes options have been set +% + {\AXO@useopts + \ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for gluon}\fi + \AXO@arrowfalse % To avoid repeated errors + \ifAXO@double + \AXO@GluonArcHelper(#1,#2)(#3,#4,#5){#6}{#7}{\AXO@CurrentWidth}{\AXO@CurrentSep}% + \SetColor{White}% + \AXO@dashfalse + \AXO@GluonArcHelper(#1,#2)(#3,#4,#5){#6}{#7}{-\AXO@CurrentWidth}{\AXO@CurrentSep}% + \else + \AXO@GluonArcHelper(#1,#2)(#3,#4,#5){#6}{#7}{0}{\AXO@CurrentWidth}% + \fi + }% +\ignorespaces +} +% #] AXO@GluonArc : +% #[ AXO@GluonCircHelper : +% +\def\AXO@GluonCircHelper(#1,#2)(#3,#4)#5#6#7#8{% +% +% Draws a gluon on a circle. The center of the circle is at (1,2) +% The radius and the phase angle are (#3,#4), 5 is the +% amplitude of the gluon, and 6 is the number of windings. +% Width #7 + #8 +% Assumes options have been set. +% Used as helper from \AXO@GluonCirc +\ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for gluon arc}\fi +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #5 #6 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + #3 #4 + #1 \axoxo\space add #2 \axoyo\space add + #7 #8 add \axoscale\space dashgluoncirc + }}% +\else + \getaxohelp{AxoGluonCirc}{#1 #2 #3 #4 #5 #6 + #7 + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + #8} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +} +% #] AXO@GluonCicHelper : +% #[ AXO@GluonCirc : +% +\def\AXO@GluonCirc(#1,#2)(#3,#4)#5#6{% +% +% Draws a gluon on a circle. The center of the circle is at (1,2) +% The radius and the phase angle are (#3,#4), 5 is the +% amplitude of the gluon, and 6 is the number of windings. +% + {\AXO@useopts + \ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for gluon}\fi + \AXO@arrowfalse % To avoid repeated errors + \ifAXO@double + \AXO@GluonCircHelper(#1,#2)(#3,#4){#5}{#6}{\AXO@CurrentWidth}{\AXO@CurrentSep}% + \SetColor{White}% + \AXO@dashfalse + \AXO@GluonCircHelper(#1,#2)(#3,#4){#5}{#6}{-\AXO@CurrentWidth}{\AXO@CurrentSep}% + \else + \AXO@GluonCircHelper(#1,#2)(#3,#4){#5}{#6}{0}{\AXO@CurrentWidth}% + \fi + }% +\ignorespaces +} +% +% #] AXO@GluonCirc : +% #[ AXO@Line : +% +\def\AXO@Line(#1,#2)(#3,#4){% +% +% Draws a line from (x1,y1) to (x2,y2) +% Double, dashing, arrow according to current settings +% +{\AXO@useopts +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){% + \AXOspecial{% + \AXO@ArrowArg \space + \ifAXO@flip true \else false \fi + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add + \AXO@CurrentWidth \space \axoscale \space + dasharrowdoubleline + }}% +\else + \getaxohelp{AxoLine}{#1 #2 #3 #4 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@ArrowArg \space + \ifAXO@flip 1 \else 0 \fi + \AXO@CurrentWidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% +\fi +}\ignorespaces +} +% +% #] AXO@Line : +% #[ AXO@Photon : +% +\def\AXO@Photon(#1,#2)(#3,#4)#5#6{% +% +% Draws a photon from (x1,y1) to (x2,y2) with amplitude #5 and number +% of windings #6. +% Assumes options have been set +% +{\AXO@useopts +\ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for photon}\fi +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add #5 #6 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@CurrentWidth\space \axoscale\space dashdoublephoton }}% +\else + \getaxohelp{AxoPhoton}{#1 #2 #3 #4 #5 #6 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@CurrentWidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +}\ignorespaces +} +% #] AXO@Photon : +% #[ AXO@PhotonArc : +% +\def\AXO@PhotonArc(#1,#2)(#3,#4,#5)#6#7{% +% +% Draws a photon on an arc segment. The center of the curve is at (1,2) +% The radius, start angle and target angle are (#3,#4,#5), #6 is the +% amplitude of the gluon, and #7 is the number of wiggles. +% Assumes options have been set +% +{\AXO@useopts +\ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for photon arc}\fi +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #6 #7 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \ifAXO@clock true \else false \fi + #3 #4 #5 + #1 \axoxo\space add #2 \axoyo\space add + \AXO@CurrentWidth\space \axoscale\space dashdoublephotonarc + }}% +\else + \getaxohelp{AxoPhotonArc}{#1 #2 #3 #4 #5 #6 #7 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \ifAXO@clock 1 \else 0 \fi + \AXO@CurrentWidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +}\ignorespaces +} +% +% #] AXO@PhotonArc : +% #[ AXO@ZigZag : +% +\def\AXO@ZigZag(#1,#2)(#3,#4)#5#6{% +% +% Draws a zigzag from (x1,y1) to (x2,y2) with amplitude #5 and number +% of windings #6. +% Assumes options have been set +% +{\AXO@useopts +\ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for zigzag}\fi +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #1 \axoxo\space add #2 \axoyo\space add + #3 \axoxo\space add #4 \axoyo\space add #5 #6 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@CurrentWidth\space \axoscale\space dashdoublezigzag }}% +\else + \getaxohelp{AxoZigZag}{#1 #2 #3 #4 #5 #6 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \AXO@CurrentWidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}}% +\fi +}\ignorespaces +} +% #] AXO@ZigZag : +% #[ AXO@ZigZagArc : +% +\def\AXO@ZigZagArc(#1,#2)(#3,#4,#5)#6#7{% +% +% Draws a zigzag on an arc segment. The center of the curve is at (1,2) +% The radius, start angle and target angle are (#3,#4,#5), #6 is the +% amplitude of the gluon, and #7 is the number of wiggles. +% Assumes options have been set +% +{\AXO@useopts +\ifAXO@arrow\AXO@NOTIMPLEMENTED{arrow not implemented for zigzag arc}\fi +\ifcase\axo@pdfoutput + \put(\axoxoff,\axoyoff){\AXOspecial{% + #6 #7 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \ifAXO@clock true \else false \fi + #3 #4 #5 + #1 \axoxo\space add #2 \axoyo\space add + \AXO@CurrentWidth\space \axoscale\space dashdoublezigzagarc + }}% +\else + \getaxohelp{AxoZigZagArc}{#1 #2 #3 #4 #5 #6 #7 + \ifAXO@double \AXO@CurrentSep \space \else 0 \fi + \ifAXO@dash \AXO@CurrentDashSize \space \else 0 \fi + \ifAXO@clock 1 \else 0 \fi + \AXO@CurrentWidth} + \put(\axoxoff,\axoyoff){\axo@pdfliteral{\contentspdf}} +\fi +}\ignorespaces +} +% +% #] AXO@ZigZagArc : +% #[ Text and boxes : +% #[ SetPFont : +% +% To access fonts, from both latex and pdflatex, we need +% to define a mapping from the human-readable name to +% the name known to (pdf)latex. Then we can define a +% user command for setting the font. The human-readable +% name is the one used by postscript. +% Variables used: +% \pfontN = human name of current PS font (e.g., Helvetica). +% \pfontC = TeX code for the font (e.g., phvr). +% Both are \relax to use regular document font +% \axofontsize = size of font (text command with unit) + + +\def\defineaxofont#1#2{% + % #1 is user visible name of font, #2 is LaTex name. + % Define a command of name #1 to return #2 + \expandafter\def\csname #1\endcsname{#2} +} + +\def\SetPFont#1#2{% + \ifthenelse{ \equal{#1}{} }% + {\let\pfontN=\relax \let\pfontC=\relax}% + {\@ifundefined{#1}% + {\PackageWarning{axodraw2}{trying to set undefined font `#1'}}% + {\def\pfontN{#1}% Human name (postscript) + \def\pfontC{\@nameuse{#1}}% Code name + }% + }% + \ifthenelse{ \equal{#2}{} }% + {% Use the value of LaTeX's fontsize when the font is used: + \def\axofontsize{\f@size}% + }% + {\def\axofontsize{#2}}% +\ignorespaces +} + +\def\UseCurrentPSFont{% + % Set regular size of regular font, so math has rational size + \fontsize{\axofontsize}{\axofontsize}% + \selectfont + \ifx\pfontC\relax + \else + \font\axofont = \pfontC \space at \axofontsize pt + \axofont + \fi +} + +\defineaxofont{AvantGarde-Book}{pagk} +\defineaxofont{AvantGarde-BookOblique}{pagko} +\defineaxofont{AvantGarde-Demi}{pagd} +\defineaxofont{AvantGarde-DemiOblique}{pagdo} +\defineaxofont{Bookman-Demi}{pbkd} +\defineaxofont{Bookman-DemiItalic}{pbkdi} +\defineaxofont{Bookman-Light}{pbkl} +\defineaxofont{Bookman-LightItalic}{pbkli} +\defineaxofont{Courier-Bold}{pcrb} +\defineaxofont{Courier-BoldOblique}{pcrbo} +\defineaxofont{Courier}{pcrr} +\defineaxofont{Courier-Oblique}{pcrro} +\defineaxofont{Helvetica-Bold}{phvb} +\defineaxofont{Helvetica-BoldOblique}{phvbo} +\defineaxofont{Helvetica-NarrowBold}{phvbrn} +\defineaxofont{Helvetica-NarrowBoldOblique}{phvbon} +\defineaxofont{Helvetica}{phvr} +\defineaxofont{Helvetica-Oblique}{phvro} +\defineaxofont{Helvetica-Narrow}{phvrrn} +\defineaxofont{Helvetica-NarrowOblique}{phvron} +\defineaxofont{NewCenturySchlbk-Bold}{pncb} +\defineaxofont{NewCenturySchlbk-BoldItalic}{pncbi} +\defineaxofont{NewCenturySchlbk-Italic}{pncri} +\defineaxofont{NewCenturySchlbk-Roman}{pncr} +\defineaxofont{Palatino-Bold}{pplb} +\defineaxofont{Palatino-BoldItalic}{pplbi} +\defineaxofont{Palatino-Italic}{pplri} +\defineaxofont{Palatino-Roman}{pplr} +\defineaxofont{Symbol}{psyr} +\defineaxofont{Times-Bold}{ptmb} +\defineaxofont{Times-BoldItalic}{ptmbi} +\defineaxofont{Times-Italic}{ptmri} +\defineaxofont{Times-Roman}{ptmr} +\defineaxofont{ZapfChancery-MediumItalic}{pzcmi} +\defineaxofont{ZapfDingbats}{pzdr} + +% Now we can set the default: + +\SetPFont{Times-Roman}{10} + +% +% #] SetPFont : +% #[ Text : +% +% Aim: \Text(#1,#2)(#3)[#4]#5, to set text #5 at position (#1,#2) +% with angle #3 and positioning #4. +% But the presence of (#3) and [#3] is to be optional (with +% defaults being equivalent to (0) and [] +% +\def\Text(#1,#2){% + \@ifnextchar(% ) + {\Text@A(#1,#2)}% + {\Text@A(#1,#2)(0)}% +} +% +\def\Text@A(#1,#2)(#3){% + \@ifnextchar[% ] + {\Text@Z(#1,#2)(#3)}% + {\Text@Z(#1,#2)(#3)[]}% +} +% +\def\axoscaleTT{\ifPSTextScalesLikeGraphics 1\else \axotextscale \fi} +\def\axoscalePT{\ifPSTextScalesLikeGraphics \axoscale\else \axotextscale \fi} +% +\def\Text@Z(#1,#2)(#3)[#4]#5{% + % + % Draws text at (#1,#2). Argument #3 is combination of l, r, t, b to + % indicate positioning instead of default (which is horizontally and + % vertically centered --- these are same as \makebox + % the text is left adjusted, right adjusted or centered. Or b or t. + % 4 is of course the text. + % + \AxoPut(#1,#2){% + \scalebox{\axoscaleTT}% + {\rotatebox{#3}{\makebox(0,0)[#4]{#5}}}% + }% + \ignorespaces +} +% +% #] Text : +% #[ PText : *+ +% +\def\PText(#1,#2)(#3)[#4]#5{% +% +% Draws a postscript text in a postscript font. +% Focal point is (1,2), rotation angle is 3, 4 is the mode (as in text) +% and 5 is the text. +% + \begingroup + \UseCurrentPSFont + \AxoPut(#1,#2){% + \scalebox{\axoscalePT}% + {\rotatebox{#3}{\makebox(0,0)[#4]{#5}}}% + }% + \endgroup + \ignorespaces +} +% +% #] PText : +% #[ RText : +% +\def\RText(#1,#2)[#3](#4)#5{% +% +% Draws rotated text at (1,2). Argument 3 is l,r or c indicating whether +% the text is left adjusted, right adjusted or centered. +% 4 is the rotation angle and 5 is of course the text. +% + \Text(#1,#2)(#4)[#3]{#5}% + \ignorespaces +} +% +% #] RText : +% #[ rText : * +% +\def\rText(#1,#2)[#3][#4]#5{% +% +% Draws rotated text at (1,2). Argument 3 is l,r or c indicating whether +% the text is left adjusted, right adjusted or centered. +% 4 is the rotation angle (specified as l, r, u, or blank, +% and 5 is of course the text. +% + \begingroup + \def\this@angle{0}% + \ifx#4l% + \def\this@angle{90}% + \else + \ifx#4r% + \def\this@angle{-90}% + \else + \ifx#4u% + \def\this@angle{180}% + \fi + \fi + \fi + \Text(#1,#2)(\this@angle)[#3]{#5}% + \endgroup + \ignorespaces +} +% +% #] rText : +% #[ BText : +% +\def\BText(#1,#2)#3{% +% +% Draws a box with the center at (x1,y1) and postscript text #3 in it. +% + \AxoPut(#1,#2){% + \edef\axoscale{\axoscalePT}% + \SetTmpBox{#3}% + \BBoxc(0,0)(\tmpXT,\tmpYT)% + \PText(0,0)(0)[]{\usebox{\tmpBox}}% + }% + \ignorespaces +} +% +% #] BText : +% #[ GText : +% +\def\GText(#1,#2)#3#4{% +% +% Draws a box with the center at (x1,y1) and postscript(#4) text in it. +% The grayness of the box is given by #3 +% + \AxoPut(#1,#2){% + \edef\axoscale{\axoscalePT}% + \SetTmpBox{#4}% + \GBoxc(0,0)(\tmpXT,\tmpYT){#3}% + \PText(0,0)(0)[]{\usebox{\tmpBox}}% + }% + \ignorespaces +} +% +% #] GText : +% #[ CText : +% +\def\CText(#1,#2)#3#4#5{% +% +% Draws a box with the center at (x1,y1) and postscript(#5) text in it. +% The color of box and text is in #3 +% The color of the background is in #4 +% + \AxoPut(#1,#2){% + \edef\axoscale{\axoscalePT}% + \SetTmpBox{\SetColor{#3}{#5}}% + \CBoxc(0,0)(\tmpXT,\tmpYT){#3}{#4}% + \PText(0,0)(0)[]{\usebox{\tmpBox}}% + }% +} +% +% #] CText : +% #[ BTwoText : +% +\def\BTwoText(#1,#2)#3#4{% +% +% Draws a box with the center at (x1,y1) and two lines of postscript +% text in it. +% + \AxoPut(#1,#2){% + \edef\axoscale{\axoscalePT}% + \SetTmpBoxTwo{#3}{#4}% + \BBoxc(0,0)(\tmpXT,\tmpYT)% + \PText(0,0)(0)[]{\usebox{\tmpBox}}% + }% + \ignorespaces +} +% +% #] BTwoText : +% #[ GTwoText : +% +\def\GTwoText(#1,#2)#3#4#5{% +% +% Draws a box with the center at (x1,y1) and two lines of postscript +% text (#4 and #5) in it. +% The grayness of the box is given by #3 +% + \AxoPut(#1,#2){% + \edef\axoscale{\axoscalePT}% + \SetTmpBoxTwo{#4}{#5}% + \GBoxc(0,0)(\tmpXT,\tmpYT){#3}% + \PText(0,0)(0)[]{\usebox{\tmpBox}}% + }% + \ignorespaces +} +% +% #] GTwoText : +% #[ CTwoText : +% +\def\CTwoText(#1,#2)#3#4#5#6{% +% +% Draws a box with the center at (x1,y1) and two lines of postscript +% text (#5 and #6) in it. +% The color of the box and the text is given by #3 +% The background color is given by #4 +% + \AxoPut(#1,#2){% + \edef\axoscale{\axoscalePT}% + \SetTmpBoxTwo{\SetColor{#3}#5}{\SetColor{#3}#6}% + \CBoxc(0,0)(\tmpXT,\tmpYT){#3}{#4}% + \PText(0,0)(0)[]{\usebox{\tmpBox}}% + }% + \ignorespaces +} +% +% #] CTwoText : +% #] Text and boxes : +% #] Mixed routines : +% #[ Postscript specific : +% +% The code here is used only when we need Postscript output. This concerns +% mainly the Postscript library. +% +\ifcase\axo@pdfoutput +% +% #[ PostScript preamble : +% +\AtBeginDvi{ +% +% This forces the PostScript preamble commands to be put into the +% dvi file. Without this, revtex4 can remove them by funny +% stuff with manipulating the first page. +% +% #[ inventory : +% +% The variables in here are: +% num,num1,ampi,ampi1,x1,y1,x2,y2,x3,y3,x4,y4,dx,dy,dr +% width, arrowpos, arrowspec, arrowwidth, arrowlength, arrowinset +% arcend, arcmid, arcstart, radius, linesep, angdsize, dsize, +% clockwise, dotsize, inc, pi, sign +% darc,const,amp1, amp2, amp3, amp4, amp5, amp6, amp7, amp8, amp1i +% gcolor,xx2 +% +% NOTE: blank lines are not allowed inside the postscript code!!!!! +% (LaTeX sneaks \par commands in and the postscript goes boink) +% +\special{color} % Provoke dvips into including color.pro + % Revtex4 in 2-column mode fails to force that +% +\special{! + /savecolor { %/cmyk [ currentcmykcolor ] def + /oldcolor [ [ currentcolor ] currentcolorspace ] def + } def + /restorecolor { oldcolor aload pop setcolorspace aload pop setcolor } def +% /savecolor { [ currentcmykcolor ] /cmyk ed } def +% /restorecolor { cmyk aload pop setcmykcolor } def +% % Do a save color now, to ensure default variables are defined: + savecolor +} +% +\special{! + /pi 3.141592 def + /ed{exch def}def +% Implement conversion of length unit from pt to bp by scaling + /gs{gsave 1.00375 div dup scale}def + /gsw{ gs + /width ed + width setlinewidth + }def + /p1{/y1 ed /x1 ed}def + /p2{/y2 ed /x2 ed}def + /p3{/y3 ed /x3 ed}def + /p4{/y4 ed /x4 ed}def + /pp1{/yy1 ed /xx1 ed}def + /pp2{/yy2 ed /xx2 ed}def + /pp3{/yy3 ed /xx3 ed}def + /setabs{ + % Usage /var setabs + % Sets variable to its absolute value + dup load abs def + }def + % + /normalizearc { + % Usage: clockwise r angle1 angle2 x y normalizearc + % Adjusts coordinate system for anticlockwize arc from angle + % zero, centered at origin. + % Left on stack: r d_angle, with 0 x1 y1 x2 y2 r + % Pure stack based: computes distance between points. Keeps points + dup + 3 index sub dup mul + 2 index 5 index sub dup mul add sqrt + } def + /setbackgroundcolor{ + 0 0 0 0 setcmykcolor + } def +} +% +% #] inventory : +% #[ Arrows : +% +% Define better arrows +% +\special{! +% Arrow making routines +% + /getarrow { + /witharrow ed + /arrowpos ed + /arrowaspect ed + /arrowscale ed + /arrowinset ed + /arrowlength ed + /arrowwidth ed + /arrowstroke ed + } def + /drawarrow { + gsave + [] 0 setdash + rotate + arrowwidth 0 eq { + arrowlength 0 eq { + linewidth linesep 0.7 mul add 1 add 1.2 mul dup + 2.5 lt { + pop + 2.5 + } if + arrowscale mul + /arrowwidth ed + /arrowlength arrowwidth 2 mul arrowaspect mul def + } { + /arrowlength arrowlength arrowscale mul def + /arrowwidth arrowlength 2 div arrowaspect div def + } ifelse + } { + arrowlength 0 eq { + /arrowwidth arrowwidth arrowscale mul def + /arrowlength arrowwidth 2 mul arrowaspect mul def + } { + /arrowwidth arrowwidth arrowscale mul def + /arrowlength arrowlength arrowscale mul def + } ifelse + } ifelse + arrowstroke 0 ne { + arrowstroke setlinewidth + gsave + setbackgroundcolor + newpath + 0 arrowlength -0.5 mul moveto + arrowwidth arrowlength rlineto + arrowwidth -1 mul arrowlength arrowinset mul -1 mul rlineto + arrowwidth -1 mul arrowlength arrowinset mul rlineto + closepath fill + grestore + newpath + 0 arrowlength -0.5 mul moveto + arrowwidth arrowlength rlineto + arrowwidth -1 mul arrowlength arrowinset mul -1 mul rlineto + arrowwidth -1 mul arrowlength arrowinset mul rlineto + closepath stroke + } { + newpath + 0 arrowlength -0.5 mul moveto + arrowwidth arrowlength rlineto + arrowwidth -1 mul arrowlength arrowinset mul -1 mul rlineto + arrowwidth -1 mul arrowlength arrowinset mul rlineto + closepath fill + } ifelse + grestore + } def +% +} +% +% #] Arrows : +% +% Basic line drawing +% #[ fixdash : +% +\special{! /fixdash{ +% Usage: r dashsize fixdash +% Sets renormalized dashsize, doing +% [rdsize rdsize] 0 setdash +% so that n+1/2 patterns fit in length r +% If dsize is too big or if dsize is zero, use continuous line +% Uses stack, no named variables. + 2 copy gt + 1 index 0 ne + and + { + 2 copy + 2 mul div 0.5 sub round + dup 0 le { pop 0 } if + 2 mul 1 add exch pop div + dup 2 array astore 0 setdash + } + { pop pop [] 0 setdash } + ifelse +} def } +% +% #] fixdash : +% #[ dashline : +% +\special{! /dashline{ +% Draws a straight dashed line: x1,y1,x2,y2 +% Assumes dsize already set +% The pattern is ideally [dsize dsize] 0 setdash +% but we want to have (2*n+1)/2 patterns, so dsize must be rounded +% If dsize is too large or zero, use a continuous line +% Pure stack operation. + gsave + distance dsize fixdash % Function distance leaves points on stack + newpath + moveto + lineto + stroke + grestore +} def } +% #] dashline : +% #[ dasharc : +% +\special{! /dasharc{ +% Draws an arc segment anticlockwise: +% x_center, y_center, radius, start_angle, end_angle +% Assumes angdsize (radians) set elsewhere + gsave + 3 copy sub abs + % Top of stack is copy of radius, start_angle, end_angle + pi mul 180 div mul + % Top of stack is arc length + 3 index angdsize mul fixdash + newpath arc stroke + grestore +} def } +% +% #] dasharc : +% #[ dashgluon : +% +\special{! /dashgluon{ +% +% Draw gluon, possibly dashed +% We have a 'head' and a 'tail' and in between the 'body' +% The head + tail is 2 windings. The body is num-1 windings. +% + gsw + /dsize ed + /num ed /ampi ed + normalizeline /dr ed + /num num 0.5 sub round def +% + dsize 0 eq { + [] 0 setdash + } { + /amp8 ampi abs 0.9 mul def + /size amp8 neg 0 amp8 neg ampi 2 mul dup dr num 2 mul 2 add div exch + 1 lengthofbezier def +% + /ndash size dsize 2 mul div truncate def + ndash 0 eq { /ndash 1 def } if + size 2 dsize ndash mul mul sub abs + size 2 dsize ndash 1 add mul mul sub abs gt { /ndash ndash 1 add def } if + /dsize size 2 ndash mul div def + [ dsize dsize ] dsize 2 div setdash + } ifelse +% + /inc dr num 2 mul 2 add div def % increment per half winding + /amp8 ampi 0.9 mul def + amp8 0 lt {/amp8 amp8 neg def} if +% + /x1 inc 2 mul def +% + newpath + x1 ampi neg moveto + x1 amp8 add dup ampi neg exch ampi inc 1.4 mul ampi curveto + inc 0.5 mul ampi inc 0.1 mul ampi 0.5 mul 0 0 curveto + stroke + newpath + x1 ampi neg moveto + 2 1 num { + pop + x1 amp8 sub dup ampi neg exch ampi dup x1 inc add exch curveto + /x1 x1 inc dup add add def + x1 amp8 add dup ampi exch ampi neg dup x1 exch curveto + } for +% + x1 amp8 sub dup ampi neg exch ampi dup x1 inc 0.6 mul add exch curveto + x1 inc 1.5 mul add ampi dr inc 0.1 mul sub ampi 0.5 mul dr 0 curveto + stroke +% + grestore +} def } +% +% #] dashgluon : +% #[ dashdoublephoton : +% +\special{! /dashdoublephoton{ +% +% Draws a photon from x1,y1 to x2,y2 with amplitude A and n wiggles +% Possibly double +% + gsw + /dsize ed + /linesep ed + /num ed /ampi ed + normalizeline /dr ed + /num num 2 mul 0.5 sub round def +% + dsize 0 eq { + [] 0 setdash + } { +% Compute the dash size + /xdd dr num div def + /size 4 3 div xdd mul pi div dup neg xdd add + 4 3 div ampi mul dup 3 1 roll xdd 0 1 lengthofbezier 2 div def + /ndash size dsize 2 mul div truncate def + ndash 0 eq { /ndash 1 def } if + size 2 dsize ndash mul mul sub abs + size 2 dsize ndash 1 add mul mul sub abs gt { /ndash ndash 1 add def } if + /dsize size 2 ndash mul div def + [ dsize dsize ] dsize 2 div setdash + } ifelse +% + linesep 0 eq + { 0 0 dr 0 ampi num photon1 } + { +% 0 linesep 2 div dup dr exch ampi num photon1 +% 0 linesep -2 div dup dr exch ampi num photon1 +% + linesep width add setlinewidth 0 0 dr 0 ampi num photon1 + [] 0 setdash + 0 0 0 0 setcmykcolor + linesep width sub setlinewidth 0 0 dr 0 ampi num photon1 +% + } + ifelse + grestore +} def } +% +% #] dashdoublephoton : +% #[ photon1 : +% +\special{! /photon1{ +% +% Draws a single photon from x1,y1 to x2,y2 with amplitude A and n wiggles +% + gsave + /num1 ed /ampi1 ed + normalizeline /dr ed +% + /x2 dr num1 div def + /sign 1 def + 1 1 num1 { + pop + newpath + 0 0 moveto + 4 3 div x2 mul pi div dup neg x2 add + 4 3 div ampi1 sign mul mul dup 3 1 roll + x2 0 curveto + stroke + /sign sign neg def + x2 0 translate + } for +% + grestore +} def } +% +% #] photon1 : +% #[ dashdoublezigzag : +% +\special{! /dashdoublezigzag{ +% +% Draws a zigzag from x1,y1 to x2,y2 with amplitude A and n wiggles +% Possibly double +% + gsw + /dsize ed + /linesep ed + /num ed /ampi ed + normalizeline /dr ed + /num num 2 mul 0.5 sub round def +% + dsize 0 eq { + [] 0 setdash + } { +% Compute the dash size + /size dr num 2 mul div dup mul ampi dup mul add sqrt def + /ndash size dsize 2 mul div truncate def + ndash 0 eq { /ndash 1 def } if + size 2 dsize ndash mul mul sub abs + size 2 dsize ndash 1 add mul mul sub abs gt { /ndash ndash 1 add def } if + /dsize size 2 ndash mul div def + [ dsize dsize ] dsize 2 div setdash + } ifelse +% + linesep 0 eq + { 0 0 dr 0 ampi num zigzag1 } + { +% 0 linesep 2 div dup dr exch ampi num zigzag1 +% 0 linesep -2 div dup dr exch ampi num zigzag1 +% + linesep width add setlinewidth 0 0 dr 0 ampi num zigzag1 + [] 0 setdash + 0 0 0 0 setcmykcolor + linesep width sub setlinewidth 0 0 dr 0 ampi num zigzag1 +% + } + ifelse + grestore +} def } +% +% #] dashdoublezigzag : +% #[ zigzag1 : +% +\special{! /zigzag1{ +% +% Draws a single zigzag from x1,y1 to x2,y2 with amplitude A and n wiggles +% + gsave + /num1 ed /ampi1 ed + normalizeline /dr ed +% + /x2 dr num1 div def + /sign 1 def + 1 1 num1 { + pop + newpath + 0 0 moveto + x2 2 div ampi1 sign mul lineto + x2 0 lineto + stroke + /sign sign neg def + x2 0 translate + } for +% + grestore +} def } +% +% #] zigzag1 : +% #[ dashgluearc : +% +\special{! /dashgluearc{ +% +% Draws a gluon on an arcsegment +% gluon_radius, num, linesep (0 for no-double), dsize (0 for no dashes) +% clock, radius, start_angle, end_angle, x_center, y_center +% in which num is the number of windings of the gluon. +% +% Method for the gluon arc itself: +% 1: compute length of arc. +% 2: generate gluon in x and y as if the arc is a straight line +% 3: x' = (radius+y)*cos(x*const) +% y' = (radius+y)*sin(x*const) +% + gsw + normalizearc + /darc ed /radius ed /dsize ed /num ed /ampi ed + /num num 0.5 sub round def +% + dsize 0 eq { + [] 0 setdash + } { + /dr radius darc mul pi mul 180 div def % length of segment. + /const darc dr div def % conversion constant + /inc dr num 2 mul 2 add div def % increment per half winding + /amp8 ampi 0.9 mul def + /amp1 radius ampi add def + /amp2 radius ampi sub def + /amp4 amp1 inc amp8 add const mul cos div def + /amp5 amp2 amp8 const mul cos div def + amp8 0 lt {/amp8 amp8 neg def} if + /x1 inc 2 mul def + /x0 x1 const mul cos amp2 mul def + /y0 x1 const mul sin amp2 mul def + x1 amp8 sub const mul dup cos amp5 mul x0 sub exch sin amp5 mul y0 sub + x1 amp8 sub const mul dup cos amp4 mul x0 sub exch sin amp4 mul y0 sub + x1 inc add const mul dup cos amp1 mul x0 sub exch sin amp1 mul y0 sub + 1 lengthofbezier + /size ed +% + /ndash size dsize 2 mul div truncate def + ndash 0 eq { /ndash 1 def } if + size 2 dsize ndash mul mul sub abs + size 2 dsize ndash 1 add mul mul sub abs gt { /ndash ndash 1 add def } if + /dsize size 2 ndash mul div def + [ dsize dsize ] dsize 2 div setdash + } ifelse +% + /dr radius darc mul pi mul 180 div def % length of segment. + /const darc dr div def % conversion constant + /inc dr num 2 mul 2 add div def % increment per half winding + /amp8 ampi 0.9 mul def + /amp1 radius ampi add def + /amp2 radius ampi sub def + /amp3 radius ampi 2 div add def + /amp4 amp1 inc amp8 add const mul cos div def + /amp5 amp2 amp8 const mul cos div def + /amp6 amp1 inc 0.6 mul amp8 add const mul cos div def + /amp7 amp1 inc 0.9 mul const mul cos div def + amp8 0 lt {/amp8 amp8 neg def} if +% + newpath + /x1 inc 2 mul def + x1 const mul dup cos amp2 mul exch sin amp2 mul + moveto + x1 amp8 add const mul dup cos amp5 mul exch sin amp5 mul + x1 amp8 add const mul dup cos amp6 mul exch sin amp6 mul + inc 1.4 mul const mul dup cos amp1 mul exch sin amp1 mul + curveto + inc 0.5 mul const mul dup cos amp7 mul exch sin amp7 mul + inc 0.1 mul const mul dup cos amp3 mul exch sin amp3 mul + radius 0 + curveto + stroke + newpath + x1 const mul dup cos amp2 mul exch sin amp2 mul moveto + 2 1 num { pop + x1 amp8 sub const mul dup cos amp5 mul exch sin amp5 mul + x1 amp8 sub const mul dup cos amp4 mul exch sin amp4 mul + x1 inc add const mul dup cos amp1 mul exch sin amp1 mul + curveto + /x1 x1 inc dup add add def + x1 amp8 add const mul dup cos amp4 mul exch sin amp4 mul + x1 amp8 add const mul dup cos amp5 mul exch sin amp5 mul + x1 const mul dup cos amp2 mul exch sin amp2 mul + curveto + } for + x1 amp8 sub const mul dup cos amp5 mul exch sin amp5 mul + x1 amp8 sub const mul dup cos amp6 mul exch sin amp6 mul + x1 inc 0.6 mul add const mul dup cos amp1 mul exch sin amp1 mul + curveto + x1 inc 1.5 mul add const mul dup cos amp7 mul exch sin amp7 mul + dr inc 0.1 mul sub const mul dup cos amp3 mul exch sin amp3 mul + dr const mul dup cos radius mul exch sin radius mul + curveto + stroke +% + grestore +} def +} +% +% #] dashgluearc : +% #[ dashdoublephotonarc : +% +\special{! /dashdoublephotonarc{ +% +% Draws a photon on an arcsegment +% photon_radius, num, linesep (0 for no-double), dsize (0 for no dashes), +% clock, radius, start_angle, end_angle, x_center, y_center +% in which num is the number of wiggles of the photon. +% + gsw + normalizearc + /darc ed /radius ed /dsize ed /linesep ed /num ed /ampli ed +% + /num num 2 mul round def % number of half wiggles + /darc1 darc num div def + /cp darc1 cos def + /sp darc1 sin def + darc1 2 div dup + /cp2 exch cos def + /sp2 exch sin def +% + dsize 0 eq { + [] 0 setdash + } { +% +% Compute the length of the outer curve and the inner curve. +% There must be an integer number of patterns in half the sum. +% The we use half of the first to determine where in the pattern +% we should start. +% + /ampli1 ampli def + /beta radius darc1 mul 180 ampli1 mul div def + /tt sp cp beta mul sub cp sp beta mul add div def + /amp1 radius ampli1 add 8 mul beta cp2 mul sp2 sub mul beta 4 cp add mul + tt cp mul 3 mul sp 4 mul sub add radius mul sub + beta tt sub 3 mul div def % this is x2 + radius ampli1 add 8 mul cp2 mul 1 cp add radius mul sub 3 div amp1 sub + dup radius sub exch radius sub beta mul % x1,y1 + amp1 radius sub amp1 radius cp mul sub tt mul radius sp mul add % x2,y2 + radius cp mul radius sub radius sp mul % x3 y3 + 1 lengthofbezier + /len1 ed + /ampli1 ampli1 neg def + /beta radius darc1 mul 180 ampli1 mul div def + /tt sp cp beta mul sub cp sp beta mul add div def + /amp1 radius ampli1 add 8 mul beta cp2 mul sp2 sub mul beta 4 cp add mul + tt cp mul 3 mul sp 4 mul sub add radius mul sub + beta tt sub 3 mul div def % this is x2 + radius ampli1 add 8 mul cp2 mul 1 cp add radius mul sub 3 div amp1 sub + dup radius sub exch radius sub beta mul % x1,y1 + amp1 radius sub amp1 radius cp mul sub tt mul radius sp mul add % x2,y2 + radius cp mul radius sub radius sp mul % x3 y3 + 1 lengthofbezier + /len2 ed + /size len1 len2 add 2 div def + /size2 len1 2 div def +% + /ndash size dsize 2 mul div truncate def + ndash 0 eq { /ndash 1 def } if + size 2 dsize ndash mul mul sub abs + size 2 dsize ndash 1 add mul mul sub abs gt { /ndash ndash 1 add def } if + /dsize size 2 ndash mul div def + /numd size2 dsize 2 mul div truncate def + /dstart dsize 2 div size2 sub 2 numd dsize mul mul add def + dstart 0 lt { /dstart dstart dsize 2 mul add def } if + [ dsize dsize ] dstart setdash + } ifelse +% + linesep 0 eq { + radius photonarc1 + } { + linesep width add setlinewidth radius photonarc1 + [] 0 setdash + 0 0 0 0 setcmykcolor + linesep width sub setlinewidth radius photonarc1 + } ifelse +% + grestore +} def } +% +% #] dashdoublephotonarc : +% #[ photonarc1 : +% +\special{! /photonarc1{ +% Usage: radius photonarc1 +% Draws a single photon on an arcsegment. +% Called from dashdoublephotonarc with coordinates centered on center, +% start on x-axis. +% Assume the following are set: num, ampli, arcend phi, arcstart phi/2, cp, +% cp2, sp, sp2. +% Draws a photonarc center at x1,y1, radius arcstart,arcend, amplitude +% number of wiggles, width, scale +% + gsave + /radius1 ed + % Local copy of amplitude, since I change it + /ampli1 ampli def +% + newpath + radius1 0 moveto + 1 1 num { 1 sub /ii ed + /cpi darc1 ii mul cos def + /spi darc1 ii mul sin def + /beta radius1 darc1 mul 180 ampli1 mul div def + /tt sp cp beta mul sub cp sp beta mul add div def + /x2 radius1 ampli1 add 8 mul beta cp2 mul sp2 sub mul beta 4 cp add mul + tt cp mul 3 mul sp 4 mul sub add radius1 mul sub + beta tt sub 3 mul div def + /x1 radius1 ampli1 add 8 mul cp2 mul 1 cp add radius1 mul sub 3 div x2 sub def + /y1 x1 radius1 sub beta mul def + /y2 x2 radius1 cp mul sub tt mul radius1 sp mul add def + /x3 radius1 cp mul def + /y3 radius1 sp mul def + x1 cpi mul y1 spi mul sub y1 cpi mul x1 spi mul add + x2 cpi mul y2 spi mul sub y2 cpi mul x2 spi mul add + x3 cpi mul y3 spi mul sub y3 cpi mul x3 spi mul add + curveto + /ampli1 ampli1 neg def + } for + stroke +% + grestore +} def } +% +% #] photonarc1 : +% #[ dashdoublezigzagarc : +% +\special{! /dashdoublezigzagarc{ +% +% Draws a zigzag on an arcsegment +% zigzag_radius, num, linesep (0 for no-double), dsize (0 for no dashes), +% clock, radius, start_angle, end_angle, x_center, y_center +% in which num is the number of wiggles of the zigzag. +% + gsw + normalizearc + /darc ed /radius ed /dsize ed /linesep ed /num ed /ampli ed +% + /num num 2 mul round def % number of half wiggles + /darc1 darc num div def + /cp darc1 cos def + /sp darc1 sin def + darc1 2 div dup + /cp2 exch cos def + /sp2 exch sin def +% + dsize 0 eq { + [] 0 setdash + } { + /size ampli dup mul radius dup mul add radius dup mul ampli dup mul sub + cp mul sub 2 div sqrt def + /size2 ampli dup mul ampli radius add radius mul 2 mul 1 cp2 sub mul + add sqrt def +% + /ndash size dsize 2 mul div truncate def + ndash 0 eq { /ndash 1 def } if + size 2 dsize ndash mul mul sub abs + size 2 dsize ndash 1 add mul mul sub abs gt { /ndash ndash 1 add def } if + /dsize size 2 ndash mul div def + /numd size2 dsize 2 mul div truncate def + /dstart dsize 2 div size2 sub 2 numd dsize mul mul add def + dstart 0 lt { /dstart dstart dsize 2 mul add def } if + [ dsize dsize ] dstart setdash + } ifelse +% + linesep 0 eq { + radius zigzagarc1 + } { + linesep width add setlinewidth radius zigzagarc1 + [] 0 setdash + 0 0 0 0 setcmykcolor + linesep width sub setlinewidth radius zigzagarc1 + } ifelse +% + grestore +} def } +% +% #] dashdoublezigzagarc : +% #[ zigzagarc1 : +% +\special{! /zigzagarc1{ +% Usage: radius zigzagarc1 +% Draws a single zigzag on an arcsegment. +% Called from dashdoublezigzagarc with coordinates centered on center, +% start on x-axis. +% Assume the following are set: num, ampli, arcend phi, arcstart phi/2, cp, +% cp2, sp, sp2. +% Draws a zigzagarc center at x1,y1, radius arcstart,arcend, amplitude +% number of wiggles, width, scale +% + gsave + /radius1 ed +% Local copy of amplitude, since I change it + /ampli1 ampli def +% +% Num is the number of half wiggles. We like to start and end with +% quarter wiggles though. +% + /darc2 darc1 2 div def + newpath + radius1 0 moveto + darc2 dup sin exch cos + radius1 ampli1 add mul exch radius1 ampli1 add mul lineto + /ampli1 ampli1 neg def + /num1 num 1 sub def + 1 1 num1 { + darc1 mul darc2 add dup sin exch cos + radius1 ampli1 add mul exch radius1 ampli1 add mul lineto + /ampli1 ampli1 neg def + } for + num darc1 mul dup sin exch cos + radius1 mul exch radius1 mul lineto + stroke +% + grestore +} def } +% +% #] zigzagarc1 : +% #[ dashgluoncirc : +% +\special{! /dashgluoncirc{ +% +% Draws a gluon on a complete circle +% cmyk color setting +% gluon_ampl, num, linesep (0 for no-double), dsize (0 for no dashes) +% radius, phase_angle, x_center, y_center +% in which num is the number of windings of the gluon. +% + gsw + translate + /phase ed /radius ed /dsize ed /num ed /ampi ed + /num num 0.5 sub round def + /darc 180 num div def +% +% We rotate in such a way that 0 angle becomes more accessible. +% + darc phase add rotate +% + dsize 0 eq { + [] 0 setdash + } { + /dr radius 2 mul pi mul def % 2*pi*r + /inc dr 2 num mul div def % 2*pi*r/(2*num) + /const 360 dr div def % 360/(2*pi*r) + /amp8 ampi 0.9 mul def + /amp1 radius ampi add def + /amp2 radius ampi sub def + /amp4 amp1 inc amp8 add const mul cos div def + /amp5 amp2 amp8 const mul cos div def + amp8 0 lt {/amp8 amp8 neg def} if + /xx inc 2 mul def + /x0 amp1 inc const mul cos mul def + /y0 amp1 inc const mul sin mul def + amp4 xx amp8 add const mul cos mul x0 sub + amp4 xx amp8 add const mul sin mul y0 sub + amp5 xx amp8 add const mul cos mul x0 sub + amp5 xx amp8 add const mul sin mul y0 sub + amp2 xx const mul cos mul x0 sub + amp2 xx const mul sin mul y0 sub + 1 lengthofbezier + /size ed +% + /ndash size dsize 2 mul div truncate def + ndash 0 eq { /ndash 1 def } if + size 2 dsize ndash mul mul sub abs + size 2 dsize ndash 1 add mul mul sub abs gt { /ndash ndash 1 add def } if + /dsize size 2 ndash mul div def + [ dsize dsize ] dsize 2 div setdash + } ifelse +% + /dr radius 2 mul pi mul def % 2*pi*r + /inc dr 2 num mul div def % 2*pi*r/(2*num) + /const 360 dr div def % 360/(2*pi*r) + /amp8 ampi 0.9 mul def + /amp1 radius ampi add def + /amp2 radius ampi sub def + /amp4 amp1 inc amp8 add const mul cos div def + /amp5 amp2 amp8 const mul cos div def + amp8 0 lt {/amp8 amp8 neg def} if +% + newpath +% + /xx inc 2 mul def + amp1 inc const mul cos mul amp1 inc const mul sin mul moveto +% + 1 1 num { pop + amp4 xx amp8 add const mul cos mul + amp4 xx amp8 add const mul sin mul + amp5 xx amp8 add const mul cos mul + amp5 xx amp8 add const mul sin mul + amp2 xx const mul cos mul + amp2 xx const mul sin mul + curveto + amp5 xx amp8 sub const mul cos mul + amp5 xx amp8 sub const mul sin mul + amp4 xx amp8 sub const mul cos mul + amp4 xx amp8 sub const mul sin mul + amp1 xx inc add const mul cos mul + amp1 xx inc add const mul sin mul + curveto + /xx xx inc 2 mul add def + } for +% + stroke +% + grestore +} def } +% +% #] dashgluoncirc : +% #[ arc2 : +% +\special{! /arc2{ +% Draws an arc segment: +% arrowspec, arrowpos, flip, linesep, dsize, +% clock, radius, start_angle, end_angle, x_center, y_center, width, scale +% If linesep == 0, then single line, else double with separation linesep. +% + gsw + normalizearc + /darc ed /radius ed + /dsize ed /linesep ed + /angdsize dsize radius div def + /flip ed + getarrow + /arcmid darc arrowpos mul def + /linewidth width def + dsize 0 eq + { linesep 0 eq + { 0 0 radius 0 darc dasharc } + { gsave + linesep linewidth add setlinewidth + 0 0 radius 0 darc dasharc + setbackgroundcolor + [] 0 setdash + linesep linewidth sub setlinewidth + 0 0 radius 0 darc dasharc + grestore + } ifelse + } + { linesep 0 eq + { 0 0 radius 0 arcmid dasharc + 0 0 radius arcmid darc dasharc + } { + gsave + linesep linewidth add setlinewidth + 0 0 radius 0 arcmid dasharc + 0 0 radius arcmid darc dasharc + setbackgroundcolor + [] 0 setdash + linesep linewidth sub setlinewidth + 0 0 radius 0 darc dasharc + grestore + } ifelse + } ifelse + arcmid rotate + radius 0 translate + flip { 0 } { 180 } ifelse + witharrow { drawarrow } if + grestore +} def } +% +% #] arc2 : +% #[ dasharrowdoubleline : +% +\special{! /dasharrowdoubleline{ +% +% arrowspec, arrowpos, flip, linesep, dsize, +% x1, y1, x2, y2, width, scale +% If linesep == 0, then single line, else double with separation linesep. +% Draws a dashed double straight line with arrow. +% If dsize==0, then continuous line. +% If linesep==0, then single line. + gsw + normalizeline + /dr ed + /dsize ed + /linesep ed + /flip ed + getarrow +% + % If linesep is negative, that means the arrow is flipped. + % But the lineend coordinates are already flipped, so there is + % no need to make any adjustment; i.e., replace linesep by + % absolute value. + /linesep setabs + /linewidth width def + linesep 0 eq { + 0 0 dr 0 dashline + } { + gsave + linesep linewidth add setlinewidth 0 0 dr 0 dashline + setbackgroundcolor + [] 0 setdash + linesep linewidth sub setlinewidth 0 0 dr 0 newpath moveto lineto stroke + grestore + } ifelse + dr arrowpos mul 0 translate + flip { -90 }{ 90 } ifelse + witharrow { drawarrow } if + grestore +} def } +% +% #] dasharrowdoubleline : +% #[ vertex : +% +\special{! /vertex{ +% +% Puts a fat dot at x,y size is the radius of the dot +% + gs + /dotsize ed + translate + newpath + 0 0 dotsize 0 360 arc + fill stroke + grestore +} def } +% +% #] vertex : +% #[ ecirc : +% +\special{! /ecirc{ +% +% Draws an anti-clockwise circle : +% x_center, y_center, radius +% Transparent interior +% + gsw /radius ed + translate % x and y are still on stack + newpath 0 0 radius 0 360 arc stroke + grestore +} def } +% +% #] ecirc : +% #[ ebox : +% +\special{! /ebox{ +% +% Draws a transparent box x1,y1,x2,y2 +% + gsw p2 p1 + abox stroke + grestore +} def } +% +% #] ebox : +% #[ fbox : +% +\special{! /fbox{ +% +% Draws a filled box x1,y1,x2,y2 +% + gsw p2 p1 + abox fill + grestore +} def } +% +% #] fbox : +% #[ triangle : +% +\special{! /triangle{ +% +% Draws a triangle x1,y1,x2,y2,x3,y3 +% + gsw p3 p2 p1 + atriangle stroke + grestore +} def } +% +% #] triangle : +% #[ ftriangle : +% +\special{! /ftriangle{ +% +% Draws a triangle x1,y1,x2,y2,x3,y3 +% + gsw p3 p2 p1 + atriangle fill + grestore +} def } +% +% #] ftriangle : +% #[ ellipse: +% +\special{! /ellipse { + % Draw an ellipse + % RedGrittyBrick 20/10/2003 + % From http://www.redgrittybrick.org/postscript/ellipse.html. 2011/03/22 + % draw an ellipse using four bezier curves + % + /r2 exch def % 2nd parameter + /r1 exch def % 1st parameter + /kappa 0.5522847498 def + % + newpath + 0 r2 moveto % start point of curve + % + % top clockwise + kappa r1 mul r2 % 1st Bezier control point + r1 kappa r2 mul % 2nd Bezier control point + r1 0 curveto % end point of curve + % + % right clockwise + r1 kappa r2 mul neg + kappa r1 mul r2 neg + 0 r2 neg curveto + % + % bottom clockwise + kappa r1 mul neg r2 neg + r1 neg kappa r2 mul neg + r1 neg 0 curveto + % + % left clockwise + r1 neg kappa r2 mul + kappa r1 mul neg r2 + 0 r2 curveto + % + } def % ellipse +} +% +% #] ellipse: +% #[ goval : +% +\special{! /goval{ +% +% Draws a gray oval that overwrites whatever was there. +% x_center y_center height width rotation color linewidth scale +% + gsw /gcolor ed /angle ed /width ed /height ed +% + translate % x and y are still on stack + angle rotate + 1 setgray width height ellipse fill + gcolor setgray width height ellipse fill + 0 setgray width height ellipse stroke + grestore +} def } +% +% #] goval : +% #[ fcoval : +% +\special{! /foval{ +% +% Draws an oval that overwrites whatever was there. +% x_center y_center height width rotation linewidth scale +% + gsw /angle ed /width ed /height ed +% + translate % x and y are still on stack + angle rotate + width height ellipse fill + grestore +} def } +% +% #] foval : +% #[ oval : +% +\special{! /oval{ +% +% Draws an oval that does not overwrite whatever was there. +% x_center y_center height width rotation linewidth scale +% + gsw /angle ed /width ed /height ed +% + translate % x and y are still on stack + angle rotate + width height ellipse stroke + grestore +} def } +% +% #] oval : +% #[ polygon : +% +% Incoming stack: +% [array of x,y pairs] width scale +% +\special{! /polygon{ + gsw /points ed + /ss points length 2 idiv 2 mul def + ss 4 gt { + newpath + points 0 get points 1 get moveto + 0 2 ss 4 sub { /ii ed + /x1 points ii 2 add get def + /y1 points ii 3 add get def + x1 y1 lineto + } for + closepath + stroke + } if + grestore +} def } +% +% #] polygon : +% #[ filledpolygon : +% +% Incoming stack: +% [array of x,y pairs] width scale +% +\special{! /filledpolygon{ + gsw /points ed + /ss points length 2 idiv 2 mul def + ss 4 gt { + newpath + points 0 get points 1 get moveto + 0 2 ss 4 sub { /ii ed + /x1 points ii 2 add get def + /y1 points ii 3 add get def + x1 y1 lineto + } for + closepath + fill + } if + grestore +} def } +% +% #] filledpolygon : +% #[ makecurve : +% +\special{! /docurve{ + x1 2 mul x2 add 3 div + y1 y0 sub x1 x0 sub div x2 x0 sub mul + y2 y0 sub x2 x0 sub div x1 x0 sub mul add + y1 add y0 2 mul add 3 div + x1 x2 2 mul add 3 div + y2 y3 sub x2 x3 sub div x1 x3 sub mul + y1 y3 sub x1 x3 sub div x2 x3 sub mul add + y2 add y3 2 mul add 3 div + x2 y2 curveto +} def } +% +\special{! /makecurve{ +% +% Incoming stack: +% [array of x,y pairs] width scale +% + gsw /points ed + /ss points length 2 idiv 2 mul def + newpath + ss 4 gt { + /x1 points 0 get def + /y1 points 1 get def + /x2 points 2 get def + /y2 points 3 get def + /x3 points 4 get def + /y3 points 5 get def + /x0 x1 2 mul x2 sub def + /y0 y3 y2 sub x3 x2 sub div y2 y1 sub x2 x1 sub div sub 2 mul + x2 x1 sub dup mul x3 x1 sub div mul + y1 2 mul add y2 sub def + x1 y1 moveto + docurve + 0 2 ss 8 sub { /ii ed + /x0 points ii get def + /y0 points ii 1 add get def + /x1 points ii 2 add get def + /y1 points ii 3 add get def + /x2 points ii 4 add get def + /y2 points ii 5 add get def + /x3 points ii 6 add get def + /y3 points ii 7 add get def + docurve + } for + /x0 points ss 6 sub get def + /y0 points ss 5 sub get def + /x1 points ss 4 sub get def + /y1 points ss 3 sub get def + /x2 points ss 2 sub get def + /y2 points ss 1 sub get def + /x3 x2 2 mul x1 sub def + /y3 y2 y1 sub x2 x1 sub div y1 y0 sub x1 x0 sub div sub 2 mul + x2 x1 sub dup mul x2 x0 sub div mul + y2 2 mul add y1 sub def + docurve + } { + ss 4 eq { + points 0 get points 1 get moveto + points 2 get points 3 get lineto + } if + } ifelse + stroke + grestore +} def } +% +% #] makecurve : +% #[ makedashcurve : +% +\special{! /makedashcurve{ +% +% Incoming stack: +% [array of x,y pairs] dashsize width scale +% + gsw /dsize ed /points ed + /ss points length 2 idiv 2 mul def + newpath + ss 4 gt { + /x1 points 0 get def + /y1 points 1 get def + /x2 points 2 get def + /y2 points 3 get def + /x3 points 4 get def + /y3 points 5 get def + /x0 x1 2 mul x2 sub def + /y0 y3 y2 sub x3 x2 sub div y2 y1 sub x2 x1 sub div sub 2 mul + x2 x1 sub dup mul x3 x1 sub div mul + y1 2 mul add y2 sub def + x1 y1 moveto + docurve + 0 2 ss 8 sub { /ii ed + /x0 points ii get def + /y0 points ii 1 add get def + /x1 points ii 2 add get def + /y1 points ii 3 add get def + /x2 points ii 4 add get def + /y2 points ii 5 add get def + /x3 points ii 6 add get def + /y3 points ii 7 add get def + docurve + } for + /x0 points ss 6 sub get def + /y0 points ss 5 sub get def + /x1 points ss 4 sub get def + /y1 points ss 3 sub get def + /x2 points ss 2 sub get def + /y2 points ss 1 sub get def + /x3 x2 2 mul x1 sub def + /y3 y2 y1 sub x2 x1 sub div y1 y0 sub x1 x0 sub div sub 2 mul + x2 x1 sub dup mul x2 x0 sub div mul + y2 2 mul add y1 sub def + docurve + } { + ss 4 eq { + points 0 get points 1 get moveto + points 2 get points 3 get lineto + } if + } ifelse + centerdash + stroke + grestore +} def } +% +\special{! /pathlength{ + flattenpath + /dist 0 def + { /yfirst ed /xfirst ed /ymoveto yfirst def /xmoveto xfirst def } + { /ynext ed /xnext ed /dist dist ynext yfirst sub dup mul + xnext xfirst sub dup mul add sqrt add def + /yfirst ynext def /xfirst xnext def } + {} + {/ynext ymoveto def /xnext xmoveto def + /dist ynext yfirst sub dup mul + xnext xfirst sub dup mul add sqrt add def + /yfirst ynext def /xfirst xnext def } + pathforall + dist +} def } +% +\special{! /centerdash{ + /pathlen pathlength def + /jj pathlen dsize div 2.0 div cvi def + /ddsize pathlen jj 2.0 mul div def + [ddsize] ddsize 2 div setdash +} def } +% +% #] makedashcurve : +% #[ logaxis : +% +\special{! /logaxis{ +% +% Draws an axis from x1,y1 to x2,y2 with nl log divisions +% size of the hashes hs, offset F +% and width W. The stack looks like +% x1,y1,x2,y2,nl,hs,F,W,scale +% After the rotation the hash marks are on top if nl is positive and +% on the bottom if nl is negative +% + gsw /offset ed /hashsize ed /nlogs ed + normalizeline /rr ed + offset 0 ne { /offset offset ln 10 ln div def } if + /offset offset dup cvi sub def + newpath + 0 0 moveto + rr 0 lineto + /lsize rr nlogs div def + 0 1 nlogs { /x2 ed + x2 offset ge { + /y2 x2 offset sub lsize mul def + y2 rr le { + y2 0 moveto + y2 hashsize 1.2 mul lineto + } if + } if + } for + stroke + width 0.6 mul setlinewidth + newpath + 0 1 nlogs { /x2 ed + 2 1 9 { + ln 10 ln div x2 add + /xx2 ed + xx2 offset ge { + /y2 xx2 offset sub lsize mul def + y2 rr le { + y2 0 moveto + y2 hashsize 0.8 mul lineto + } if + } if + } for + } for + stroke + grestore +} def } +% +% #] logaxis : +% #[ linaxis : +% +\special{! /linaxis{ +% +% x1,y1,x2,y2,num_decs,per_dec,hashsize,offset,width,scale +% + gsw /offset ed /hashsize ed /perdec ed /numdec ed + normalizeline + /rr ed + /perdec perdec round def + /offset offset + % Do real equivalent of offset perdec mod + dup cvi perdec idiv + sub + dup 0 lt {perdec add} if + dup perdec ge {perdec sub} if + def + newpath + 0 0 moveto + rr 0 lineto + /x1 rr numdec perdec mul div def + /y1 rr numdec div def + offset 0 eq {0} {1} ifelse 1 numdec + { y1 mul offset x1 mul sub + dup 0 moveto + hashsize 1.2 mul lineto + } for + stroke + width 0.6 mul setlinewidth + newpath + /offset offset dup cvi sub def + offset 0 eq {0} {1} ifelse 1 numdec perdec mul { + offset sub x1 mul + dup 0 ge { + dup rr le { + dup 0 moveto + hashsize 0.8 mul lineto + } if + } if + } for + stroke + grestore +} def } +% +% #] linaxis : +% #[ dashbezier : +% +\special{! /dashbezier{ +% +% Draws a dashed Bezier with control points x1,y1,x2,y2,x3,y3,x4,y4 +% + gsw /dsize ed p4 p3 p2 p1 + dsize 0 ne { + /size x2 x1 sub y2 y1 sub x3 x1 sub y3 y1 sub x4 x1 sub y4 y1 sub + 1 lengthofbezier def + /numdashes size dsize 2 mul div def + numdashes 0 eq { /numdashes 1 def } if + size dsize 2 mul numdashes mul sub abs + size dsize 2 mul numdashes 1 add mul sub abs + gt { /numdashes 1 add def } if + /dsize size numdashes 2 mul div def + [dsize dsize] dsize 2 div setdash + } if + abezier stroke + grestore +} def } +% +% #] dashbezier : +% #[ dashdoublebezier : +% +\special{! /dashdoublebezier{ +% +% Draws a dashed Bezier with control points x1,y1,x2,y2,x3,y3,x4,y4 +% + gsw /dsize ed /linesep ed + /flip ed + getarrow + p4 p3 p2 p1 + /linewidth width def + /bsize x2 x1 sub y2 y1 sub x3 x1 sub y3 y1 sub x4 x1 sub y4 y1 sub + 1 lengthofbezier def + dsize 0 ne { + /numdashes bsize dsize 2 mul div def + numdashes 0 eq { /numdashes 1 def } if + bsize dsize 2 mul numdashes mul sub abs + bsize dsize 2 mul numdashes 1 add mul sub abs + gt { /numdashes 1 add def } if + /dsize bsize numdashes 2 mul div def + [dsize dsize] dsize 2 div setdash + } if + linesep 0 ne { + linesep linewidth add setlinewidth abezier stroke + gsave + 0 0 0 0 setcmykcolor + linesep linewidth sub setlinewidth abezier stroke + grestore + } { + abezier stroke + } ifelse +% + witharrow { + /tb arrowpos def + /tbmax 1 def /tbmin 0 def + { + /sizeb x2 x1 sub y2 y1 sub x3 x1 sub y3 y1 sub x4 x1 sub y4 y1 sub + tb lengthofbezier def + sizeb bsize div arrowpos sub abs 0.0001 le { exit } if + sizeb bsize div arrowpos gt + { /tbmax tb def /tb tb tbmin add 2 div def } + { /tbmin tb def /tb tb tbmax add 2 div def } ifelse + } loop + /ub 1 tb sub def + x1 ub ub ub mul mul mul tb x2 3 mul ub mul ub mul tb x3 3 mul ub mul + x4 tb mul add mul add mul add + y1 ub ub ub mul mul mul tb y2 3 mul ub mul ub mul tb y3 3 mul ub mul + y4 tb mul add mul add mul add translate + y4 tb dup mul mul y3 tb mul 2 3 tb mul sub mul add y2 ub mul 1 3 tb mul + sub mul add y1 ub dup mul mul sub 3 mul + x4 tb dup mul mul x3 tb mul 2 3 tb mul sub mul add x2 ub mul 1 3 tb mul + sub mul add x1 ub dup mul mul sub 3 mul + atan rotate + flip { -90 }{ 90 } ifelse + drawarrow + } if +% + grestore +} def } +% +% #] dashdoublebezier : +% #[ lengthofbezier : +% +% Calculates the length of a Bezier curve assuming that we start +% in the point 0,0. We use a Gaussian quadrature with 16 points. +% If, at any time, more precision is needed we have the 32 points +% numbers in axohelp.c. (and there is more commentary in that file) +% +\special{! + /g16x1 { 0.095012509837637440185 } def + /g16x2 { 0.281603550779258913230 } def + /g16x3 { 0.458016777657227386342 } def + /g16x4 { 0.617876244402643748447 } def + /g16x5 { 0.755404408355003033895 } def + /g16x6 { 0.865631202387831743880 } def + /g16x7 { 0.944575023073232576078 } def + /g16x8 { 0.989400934991649932596 } def + /g16w1 { 0.189450610455068496285 } def + /g16w2 { 0.182603415044923588867 } def + /g16w3 { 0.169156519395002538189 } def + /g16w4 { 0.149595988816576732081 } def + /g16w5 { 0.124628971255533872052 } def + /g16w6 { 0.095158511682492784810 } def + /g16w7 { 0.062253523938647892863 } def + /g16w8 { 0.027152459411754094852 } def + /onepoint { + /gpt ed + /tpt 1 gpt add 2 div tmax mul def + xc tpt mul xb add tpt mul xa add dup mul + yc tpt mul yb add tpt mul ya add dup mul + add sqrt + /tpt 1 gpt sub 2 div tmax mul def + xc tpt mul xb add tpt mul xa add dup mul + yc tpt mul yb add tpt mul ya add dup mul + add sqrt add 2 div + } def + /lengthofbezier { + /tmax ed + pp3 pp2 pp1 + /xa xx1 3 mul def /xb xx2 xx1 2 mul sub 6 mul def + /xc xx3 xx2 xx1 sub 3 mul sub 3 mul def + /ya yy1 3 mul def /yb yy2 yy1 2 mul sub 6 mul def + /yc yy3 yy2 yy1 sub 3 mul sub 3 mul def +% + g16x1 onepoint g16w1 mul + g16x2 onepoint g16w2 mul add + g16x3 onepoint g16w3 mul add + g16x4 onepoint g16w4 mul add + g16x5 onepoint g16w5 mul add + g16x6 onepoint g16w6 mul add + g16x7 onepoint g16w7 mul add + g16x8 onepoint g16w8 mul add + tmax mul + } def +} +% #] lengthofbezier : +% #[ axogrid : +% +\special{! /axogrid{ + gsw translate + /ny ed /nx ed /dy ed /dx ed + /maxx nx dx mul def + /maxy ny dy mul def + 0 1 nx { + newpath dx mul dup 0 moveto maxy lineto stroke + } for + 0 1 ny { + newpath maxx exch dy mul dup 0 exch moveto lineto stroke + } for +} def } +% +% #] axogrid : +} +% #] PostScript preamble : +% #[ axoparray : Puts an array of 2-dim points +% +% Puts a sequence of points in the notation (x1,y1)(x2,y2).... +% on the Postscript stack. This is for Curve and DashCurve. +% +\let\eind=] +% +\def\axoparray(#1,#2)#3{#1 \axoxo\space add #2 \axoyo\space add \ifx #3\eind\else +\expandafter\axoparray\fi#3} +% +% #] axoparray : +% +\fi +% #] Postscript specific : +% #[ PDF specific : +% +% Here are the routines that are used purely for the PDF output. +% The main concern here is the communication with the axohelp program. +% +\ifcase\axo@pdfoutput\else +% +% #[ getaxohelp : +% +% This is the command that makes the PDF work. Use as in +% getaxohelp{NameOfFunction}{parameters to be passed} +% The format is very precise. If axohelp is not happy there will +% be no output. The most common error is that the parameters are +% not separated by black spaces. Some \space might have to be inserted. +% The reason we do not separate the parameters by comma's is that +% both Postscript and PDF want their objects separated by blanks. +% Also a separation by blanks makes the parameters into separate +% arguments in the call to axohelp. Our colors need blanks.... +% +% +\def\getoneline#1#2{% + % Set the command of name #1 to the next line of the file + % for which the input stream number is #2. + \def\tmpfh{#2}% + \ifeof\tmpfh + \else + \read\tmpfh to \tmpline + \fi + \ifeof\tmpfh + \@namedef{#1}{}% + \else + \expandafter \let \csname #1\endcsname = \tmpline + \fi +} +% +\def\getaxohelp#1#2{% + \def\axohelp{}% + \stepcounter{axo@objectIndex}% + \def\axo@currentInput{#1 #2;}% + \immediate\write\axo@spec{[\arabic{axo@objectIndex}]\space \axo@currentInput}% + \ifaxo@axohelpRerun% + \else% + \def\axo@currentInput{{#1 #2;}}% + \getoneline{axo@partOne}\axo@axohelpFile% + \catcode`\ =13% + \getoneline{axo@partTwo}\axo@axohelpFile% + \catcode`\ =10% + \getoneline{axo@partThree}\axo@axohelpFile% + \ifeof\axo@axohelpFile + \rlap{New object; rerun axohelp}% + \global\axo@axohelpReruntrue + \else + \ifthenelse{\equal{\axo@partTwo}{\axo@currentInput}}% + {% Current definition is same as the one processed + % by axohelp, so it is safe to use + \expandafter\def\expandafter\axohelp\axo@partThree% + }% + {% + \rlap{Changed object; rerun axohelp}% + \global\axo@axohelpReruntrue + }% + \fi + \fi% +} +% +% #] getaxohelp : +% #[ Use the axohelp output : +% +% Implement conversion of length unit from pt to bp by scaling +\def\contentspdf{q \axoscale\space 0 0 \axoscale\space 0 0 cm + 0.99626401 0 0 0.99626401 0 0 cm + 1 0 0 1 \axoxo\space \axoyo\space cm + \axohelp\space + Q} +\def\contentspdfNoOffset{q \axoscale\space 0 0 \axoscale\space 0 0 cm + 0.99626401 0 0 0.99626401 0 0 cm + \axohelp\space + Q} +% +% #] Use the axohelp output : +% +\fi +% #] PDF specific : + +% Process options now, after all potentially necessary commands have +% been defined. Use starred form, so that the options are processed +% in the order the user writes them. Also set defaults here. +\PSTextScalesLikeGraphicstrue +\canvasScaleObjectScale +\ProcessOptions* diff --git a/Master/tlpkg/bin/tlpkg-ctan-check b/Master/tlpkg/bin/tlpkg-ctan-check index 025182365ff..4cc40e17c97 100755 --- a/Master/tlpkg/bin/tlpkg-ctan-check +++ b/Master/tlpkg/bin/tlpkg-ctan-check @@ -52,7 +52,7 @@ my @TLP_working = qw( aucklandthesis augie auncial-new aurical aurl autobreak autopdf authoraftertitle authorindex auto-pst-pdf autoaligne autoarea automata autonum autosp avantgar avremu - awesomebox + awesomebox axodraw2 b1encoding babel babel-albanian babel-azerbaijani babel-basque babel-belarusian babel-bosnian babel-breton diff --git a/Master/tlpkg/libexec/ctan2tds b/Master/tlpkg/libexec/ctan2tds index ebecd525be2..623d0bde4eb 100755 --- a/Master/tlpkg/libexec/ctan2tds +++ b/Master/tlpkg/libexec/ctan2tds @@ -135,7 +135,6 @@ chomp ($Build = `cd $Master/../Build/source && pwd`); 'auto1', "die 'skipping, nonfree font support'", 'autolatex', "die 'skipping, not self-locating'", 'autotab', "die 'skipping, noinfo license, latex 2.09'", - 'axodraw2', "die 'skipping, requires compilation'", 'babel-frenchb', "die 'skipping, use babel-french'", 'babel-serbianc', "&MAKEflatten", 'babel-slovene', "die 'skipping, use babel-slovenian'", @@ -2929,6 +2928,7 @@ $standardclean = '\.head|\.tmp|\.dvi|\.log|\.out|\.aux|\.toc|\.lof|\.lot' 'accfonts' => $standardclean . '|dvips.enc', # dup enc 'acmconf' => $standardclean . '|flushend.sty', # dup with sttools 'apalike' => "apalike2.bst", # does not belong + 'axodraw2' => "axohelp.exe", # later 'bardiag' => "example/.*(aux|log)", # junk on CTAN 'bibleref' => $standardclean . '|sample.tex|sample-.*', # derived uploaded 'bbm-macros' => $standardclean . '|^bbm$', # symlink diff --git a/Master/tlpkg/tlpsrc/axodraw2.tlpsrc b/Master/tlpkg/tlpsrc/axodraw2.tlpsrc new file mode 100644 index 00000000000..e69de29bb2d diff --git a/Master/tlpkg/tlpsrc/collection-mathscience.tlpsrc b/Master/tlpkg/tlpsrc/collection-mathscience.tlpsrc index 96574c234f1..8d4c7b30889 100644 --- a/Master/tlpkg/tlpsrc/collection-mathscience.tlpsrc +++ b/Master/tlpkg/tlpsrc/collection-mathscience.tlpsrc @@ -14,6 +14,7 @@ depend algorithms depend amstex depend apxproof depend autobreak +depend axodraw2 depend backnaur depend begriff depend binomexp -- cgit v1.2.3