diff options
Diffstat (limited to 'tex/.texmf/tex/generic/pgfplots/pgfplotscoordprocessing.code.tex')
| -rw-r--r-- | tex/.texmf/tex/generic/pgfplots/pgfplotscoordprocessing.code.tex | 9152 |
1 files changed, 9152 insertions, 0 deletions
diff --git a/tex/.texmf/tex/generic/pgfplots/pgfplotscoordprocessing.code.tex b/tex/.texmf/tex/generic/pgfplots/pgfplotscoordprocessing.code.tex new file mode 100644 index 0000000..d370f84 --- /dev/null +++ b/tex/.texmf/tex/generic/pgfplots/pgfplotscoordprocessing.code.tex @@ -0,0 +1,9152 @@ +%-------------------------------------------- +% +% Package pgfplots +% +% Provides a user-friendly interface to create function plots (normal +% plots, semi-logplots and double-logplots). +% +% It is based on Till Tantau's PGF package. +% +% Copyright 2007-2010 by Christian Feuersänger. +% +% This program 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. +% +% This program 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. +% +% You should have received a copy of the GNU General Public License +% along with this program. If not, see <http://www.gnu.org/licenses/>. +% +%-------------------------------------------- + +% This file contains the code to process coordinates +% - coordinate input: \addplot and its variants, +% - coordinate loops, +% - single coordinate processing +% +% -> see \pgfplots@addplot + + +% To be called inside of an axis as soon as the axis is ready and all +% point commands can be invoked. +\def\pgfplotspoint@initialisation{% + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@v00\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@v01\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@v10\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@v11\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@0v0\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@0v1\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@1v0\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@1v1\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@00v\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@01v\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@10v\endcsname\relax + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@11v\endcsname\relax + % + % Installs e_x, e_y and e_z such that (0,0) is the 'south west' + % anchor of the axis and (1,1) the 'north east'. + % It is used inside of descriptions. + \def\pgfplots@install@description@xyzvec{% + % this here is also used in color bars! + \ifpgfplots@deprecated@anchors + \pgfpointadd{\pgfplotspointxaxis}{\pgfplotspointyaxis}% + \else + \pgfplotspointbbdiagonal + \fi + \pgf@xa=\pgf@x + \pgf@ya=\pgf@y + % do not use \pgfqpoint here - it may have been replaced + % (compare \pgfplots@change@pgfpoints@to@descriptioncs) + \pgfsetxvec{\global\pgf@x=\pgf@xa \global\pgf@y=0pt }% + \pgfsetyvec{\global\pgf@x=0pt \global\pgf@y=\pgf@ya}% + \pgfsetzvec{\global\pgf@x=0pt \global\pgf@y=0pt }% + }% + % + % The \pgfplotsqpointxyz method (or its 2d counterpart) are THE + % point method. If you override them, all other coordinate systems + % should inherit the changes as well. + \edef\pgfplotsplothandlerpointxyz##1##2##3{% + \ifpgfplots@curplot@threedim + \noexpand\pgfplotsqpointxyz{##1}{##2}{##3}% + \else + \noexpand\pgfplotsqpointxy{##1}{##2}% + \fi + }% + % + % A point command such that (0,0) is the 'south west' and (1,1) + % the 'north east' point of an axis. + \def\pgfplotspointdescriptionxy##1##2{% + \pgf@process{% + \pgfplots@install@description@xyzvec + \pgfpointadd + {\ifpgfplots@deprecated@anchors + \pgfplotspointminminmin + \else + \pgfplotspointbblowerleft + \fi}% + {\pgfpointxy@orig{##1}{##2}}% + %I use the '@orig' variant here because descriptions may + %\let\pgfpointxy=\pgfplotspointdescriptionxy + }% + }% + % the 'q' variant: + \def\pgfplotsqpointdescriptionxy##1##2{% + \pgf@process{% + \pgfplots@install@description@xyzvec + \pgfpointadd + {\ifpgfplots@deprecated@anchors + \pgfplotspointminminmin + \else + \pgfplotspointbblowerleft + \fi}% + {\pgfqpointxy@orig{##1}{##2}}% + }% + }% + \pgfplotspoint@initialisation@axes + \pgfplotspoint@initialisation@units + \pgfplotspoint@initialisation@center + % + % declare the '[xyz]ticklabel cs' + \tikzdeclarecoordinatesystem{xticklabel}{\pgfplotspointticklabelcs{x}{##1}}% + \tikzdeclarecoordinatesystem{yticklabel}{\pgfplotspointticklabelcs{y}{##1}}% + \tikzdeclarecoordinatesystem{zticklabel}{\pgfplotspointticklabelcs{z}{##1}}% + \tikzdeclarecoordinatesystem{xticklabel*}{\pgfplotspointticklabelnoshiftcs{x}{##1}}% + \tikzdeclarecoordinatesystem{yticklabel*}{\pgfplotspointticklabelnoshiftcs{y}{##1}}% + \tikzdeclarecoordinatesystem{zticklabel*}{\pgfplotspointticklabelnoshiftcs{z}{##1}}% + % + % does also declare the 'near xticklabel*' variants. + \pgfplotsdeclareborderanchorforticklabelaxis{x}{near xticklabel}% + \pgfplotsdeclareborderanchorforticklabelaxis{y}{near yticklabel}% + \pgfplotsdeclareborderanchorforticklabelaxis{z}{near zticklabel}% + % + \pgfkeysdef{/tikz/sloped like x axis}{\tikz@addtransform{\pgfplotstransformtoaxisdirection[##1]{x}}}% + \pgfkeysdef{/tikz/sloped like y axis}{\tikz@addtransform{\pgfplotstransformtoaxisdirection[##1]{y}}}% + \pgfkeysdef{/tikz/sloped like z axis}{\tikz@addtransform{\pgfplotstransformtoaxisdirection[##1]{z}}}% + % +}% + +% Determine final axes this does also fix the axis' dimension. +% There are the following cases: +% 1. the user really wants a fixed dimension, +% i.e. he used 'scale only axis'. +% Then, we have to work to get the correct dimension! +% +% Up to now, the scaling mechanism looses to many significant +% digits such that the final width/height differs by 1-2 pt. +% +% If I am not mistaken, this does ONLY affect the final size, +% not the relative plot precision. +% +% FIXME : really compute the plot precision! +% +% 2. The use specified width and/or height, but not 'scale only +% axis'. Accept inaccurate final widths/heights (see above). +% +% 3. The user supplied 'x' and or 'y'. Simply use them, its +% accurate. +% POSTCONDITION: the macros +% \pgfplotspointminminmin +% \pgfplotspoint[xyz]axis +% \pgfplotspoint[xyz]axislength +% are defined (globally). +% +\def\pgfplotspoint@initialisation@axes{% + \begingroup + \ifpgfplots@threedim + \def\pgfplotspointmaxminmin{\pgfplotsqpointxyz{\pgfplots@xmax}{\pgfplots@ymin}{\pgfplots@zmin}}% + \def\pgfplotspointminmaxmin{\pgfplotsqpointxyz{\pgfplots@xmin}{\pgfplots@ymax}{\pgfplots@zmin}}% + \pgfplotsqpointxyz{\pgfplots@xmin}{\pgfplots@ymin}{\pgfplots@zmin}% + \else + \def\pgfplotspointmaxminmin{\pgfplotsqpointxy{\pgfplots@xmax}{\pgfplots@ymin}}% + \def\pgfplotspointminmaxmin{\pgfplotsqpointxy{\pgfplots@xmin}{\pgfplots@ymax}}% + \pgfplotsqpointxy{\pgfplots@xmin}{\pgfplots@ymin}% + \fi + \xdef\pgfplotspointminminmin{\noexpand\pgf@x=\the\pgf@x\space\noexpand\pgf@y=\the\pgf@y\space}% + % ATTENTION: I re-use registers here! Make sure they won't be + % overwritten! \pgfpointdiff and \pgfplotsqpointxy are ok in this respect. + \let\pgfplots@xcoordminTEX=\pgf@xb + \let\pgfplots@ycoordminTEX=\pgf@yb + \pgfplots@xcoordminTEX=\pgf@x + \pgfplots@ycoordminTEX=\pgf@y + % + %-------------------------------------------------- + % FIXME : WHAT IS THIS HERE FOR? + % \pgfplotsqpointxy{\pgfplots@xmax}{\pgfplots@ymax}% + % \ifx\pgfplots@rectangle@width\pgfutil@empty + % \def\pgfplots@tmp@xmax@ymin{\pgfplotsqpointxy{\pgfplots@xmax}{\pgfplots@ymin}}% + % \else + % % this 'if' here should only make a difference of about + % % 1-2pt, not more. + % % + % % and I am quite sure that this inaccuracy (and this + % % work-around) only affects the + % % final size, not the relative plot accuracy. + % \pgf@x=\pgfplots@xcoordminTEX + % \advance\pgf@x by\pgfplots@width + % \edef\pgfplots@tmp@xmax@ymin{\noexpand\pgfqpoint{\the\pgf@x}{\noexpand\pgfplots@ycoordminTEX}}% + % \fi + % \ifx\pgfplots@rectangle@height\pgfutil@empty + % \def\pgfplots@tmp@xmin@ymax{\pgfplotsqpointxy{\pgfplots@xmin}{\pgfplots@ymax}}% + % \else + % \pgf@x=\pgfplots@ycoordminTEX + % \advance\pgf@x\pgfplots@height + % \edef\pgfplots@tmp@xmin@ymax{\noexpand\pgfqpoint{\noexpand\pgfplots@xcoordminTEX}{\the\pgf@x}}% + % \fi + %-------------------------------------------------- + \pgfpointdiff + {\pgfqpoint{\pgfplots@xcoordminTEX}{\pgfplots@ycoordminTEX}} + {\pgfplotspointmaxminmin}% + \xdef\pgfplotspointxaxis{\noexpand\pgf@x=\the\pgf@x\space\noexpand\pgf@y=\the\pgf@y\space}% + \pgfmathveclen{\pgf@x}{\pgf@y}% + \xdef\pgfplotspointxaxislength{\pgfmathresult pt}% + % + \pgfpointdiff + {\pgfqpoint{\pgfplots@xcoordminTEX}{\pgfplots@ycoordminTEX}} + {\pgfplotspointminmaxmin}% + \xdef\pgfplotspointyaxis{\noexpand\pgf@x=\the\pgf@x\space\noexpand\pgf@y=\the\pgf@y\space}% + \pgfmathveclen{\pgf@x}{\pgf@y}% + \xdef\pgfplotspointyaxislength{\pgfmathresult pt}% + % + \ifpgfplots@threedim + \pgfpointdiff + {\pgfqpoint{\pgfplots@xcoordminTEX}{\pgfplots@ycoordminTEX}} + {\pgfplotsqpointxyz{\pgfplots@xmin}{\pgfplots@ymin}{\pgfplots@zmax}}% + \xdef\pgfplotspointzaxis{\noexpand\pgf@x=\the\pgf@x\space\noexpand\pgf@y=\the\pgf@y\space}% + \pgfmathveclen{\pgf@x}{\pgf@y}% + \xdef\pgfplotspointzaxislength{\pgfmathresult pt}% + \else + \global\let\pgfplotspointzaxis=\pgfpointorigin + \gdef\pgfplotspointzaxislength{0pt}% + \fi + \endgroup + % +} + +% PRECONDITION: called after \pgfplotspoint@initialisation@axes +% POSTCONDITION: +% \pgfplotspointcenter is defined. +\def\pgfplotspoint@initialisation@center{% + \begingroup + % + % + \ifpgfplots@threedim + % + \pgfpointscale + {0.5}% + {\pgfplotspointxaxis + \pgf@xa=\pgf@x + \pgf@xb=\pgf@y + \pgfplotspointyaxis% + \advance\pgf@xa by\pgf@x + \advance\pgf@xb by\pgf@y + \pgfplotspointzaxis% + \advance\pgf@xa by\pgf@x + \advance\pgf@xb by\pgf@y + \pgf@x=\pgf@xa + \pgf@y=\pgf@xb + }% + \xdef\pgfplotspointcenter{\noexpand\pgf@x=\the\pgf@x\space\noexpand\pgf@y=\the\pgf@y\space}% + \else + \pgfpointscale + {0.5}% + {\pgfpointadd + \pgfplotspointxaxis% + \pgfplotspointyaxis% + }% + \xdef\pgfplotspointcenter{\noexpand\pgf@x=\the\pgf@x\space\noexpand\pgf@y=\the\pgf@y\space}% + \fi + \endgroup +} + +% PRECONDITION: +% the unit vectors are set up +% +% POSTCONDITION: +% \pgfplotspointunit[xyz] +% \pgfplotspointunit[xyz]length +% \pgfplotspointunit[xyz]invlength +% are all set up. +\def\pgfplotspoint@initialisation@units{% + \edef\pgfplotspointunitx{\pgf@x=\the\pgf@xx\space\pgf@y=\the\pgf@xy\space}% + \edef\pgfplotspointunity{\pgf@x=\the\pgf@yx\space\pgf@y=\the\pgf@yy\space}% + \let\pgfplotsunitxlength=\pgfplots@x@veclength + \let\pgfplotsunitylength=\pgfplots@y@veclength + \let\pgfplotsunitxinvlength=\pgfplots@x@inverseveclength + \let\pgfplotsunityinvlength=\pgfplots@y@inverseveclength + \ifpgfplots@threedim + \edef\pgfplotspointunitz{\pgf@x=\the\pgf@zx\space\pgf@y=\the\pgf@zy\space}% + \let\pgfplotsunitzlength=\pgfplots@z@veclength + \let\pgfplotsunitzinvlength=\pgfplots@z@inverseveclength + \fi +}% + +% The idea here is the following: +% +% 1. A point coordinate (<x>,<y>) without units should use +% relative axis coordinate system. +% +% 2. Any other point coordinate should not be altered. +% +% Former versions installed a shift and changed e_x, e_y and +% e_z. However, that was misleading as it disabled point 2). +% So, my idea here is to replace \pgfpointxy and \pgfqpointxy +% such that they install the correct coordinate system before +% doing anything else. +\def\pgfplots@change@pgfpoints@to@descriptioncs{% + % + \let\pgfpointxy=\pgfplotspointdescriptionxy + \let\pgfqpointxy=\pgfplotsqpointdescriptionxy + % e_z is zero, so the xyz variants ignore z: + \def\pgfpointxyz##1##2##3{\pgfpointxy{##1}{##2}}% + \def\pgfqpointxyz##1##2##3{\pgfqpointxy{##1}{##2}}% + % +}% + +% \pgfplotspointticklabelcs{<axis>}{<coordinate>} +% or +% \pgfplotspointticklabelcs[<default shift>]{<axis>}{<coordinate>} +% +% Yields a point in the '<axis>ticklabel cs'. +% +% The 'xticklabel cs' is a coordinate system which expects either one +% or two coordinates. The first is the coordinate on the axis where +% x tick label will be placed (or would be placed). The first +% coordinate '0' means the lower aixs site and the value '1' the upper +% range. The second (optional) coordinate of 'xticklabel cs' is a +% shift in direction of the outer normal vector of the axis. The +% minimum shift is the largest' tick labels dimensions. If the second +% argument is omitted, the <default shift> will be used (0pt if this +% argument has been omitted as well). +% +% \pgfplotspointticklabelcs#1#2: +% #1 is the axis (either x,y or z) +% #2 is the coordinate (either <relative coord> or <relative coord>,<shift>) +% +% @see \pgfplotsvalueoflargesttickdimen +% +% This command actually boils down to a +% \pgfplotsqpointoutsideofticklabelaxisrel +% invocation which. Thus, you *can* get the *same* effect by using +% basic level commands -- and you are not restricted to the tick label +% axis. +% @see \pgfplotsqpointoutsideofaxisrel +\def\pgfplotspointticklabelcs{\pgfutil@ifnextchar[% + {\pgfplotspointticklabelcs@opt}% + {\pgfplotspointticklabelcs@opt[0pt]}% +}% +\def\pgfplotspointticklabelcs@opt[#1]#2#3{% + \pgfutil@in@{,}{#3}% + \ifpgfutil@in@ + \edef\pgfplots@loc@TMPa{#3}% + \else + \edef\pgfplots@loc@TMPa{#3,#1}% + \fi + \def\pgfplots@loc@TMPb##1,##2\relax{% + % invoke + % \pgfplotsqpointoutsideofticklabelaxisrel{#2}{##1}{ticklabel dimen + ##2}: + \begingroup + \pgfmathparse{##2}% + \pgf@xa=\pgfmathresult pt\relax + \advance\pgf@xa by\pgfplotsvalueoflargesttickdimen{#2} %<- keep this space! + \xdef\pgfplots@glob@TMPa{\pgf@sys@tonumber\pgf@xa}% + \endgroup + \def\pgfplots@loc@TMPa{\pgfplotsqpointoutsideofticklabelaxisrel{#2}{##1}}% + \expandafter\pgfplots@loc@TMPa\expandafter{\pgfplots@glob@TMPa}% + }% + \expandafter\pgfplots@loc@TMPb\pgfplots@loc@TMPa\relax +}% + +\def\pgfplotspointticklabelnoshiftcs#1#2{% + \pgfutil@in@{,}{#2}% + \ifpgfutil@in@ + \edef\pgfplots@loc@TMPa{#2}% + \else + \edef\pgfplots@loc@TMPa{#2,0}% + \fi + \def\pgfplots@loc@TMPb##1,##2\relax{% + % invoke + % \pgfplotsqpointoutsideofticklabelaxisrel{#2}{##1}{##2}: + \pgfmathparse{##2}% + \def\pgfplots@loc@TMPa{\pgfplotsqpointoutsideofticklabelaxisrel{#1}{##1}}% + \expandafter\pgfplots@loc@TMPa\expandafter{\pgfmathresult}% + }% + \expandafter\pgfplots@loc@TMPb\pgfplots@loc@TMPa\relax +}% + + +% Converts a dimen (with unit!) to a corresponding x, y or z +% coordinate. +% The result will be written to \pgfmathresult (without units). +% +% It is possible to use the result within the \pointxyz command(s). +% +% #1: the axis (x,y or z) +% #2: the dimen +% +% example: +% \pgfplotsconvertunittocoordinate{x}{5pt} +\def\pgfplotsconvertunittocoordinate#1#2{% + \begingroup + \pgf@xa=#2\relax + \pgf@xa=\csname pgfplots@#1@inverseveclength\endcsname\pgf@xa + \edef\pgfmathresult{\pgf@sys@tonumber\pgf@xa}% + \pgfmath@smuggleone\pgfmathresult + \endgroup +}% + +% This is the same as using \pgfplotsconvertunittocoordinate for each +% component #1, #2 and #3. The results are directly communicated to +% \pgfplotsqpointxyz. +% +% Expects #1, #2 and #3 to be numbers with units and issues a \pgfplotsqpointxyz +\def\pgfplotsqpointxyzabsolutesize#1#2#3{% + \begingroup + \pgf@xa=#1\relax + \pgf@xa=\pgfplots@x@inverseveclength\pgf@xa + \pgf@xb=#2\relax + \pgf@xb=\pgfplots@y@inverseveclength\pgf@xb + \pgf@ya=#3\relax + \pgf@ya=\pgfplots@z@inverseveclength\pgf@ya + \xdef\pgfplots@glob@TMPa{{\pgf@sys@tonumber\pgf@xa}{\pgf@sys@tonumber\pgf@xb}{\pgf@sys@tonumber\pgf@ya}}% + \endgroup + \expandafter\pgfplotsqpointxyz\pgfplots@glob@TMPa +}% + +% Denotes a point in a twodimensional hyperplane. The hyperplane is +% one of the six planes of the threedimensional axis cube. +% +% The meaning of coordinates #1 and #2 will be redefined depending on +% which surface we are currently processing. You can get the axis +% names for '#1' (a) and '#2' (b) using the macros +% \pgfplotspointonorientedsurfaceA (one of the characters x,y or z) +% and +% \pgfplotspointonorientedsurfaceB. +% The surface normal direction is +% \pgfplotspointonorientedsurfaceN. +% +% Example: +% \pgfplotspointonorientedsurfaceabsetupfor xyz +% \pgfplotspointonorientedsurfaceabsetupforsetz{<lower z limit>}{0} +% +% -> +% \pgfplotspointonorientedsurfaceA = x +% \pgfplotspointonorientedsurfaceB = y +% \pgfplotspointonorientedsurfaceN = z +% \pgfplotspointonorientedsurfacespec = {ab0} +% \pgfplotspointonorientedsurfacespecunordered = {vv0} +% \pgfplotspointonorientedsurfaceab{3}{4} =\pgfqpointxyz{3}{4}{<lower z limit>} +% +% \pgfplotspointonorientedsurfaceabsetupfor yxz +% \pgfplotspointonorientedsurfaceabsetupforsetz{<lower z limit>}{0} +% -> +% \pgfplotspointonorientedsurfaceA = y +% \pgfplotspointonorientedsurfaceB = x +% \pgfplotspointonorientedsurfaceN = z +% \pgfplotspointonorientedsurfacespec = {ba0} +% \pgfplotspointonorientedsurfacespecunordered = {vv0} +% \pgfplotspointonorientedsurfaceab{3}{4} =\pgfqpointxyz{4}{3}{<lower z limit>} +% +% @see \pgfplotspointonorientedsurfaceabsetupfor xyz +\def\pgfplotspointonorientedsurfaceab#1#2{% + \pgfplots@error{Internal logic error: \string\pgfplotspointonorientedsurfaceab\ used although surface has not been declared! You need to call \string\pgfplotspointonorientedsurfaceabsetupfor xyz\ or its friends to do so.}% +}% + +% This is a shortcut for +% \pgfpointadd +% {\pgfplotspointonorientedsurfaceab{#1}{#2}} +% {<shift in B direction of #3>} +% +% where #3 is a dimension (a number with unit). +\def\pgfplotspointonorientedsurfaceabwithbshift#1#2#3{% + \begingroup + \pgf@xa=#3\relax + \ifdim\pgf@xa=0pt + \else + \pgf@xa=\csname pgfplots@\pgfplotspointonorientedsurfaceB @inverseveclength\endcsname\pgf@xa + \fi + \advance\pgf@xa by#2pt + \edef\pgfplots@loc@b{\pgf@sys@tonumber\pgf@xa}% + \pgf@process{\pgfplotspointonorientedsurfaceab{#1}{\pgfplots@loc@b}}% + \endgroup +} + +\pgfkeyssetvalue{/pgfplots/oriented surf installed}{} + +% This macro will be defined after +% \pgfplotspointonorientedsurfaceabsetupfor... +% routines. It expands to a three-character string +% where the first character contains information about the x axis, +% the second about the y axis and the third about the z axis. +% +% The single characters can be one of +% - 'a' - the corresponding axis is the PRIMARY direction of the +% oriented surface. +% - 'b' - the corresponding axis is the SECONDARY direction of the +% oriented surface. +% - anything else - the characters provides as second argument for +% \pgfplotspointonorientedsurfaceabsetupforsetz{}{}, for example. +% Common choices are '0' for lower limit, '1' for upper limit and +% '2' for other. +\def\pgfplotspointonorientedsurfacespec{}% + +% Similar to \pgfplotspointonorientedsurfacespec, this macro encodes +% the currently active oriented surface. +% However, it only contains the characters 'v', '0' and '1' and '2'. +% The distinction 'v in {a,b}' is eliminated. +\def\pgfplotspointonorientedsurfacespecunordered{}% + +% As \pgfplotspointonorientedsurfacespec, this macro contains +% information about the current oriented surface: it contains the +% fixed symbol '0', '1' or '2' describing the only direction which is +% fixed. +\def\pgfplotspointonorientedsurfacespecsymbol{\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol} + +\def\pgfplotspointonorientedsurfaceabsetupfor#1#2#3{% + \pgfutil@ifundefined{pgfplotspointonorientedsurfaceabsetupfor@@#1#2#3}{% + \pgfplots@error{Sorry, \string\pgfplotspointonorientedsurfaceabsetupfor\space#1#2#3 is not yet implemented.}% + }{ + \csname pgfplotspointonorientedsurfaceabsetupfor@@#1#2#3\endcsname + }% +}% +% +% Initialises \pgfplotspointonorientedsurfaceab such that 'a' is the x +% axis and 'b' is the y axis and the z coordinate has been fixed with +% \pgfplotspointonorientedsurfaceabsetupforsetz{}. +% +% The Z value needs to be fixed with +% \pgfplotspointonorientedsurfaceabsetupforsetz . +\def\pgfplotspointonorientedsurfaceabsetupfor@@xyz{% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxyz{##1}{##2}{\pgfplotspointonorientedsurfaceabsetupfor@fixedz}}% + \def\pgfplotspointonorientedsurfaceA{x}% + \def\pgfplotspointonorientedsurfaceB{y}% + \def\pgfplotspointonorientedsurfaceN{z}% + \edef\pgfplotspointonorientedsurfacespec{ab\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \edef\pgfplotspointonorientedsurfacespecunordered{vv\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% +\def\pgfplotspointonorientedsurfaceabsetupfor@@yxz{% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxyz{##2}{##1}{\pgfplotspointonorientedsurfaceabsetupfor@fixedz}}% + \def\pgfplotspointonorientedsurfaceA{y}% + \def\pgfplotspointonorientedsurfaceB{x}% + \def\pgfplotspointonorientedsurfaceN{z}% + \edef\pgfplotspointonorientedsurfacespec{ba\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \edef\pgfplotspointonorientedsurfacespecunordered{vv\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% +\def\pgfplotspointonorientedsurfaceabsetupfor@@xzy{% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxyz{##1}{\pgfplotspointonorientedsurfaceabsetupfor@fixedy}{##2}}% + \def\pgfplotspointonorientedsurfaceA{x}% + \def\pgfplotspointonorientedsurfaceB{z}% + \def\pgfplotspointonorientedsurfaceN{y}% + \edef\pgfplotspointonorientedsurfacespec{a\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol b}% + \edef\pgfplotspointonorientedsurfacespecunordered{v\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol v}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% +\def\pgfplotspointonorientedsurfaceabsetupfor@@zxy{% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxyz{##2}{\pgfplotspointonorientedsurfaceabsetupfor@fixedy}{##1}}% + \def\pgfplotspointonorientedsurfaceA{z}% + \def\pgfplotspointonorientedsurfaceB{x}% + \def\pgfplotspointonorientedsurfaceN{y}% + \edef\pgfplotspointonorientedsurfacespec{b\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol a}% + \edef\pgfplotspointonorientedsurfacespecunordered{v\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol v}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% +\def\pgfplotspointonorientedsurfaceabsetupfor@@yzx{% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxyz{\pgfplotspointonorientedsurfaceabsetupfor@fixedx}{##1}{##2}}% + \def\pgfplotspointonorientedsurfaceA{y}% + \def\pgfplotspointonorientedsurfaceB{z}% + \def\pgfplotspointonorientedsurfaceN{x}% + \edef\pgfplotspointonorientedsurfacespec{\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol ab}% + \edef\pgfplotspointonorientedsurfacespecunordered{\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol vv}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% +\def\pgfplotspointonorientedsurfaceabsetupfor@@zyx{% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxyz{\pgfplotspointonorientedsurfaceabsetupfor@fixedx}{##2}{##1}}% + \def\pgfplotspointonorientedsurfaceA{z}% + \def\pgfplotspointonorientedsurfaceB{y}% + \def\pgfplotspointonorientedsurfaceN{x}% + \edef\pgfplotspointonorientedsurfacespec{\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol ba}% + \edef\pgfplotspointonorientedsurfacespecunordered{\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol vv}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% + +% Fixes 'x' to #1 for use in +% \pgfplotspointonorientedsurfaceabsetupfor zyx and +% \pgfplotspointonorientedsurfaceabsetupfor yzx. +% +% #1: The fixed value for 'x' (a coordinate in transformed range). +% #2: a one-character symbol describing 'x'. +% Command characters are +% 0 : x is the lower x-axis range. +% 1 : x is the upper x-axis range. +% 2 : other. +\def\pgfplotspointonorientedsurfaceabsetupforsetx#1#2{% + \edef\pgfplotspointonorientedsurfaceabsetupfor@fixedx{#1}% + \edef\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol{#2}% +}% +\def\pgfplotspointonorientedsurfaceabsetupforsety#1#2{% + \edef\pgfplotspointonorientedsurfaceabsetupfor@fixedy{#1}% + \edef\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol{#2}% +}% +\def\pgfplotspointonorientedsurfaceabsetupforsetz#1#2{% + \edef\pgfplotspointonorientedsurfaceabsetupfor@fixedz{#1}% + \edef\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol{#2}% +}% + +% Helper methods which should be used if no Z component exists (pure +% 2d plots). +\def\pgfplotspointonorientedsurfaceabsetupfor@@xy{% + \def\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol{0}% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxy{##1}{##2}}% + \def\pgfplotspointonorientedsurfaceA{x}% + \def\pgfplotspointonorientedsurfaceB{y}% + \def\pgfplotspointonorientedsurfaceN{z}% + \edef\pgfplotspointonorientedsurfacespec{ab\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \edef\pgfplotspointonorientedsurfacespecunordered{vv\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% +\def\pgfplotspointonorientedsurfaceabsetupfor@@yx{% + \def\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol{0}% + \def\pgfplotspointonorientedsurfaceab##1##2{\pgfplotsqpointxy{##2}{##1}}% + \def\pgfplotspointonorientedsurfaceA{y}% + \def\pgfplotspointonorientedsurfaceB{x}% + \def\pgfplotspointonorientedsurfaceN{z}% + \edef\pgfplotspointonorientedsurfacespec{ba\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \edef\pgfplotspointonorientedsurfacespecunordered{vv\pgfplotspointonorientedsurfaceabsetupfor@fixedsymbol}% + \pgfkeysvalueof{/pgfplots/oriented surf installed}% +}% + + +% Assuming we have an oriented surface installed, this command defines +% \pgfplotsretval to be the three-char-string such that the 'a' axis +% if the oriented surface takes value '#1', the 'b' axis of the +% oriented surface takes '#2' and the remaining axis has its fixed +% symbol anyway. +\def\pgfplotspointonorientedsurfaceabtolinespec#1#2{% + \expandafter\pgfplotspointonorientedsurfaceabtolinespec@a\pgfplotspointonorientedsurfacespec\relax#1% + \expandafter\pgfplotspointonorientedsurfaceabtolinespec@b\pgfplotsretval\relax#2% +}% +\def\pgfplotspointonorientedsurfaceabtolinespec@a#1a#2\relax#3{\edef\pgfplotsretval{#1#3#2}} +\def\pgfplotspointonorientedsurfaceabtolinespec@b#1b#2\relax#3{\edef\pgfplotsretval{#1#3#2}} + +% Assuming that an oriented surface has been initialised, say 'a0b', +% we have the following possible axis lines which can be drawn: +% - b=0: 'v00' +% - b=1: 'v01' +% - b=2: 'v02' +% +% To check which of them should be drawn, this macro here converts 'a' +% to 'v' and 'b' to '#1'. The remaining possible character will be +% copied as-is. +% +% The resulting three-character-string is written into '#2'. +% +% #1 : the replacement value which will be inserted instead of 'b' in +% the currently active oriented surface. +% #2 : the macro which will contain the output axis line specification +% (three-char-string). +% +% Example: +% \pgfplotspointonorientedsurfaceabsetupfor xyz +% \pgfplotspointonorientedsurfaceabsetupforsetz{<lower z limit>}{0} +% -> the oriented surface is 'ab0' +% ... +% \pgfplotspointonorientedsurfaceabgetcontainedaxisline{0}\pgfplotsretval +% -> \pgfplotsretval = 'v00' +% \pgfplotspointonorientedsurfaceabgetcontainedaxisline{1}\pgfplotsretval +% -> \pgfplotsretval = 'v10' +% \pgfplotspointonorientedsurfaceabgetcontainedaxisline{2}\pgfplotsretval +% -> \pgfplotsretval = 'v20' +\def\pgfplotspointonorientedsurfaceabgetcontainedaxisline#1#2{% + \expandafter\pgfplotspointonorientedsurfaceabgetcontainedaxisline@\pgfplotspointonorientedsurfacespec\relax{#1}% + \let#2=\pgfplots@loc@TMPa +}% +% writes into \pgfplots@loc@TMPa: +\def\pgfplotspointonorientedsurfaceabgetcontainedaxisline@#1#2#3\relax#4{% + \pgfplotspointonorientedsurfaceabgetcontainedaxisline@single{#1}{#4}\to\pgfplots@loc@TMPa + \pgfplotspointonorientedsurfaceabgetcontainedaxisline@single{#2}{#4}\to\pgfplots@loc@TMPb + \pgfplotspointonorientedsurfaceabgetcontainedaxisline@single{#3}{#4}\to\pgfplots@loc@TMPc + \edef\pgfplots@loc@TMPa{\pgfplots@loc@TMPa\pgfplots@loc@TMPb\pgfplots@loc@TMPc}% +}% +\def\pgfplotspointonorientedsurfaceabgetcontainedaxisline@single#1#2\to#3{% + \if#1a% + \def#3{v}% + \else + \if#1b% + \def#3{#2}% + \else + \def#3{#1}% + \fi + \fi +}% + + +% Finds the two surfaces which are adjacent to an axis line encoded as +% three-character-string. +% +% There are the following possibilities: +% #1 = 'v**' where '*' is not 'v'. +% -> #2 = 'vv*' and #3 = 'v*v' +% +% #1 = '*v*' +% -> #2 = 'vv*' and #3 = '*vv' +% +% #1 = '**v' +% -> #2 = 'v*v' and #3 = '*vv' +\def\pgfplotsgetadjacentsurfsforaxisline#1\to#2#3{% + \edef\pgfplots@loc@TMPa{#1}% + \expandafter\pgfplotsgetadjacentsurfsforaxisline@\pgfplots@loc@TMPa\relax{#2}{#3}% +}% +\def\pgfplotsgetadjacentsurfsforaxisline@#1#2#3\relax#4#5{% + \if#1v% + \def#4{vv#3}% + \def#5{v#2v}% + \else + \if#2v% + \def#4{vv#3}% + \def#5{#1vv}% + \else + \def#4{v#2v}% + \def#5{#1vv}% + \fi + \fi +}% + +% Executes code '#2' if the axis surface denoted by the +% three-character-string '#1' is a foreground surface and code '#3' if +% the surface '#1' is a background surface. +% +% #1: a three-char-string with the keys +% 'v' = 'varying', +% '0' = 'lower axis limit', +% '1' = 'upper axis limit'. +% The string 'v0v' means that x and z are varying in that surface +% and 'y' is fixed to the lower axis limit. +% #2: code to execute if '#1' is foreground. +% #3: code to execute if '#1' is background. +\def\pgfplotsifaxissurfaceisforeground#1#2#3{% + \pgfutil@ifundefined{pgfplots@surfviewdepth@#1}{% + \pgfplots@error{\string\pgfplotsifaxissurfaceisforeground{#1}: undefined three-character-string '#1' provided.}% + #3% + }{% + \if f\csname pgfplots@surfviewdepth@#1\endcsname #2\else #3\fi + }% +}% + +% As \pgfplotsifaxissurfaceisforeground, but for axis lines. +% +% #1: a three-character string with the same keys as in +% \pgfplotsifaxissurfaceisforeground. However, there should be only +% one varying direction as we are dealing with an axis line. +% #2: code to execute if '#1' is foreground. +% #3: code to execute if '#1' is background. +% +\def\pgfplotsifaxislineisforeground#1#2#3{% + \pgfplotsgetadjacentsurfsforaxisline#1\to\pgfplots@loc@TMPb\pgfplots@loc@TMPc + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPb}{% + #2% + }{% + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPc}{% + #2% + }{% + #3% + }% + }% +}% +% Executes code '#2' if the axis surface denoted by the +% three-char-string '#1' is on the convex hull of the projected axis +% cube or code '#3' if that is not the case. +% +% The arguments are the same as for \pgfplotsifaxislineisforeground: +% #1: a three-character string with the same keys as in +% \pgfplotsifaxissurfaceisforeground. However, there should be only +% one varying direction as we are dealing with an axis line. +% #2: code to execute if '#1' is foreground. +% #3: code to execute if '#1' is background. +\def\pgfplotsifaxislineisonconvexhull#1#2#3{% + \pgfplotsgetadjacentsurfsforaxisline#1\to\pgfplots@loc@TMPb\pgfplots@loc@TMPc + % '#1' is on the convex hull if ONE of the adjacent surfs is + % foreground and the other one is background. + \pgfplots@loc@tmpfalse + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPb}{% + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPc}{% + }{% + \pgfplots@loc@tmptrue + }% + }{% + }% + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPb}{% + }{% + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPc}{% + \pgfplots@loc@tmptrue + }{% + }% + }% + \ifpgfplots@loc@tmp #2\else #3\fi +}% + +% Executes code '#2' if the axis line with 'b=#1' on the current +% oriented surface shall be drawn. +% If that is not the case, the code '#3' will be executed. +% +% Example: +% Let's assume the current oriented surface is 'b0a'. +% Then, +% \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn{0}{draw it!}{\relax} +% will check whether the line '00v' shall be drawn while +% \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn{1}{draw it!}{\relax} +% will check whether the line '10v' shall be drawn. +% +% The check is based on +% 1. foreground/background flags +% 2. the current configuration of the axis lines key(s) +% +% @see \pgfplotspointonorientedsurfaceabgetcontainedaxisline +\def\pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn#1#2#3{% + \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn@{#1}{% + \edef\pgfplots@loc@TMPe{\csname pgfplots@\pgfplotspointonorientedsurfaceA axislinesnum\endcsname}% + \if0\pgfplots@loc@TMPe + % boxed axis lines + #2% + \else + \if2\pgfplots@loc@TMPe + % centered axis lines + #2% + \else + % either the 'left' or 'right' positioned cases. + % These have exactly one line which is the one where + % tick labels will be placed. And this, in turn, is + % already known, even for 3D. Check if we have it: + \pgfplotspointonorientedsurfaceabtolinespec v#1% + \edef\pgfplots@loc@TMPe{\csname pgfplots@\pgfplotspointonorientedsurfaceA ticklabelaxisspec\endcsname}% + \ifx\pgfplots@loc@TMPe\pgfplotsretval + #2% + \else + #3% + \fi + \fi + \fi + }{% + #3% + }% +}% +\def\pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn@allaxislinevariations#1#2#3{% + \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn@{#1}{% + #2% + }{% + #3% + }% +}% + +% A sub-part of \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn +% which is /only/ based on foreground/background flags. +% +% @ATTENTION : this command will be always true for the 2D case. (it +% will be overwritten, see \pgfplots@decide@which@figure@surfaces@are@drawn) +\def\pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn@#1#2#3{% + \pgfplotspointonorientedsurfaceabgetcontainedaxisline#1\pgfplots@loc@TMPc + \pgfplotsgetadjacentsurfsforaxisline\pgfplots@loc@TMPc\to\pgfplots@loc@TMPb\pgfplots@loc@TMPc + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPb}{% + \pgfplotsifaxissurfaceisforeground{\pgfplots@loc@TMPc}{% + #3% + }{% + #2% + }% + }{% + #2% + }% +}% + +% Similar to \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn, +% this thing here execute '#1' if grid lines on the currently +% initialised oriented surfaces shall be drawn and '#2' if not. +% +% This does only handle foreground/background issues; it has NOTHING +% to do with the actual checks if grid lines are active or not. +\def\pgfplots@ifgridlines@onorientedsurf@should@be@drawn#1#2{% + % grid lines shall be drawn + % if and only if BOTH adjacent axis lines shall be drawn: + \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn@allaxislinevariations{0}{% + % remark: this is ALWAYS true for 2D plots. + \pgfplots@ifaxisline@B@onorientedsurf@should@be@drawn@allaxislinevariations{1}{% + #1% + }{% + #2% + }% + }{% + #2% + }% +}% + +% Checks whether the line specified by a three-character-string '#1' +% is inside of the currently set-up oriented surface. +% +% The return value is encoded as integer into the macro #2 as +% described below. +% +% #1 : a three-character string uniquely identifing an axis line. +% Each of the three characters can be 'v', '0' or '1'. +% The value '0' denotes the lower axis range while '1' denotes +% the upper axis range. The character 'v' stands for 'varying' +% and indicates the direction in which the line varies. The first +% character contains the values for the 'x' axis, the second +% character for the 'y' axis and the third character for the 'z' +% axis. +% Example: +% 'v01' is the axis line with 'y=lower y limit' and 'z=upper z limit' +% '10v' is the axis line with 'x=upper x limit' and 'y=lower y limit' +% The 'v' character indicates the varying component. There may be +% only one 'v'. +% #2 : a macro name. It will be empty if the line is NOT on the +% current surface. If will be non-empty if it IS on the current +% surface. +% To be more precise, If the line IS on the current surface, '#2' will be set to +% the character in '#1' which belongs to the second oriented +% surface axis (which is called the 'b' axis). +% Thus, the following values for '#2' can be expected: +% - '' (empty) if the line is not on the surface, +% - 'v' if the line IS on the surface, and '#1' contains a 'v' +% in direction of the surface's 'b' axis. +% - '0' if the line IS on the surface and '#1' contains a '0' in +% direction of the surface's 'b' axis, +% - '1' if the line IS on the surface and '#1' contains a '1' in +% direction of the surface's 'b' axis. +% No other values are possible. +% +% Example: +% \pgfplotspointonorientedsurfaceabsetupforsetz{\zmax}{1} +% \pgfplotspointonorientedsurfaceabsetupfor yxz +% \pgfplotspointonorientedsurfaceabmatchaxisline{v01}{\result} +% -> \result will be 'v' because 'x=v' in '{v01} +% +% \pgfplotspointonorientedsurfaceabsetupforsety{\ymin}{0} +% \pgfplotspointonorientedsurfaceabsetupfor xzy +% \pgfplotspointonorientedsurfaceabmatchaxisline{v01}{\result} +% -> \result will be '1' because 'z=1' in '{v01} +% +% \pgfplotspointonorientedsurfaceabsetupforsety{\ymax}{1} +% \pgfplotspointonorientedsurfaceabsetupfor xzy +% \pgfplotspointonorientedsurfaceabmatchaxisline{v01}{\result} +% -> \result will be empty because 'y=0' in '{v01} +% +% \pgfplotspointonorientedsurfaceabsetupforsetx{\xmax}{1} +% \pgfplotspointonorientedsurfaceabsetupfor yzx +% \pgfplotspointonorientedsurfaceabmatchaxisline{10v}{\result} +% -> \result will be 'v' because 'z=v' in '{10v} +\def\pgfplotspointonorientedsurfaceabmatchaxisline#1#2{% + \pgfplotsmatchcubeparts{#1}{\pgfplotspointonorientedsurfacespec}{#2}% +}% + +% Checks whether the line or surface specified by a three-character-string '#1' +% is inside of the surface designated by the three-character-string '#2'. +% +% +% Arguments: +% #1 a cube-part (axis line or surface) encoded as three character +% string. Can be '0v1' or 'vv0' or so (see above). +% #2 a surface, also encoded as three character string. Maybe +% oriented. +% #3 The return value is encoded as char into the macro #3 as +% described in \pgfplotspointonorientedsurfaceabmatchaxisline: +% '#3' will be EMPTY if '#1' is NOT in '#2'. +% '#3' will be NON-EMPTY if '#1' IS in '#2'. +\def\pgfplotsmatchcubeparts#1#2#3{% + \edef\pgfplots@loc@TMPa{#1:#2}% + \expandafter\pgfplotspointonorientedsurfaceabmatchaxisline@\pgfplots@loc@TMPa\pgfplots@EOI + \let#3=\pgfplots@loc@TMPa +}% + +% IMPLEMENTATION: +% The return value is 'yes, #1#2#3 is on the oriented surface #4#5#6' +% if and only if for all three character pairs, the following single +% relations hold. +% Input char oriented surface char +% 'v' : is either a or b or v +% '0' : is either 0, a, b, v or 2 (i.e. NOT 1) FIXME : is the '2' correct here!? +% '1' : is either 1, a, b, v or 2 (i.e. NOT 0) +% '2' : is either 2, a, b, v (i.e. NOT 0 or 1) +% That's all. +% +% If the 'oriented surface char' is 'v', then we actually don't have +% an oriented surface but just a surface. +% So, 'a0b' is the same surface as 'v0v', but the first choice has +% designated orientations. +% +% @POST \pgfplots@loc@TMPa contains the return value macro. +% More precisely, \pgfplots@loc@TMPa will be EMPTY is #1#2#3 is NOT +% on #4#5#6 . It will contain the value on the surface if it IS on +% the surface +\def\pgfplotspointonorientedsurfaceabmatchaxisline@#1#2#3:#4#5#6\pgfplots@EOI{% + % Search for the 'b' character: + \if#4b% + \def\pgfplots@loc@TMPa{#1}% + \else + \if#5b% + \def\pgfplots@loc@TMPa{#2}% + \else + \if#6b% + \def\pgfplots@loc@TMPa{#3}% + \else + \def\pgfplots@loc@TMPa{v}% FALLBACK solution. + \fi + \fi + \fi + % Now, check whether we need to clear the return value (i.e. + % return false) + \pgfplotspointonorientedsurfaceabmatchaxisline@single{#1}{#4}% + \pgfplotspointonorientedsurfaceabmatchaxisline@single{#2}{#5}% + \pgfplotspointonorientedsurfaceabmatchaxisline@single{#3}{#6}% +%\message{\string\pgfplotspointonorientedsurfaceabmatchaxisline@#1#2#3:#4#5#6 = '\pgfplots@loc@TMPa'.^^J}% +} +\def\pgfplotspointonorientedsurfaceabmatchaxisline@single#1#2{% + \if#1v% + \if#2a% + \else + \if#2b% + \else + \if#2v% + \else + \let\pgfplots@loc@TMPa=\pgfutil@empty + \fi + \fi + \fi + \else + \if0#1% + \if1#2% + \let\pgfplots@loc@TMPa=\pgfutil@empty + \fi + \else + \if1#1% + \if0#2% + \let\pgfplots@loc@TMPa=\pgfutil@empty + \fi + \else + \if2#1% + \if0#2% + \let\pgfplots@loc@TMPa=\pgfutil@empty + \fi + \if1#2% + \let\pgfplots@loc@TMPa=\pgfutil@empty + \fi + \else + % return TRUE. + % I admit I am not sure at all if this works in all + % cases + \pgfplotspointonorientedsurfaceabmatchaxisline@warn{#1}% + \fi + \fi + \fi + \fi +}% +\def\pgfplotspointonorientedsurfaceabmatchaxisline@warn#1{% + \pgfplots@warning{The internal implementation is suspicious that something is wrong: \string\pgfplotspointonorientedsurfaceabmatchaxisline@warn: the character '#1' in a three-character axis line or surface description might not be fully supported...}% +}% + +% Provides a point on an arbitrary axis (identified by a +% three-character-string) which can take any value on that axis and +% which is shifted in the direction of the outer normal vector. +% +% #1: a three-character-string denoting the desired axis +% #2: the coordinate on that axis (the coordinate for the 'v' +% direction in '#1'). It needs to be given as it would be supplied to +% an \addplot or 'axis cs' coordinate; any logs or data +% transformations will be applied. +% #3: the distance (a dimension) describing how much we should move +% away from that axis. This points to the outside normal vector of the +% axis cube. +% +% @see \pgfplotsqpointoutsideofticklabelaxis +% +% If, in addition, the boolean \ifpgfslopedattime is true, the same +% transformations which would have been applied by +% \pgftransformlineattime will be applied, that means the 'sloped' +% feature of tikz is applied. FIXME : is that up-to-date!? +% +% @see \pgftransformlineattime -- it is quite similar. +\def\pgfplotsqpointoutsideofaxis#1#2#3{% + \begingroup + \def\pgfplotspointoutsideofaxis@plug@trafo##1##2{\csname pgfplotstransformcoordinate##1\endcsname{##2}}% + \let\pgfplotspointoutsideofaxis@plug@getlimit=\pgfplotspointoutsideofaxis@getlimit@ + \edef\pgfplots@loc@TMPa{#1}% + \expandafter\pgfplotspointoutsideofaxis@\pgfplots@loc@TMPa\relax{#2}{#3}% +}% + +% A variant of \pgfplotsqpointoutsideofaxis with relative values for +% #2. +% That means +% '#2 = 0' === lower axis limit +% and +% '#2 = 1' === upper axis limit. +\def\pgfplotsqpointoutsideofaxisrel#1#2#3{% + \begingroup + \def\pgfplotspointoutsideofaxis@plug@trafo##1##2{% + \begingroup + % compute ##1min + ##2 * (##1max - ##1min) : + % + \afterassignment\pgfplots@gobble@until@relax + \pgf@xa=##2pt\relax + \edef\pgfplots@loc@TMPa{\pgf@sys@tonumber\pgf@xa}% + % + \pgf@xa=\csname pgfplots@##1min\endcsname pt % + \pgf@xb=\csname pgfplots@##1max\endcsname pt % + \pgf@xc=\pgf@xb + \ifpgfplots@allow@reversal@of@rel@axis@cs + \if\pgfkeysvalueof{/pgfplots/##1 dir/value}r% + % reverse: exchange min and max. + \pgf@xb=\pgf@xa + \pgf@xa=\pgf@xc + \pgf@xc=\pgf@xb + \fi + \fi + \advance\pgf@xc by-\pgf@xa + \pgf@xc=\pgfplots@loc@TMPa\pgf@xc + \advance\pgf@xc by\pgf@xa + \edef\pgfmathresult{\pgf@sys@tonumber\pgf@xc}% + \pgfmath@smuggleone\pgfmathresult + \endgroup + }% + \let\pgfplotspointoutsideofaxis@plug@getlimit=\pgfplotspointoutsideofaxis@getlimit@ + \edef\pgfplots@loc@TMPa{#1}% + \expandafter\pgfplotspointoutsideofaxis@\pgfplots@loc@TMPa\relax{#2}{#3}% +}% + +% A variant of \pgfplotsqpointoutsideofaxis which accepts transformed +% values for '#2' (i.e. any data transformations and logs are already +% applied). +\def\pgfplotsqpointoutsideofaxistransformed#1#2#3{% + \begingroup + \def\pgfplotspointoutsideofaxis@plug@trafo##1##2{\def\pgfmathresult{##2}}% + \let\pgfplotspointoutsideofaxis@plug@getlimit=\pgfplotspointoutsideofaxis@getlimit@ + \edef\pgfplots@loc@TMPa{#1}% + \expandafter\pgfplotspointoutsideofaxis@\pgfplots@loc@TMPa\relax{#2}{#3}% +}% + +% Computes the unit outer normal vector of the axis identified by a +% three-character-string '#1'. +% +% This is the same normal vector which is used inside of +% \pgfplotsqpointoutsideofaxis and its variants. +% +% The output of this command will be cached and re-used during the +% lifetime of an axis. +% +% The returned normal vector has length 1 (computed with +% \pgfpointnormalised). +% +% NOTE: some specialized axis types support non-linear axes (for +% example, polar axes). In that case, the outer normal vector *varies* +% along the `v' direction (of the three-character-string `#1'). +% The value of `v' can be set using +% \pgfplotspointouternormalvectorofaxissetv{<axis three char string>}{<transformed coordinate>} +\def\pgfplotspointouternormalvectorofaxis#1{% + \pgfplotspointouternormalvectorofaxis@ifdependson@v{#1}{% + \expandafter\global\expandafter\let\csname pgfplotspointouternormalvectorofaxis@cache@#1\endcsname\relax + }{% + }% + \expandafter\ifx\csname pgfplotspointouternormalvectorofaxis@cache@#1\endcsname\relax + \begingroup + \edef\pgfplots@loc@TMPa{#1}% + \expandafter\pgfplotspointouternormalvectorofaxis@\pgfplots@loc@TMPa\relax% + % \endgroup in \pgfplotspointouternormalvectorofaxis@. + \expandafter\xdef\csname pgfplotspointouternormalvectorofaxis@cache@#1\endcsname{\global\pgf@x=\the\pgf@x\space\global\pgf@y=\the\pgf@y\space}% + \else + \csname pgfplotspointouternormalvectorofaxis@cache@#1\endcsname + \fi +}% + +% Fixes the "v" value for successive calls to +% \pgfplotspointouternormalvectorofaxis{#1}. +% +% #1 the three-character-string of an axis or the empty string. +% If #1 is empty, the actual configuration of oriented surfaces may be +% used to check which normal vector is intented. +% +% #2 the "v" value to store. It should be a transformed coordinate. +\def\pgfplotspointouternormalvectorofaxissetv#1#2{% + \edef\pgfplots@loc@TMPa{#1}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \expandafter\edef\csname pgfplotspointouternormalvectorofaxis@v@\pgfplotspointonorientedsurfaceA\endcsname{#2}% + \else + \expandafter\edef\csname pgfplotspointouternormalvectorofaxis@v@#1\endcsname{#2}% + \fi +}% + +% Defines \pgfplotsretval to contain the 'v' value for an outer normal +% vector (if there is one known). If there is no such value, +% \pgfplotsretval will be empty. +% #1 a three-character-string +\def\pgfplotspointouternormalvectorofaxisgetv#1{% + \edef\pgfplots@loc@TMPa{#1}% + \expandafter\pgfplotspointouternormalvectorofaxisgetv@\pgfplots@loc@TMPa\relax\relax\relax\relax +} +\def\pgfplotspointouternormalvectorofaxisgetv@#1#2#3\relax{% + \pgfutil@ifundefined{pgfplotspointouternormalvectorofaxis@v@#1#2#3}{% + % no value found so far. + \if#1v% + \def\pgfplotsretval{x}% + \else + \if#2v% + \def\pgfplotsretval{y}% + \else + \def\pgfplotsretval{z}% + \fi + \fi + \pgfutil@ifundefined{pgfplotspointouternormalvectorofaxis@v@\pgfplotsretval}{% + \let\pgfplotsretval\pgfutil@empty + }{% + \edef\pgfplotsretval{\csname pgfplotspointouternormalvectorofaxis@v@\pgfplotsretval\endcsname}% + }% + }{% + \edef\pgfplotsretval{\csname pgfplotspointouternormalvectorofaxis@v@#1#2#3\endcsname}% + }% +}% + +% invokes #2 if the outer normal for the axis #1 (identified by a +% three-character-string) depends on a coordinate on that axis and #3 +% otherwise. +% +% Overwrite in subclasses if necessary. +\def\pgfplotspointouternormalvectorofaxis@ifdependson@v#1#2#3{#3} + +\def\pgfplotspointouternormalvectorofaxis@#1#2#3\relax{% + \if v#1% + \def\pgfplots@loc@point@orthogonal@to@v##1##2{% + \pgfplotsqpointxyz{0}{##1}{##2}% + }% + \def\pgfplots@loc@char@for@baxis{#2}% + \def\pgfplots@loc@char@for@naxis{#3}% + \def\pgfplots@loc@vaxis{x}% + \def\pgfplots@loc@baxis{y}% + \def\pgfplots@loc@naxis{z}% + \else + \if v#2% + \def\pgfplots@loc@point@orthogonal@to@v##1##2{% + \pgfplotsqpointxyz{##1}{0}{##2}% + }% + \def\pgfplots@loc@char@for@baxis{#1}% + \def\pgfplots@loc@char@for@naxis{#3}% + \def\pgfplots@loc@vaxis{y}% + \def\pgfplots@loc@baxis{x}% + \def\pgfplots@loc@naxis{z}% + \else + \def\pgfplots@loc@point@orthogonal@to@v##1##2{% + \pgfplotsqpointxyz{##1}{##2}{0}% + }% + \def\pgfplots@loc@char@for@baxis{#1}% + \def\pgfplots@loc@char@for@naxis{#2}% + \def\pgfplots@loc@vaxis{z}% + \def\pgfplots@loc@baxis{x}% + \def\pgfplots@loc@naxis{y}% + \fi + \fi + % + \pgfplotspointouternormalvectorofaxis@get@otheraxis@sign{\pgfplots@loc@vaxis}{\pgfplots@loc@baxis}{\pgfplots@loc@char@for@baxis}% + \let\pgfplots@loc@baxissign=\pgfplotsretval + % + \pgfplotspointouternormalvectorofaxis@get@otheraxis@sign{\pgfplots@loc@vaxis}{\pgfplots@loc@naxis}{\pgfplots@loc@char@for@naxis}% + \let\pgfplots@loc@naxissign=\pgfplotsretval + % + % + % ok, compute vector scales: + \pgfplotsmath@ifzero{\csname pgfplots@\pgfplots@loc@baxis @veclength\endcsname}{% + \def\pgfplots@loc@baxissign{0}% + \def\pgfplots@loc@baxisscale{0}% + }{% + \edef\pgfplots@loc@baxisscale{\pgfplots@loc@baxissign\csname pgfplots@\pgfplots@loc@baxis @inverseveclength\endcsname}% + }% + \pgfplotsmath@ifzero{\csname pgfplots@\pgfplots@loc@naxis @veclength\endcsname}{% + \def\pgfplots@loc@naxissign{0}% + \def\pgfplots@loc@naxisscale{0}% + }{% + \edef\pgfplots@loc@naxisscale{\pgfplots@loc@naxissign\csname pgfplots@\pgfplots@loc@naxis @inverseveclength\endcsname}% + }% + % + % Ok, compute and normalize the vector: + \pgf@process{% + \pgfpointnormalised + {\pgfplots@loc@point@orthogonal@to@v{\pgfplots@loc@baxisscale}{\pgfplots@loc@naxisscale}}% + }% + \endgroup +}% + +% #1: the axis for which we want the "outer normal". +% #2: the "other axis" for which we seek the sign. +% #3: the entry in the three-char-identifier which corresponds to +% "other axis". +\def\pgfplotspointouternormalvectorofaxis@get@otheraxis@sign#1#2#3{% + \ifcase#3\relax% + % case 0: + % this means : the '##1' direction of the surface + % orthogonal to the 'v' vector is on the lower axis + % limit. Since I need a vector pointing to the OUTSIDE of + % the axis, I need sign = -1 + \def\pgfplotsretval{-}% + \or + % case 1: + % in this case, the OUTSIDE area requires a plus sign - the b + % axis already points to the inside. + \def\pgfplotsretval{+}% + \or + % case 2: we have the 'axis lines=centered' case. + % + % This case is complicated. The problem is that we do not know + % if we are at the top or bottom limit. + % + % BUT: we know what we would have done if this would be a + % normal boxed axis! + % + % The idea is to return the same normal vector as if this would be a boxed axis. + % To this end, we have to access the "ticklabel axis spec" + % which would have been used in this case. + % + % We computed it at startup. Might be a hack ... :-( + \edef\pgfplots@loc@TMPb{\csname pgfplots@#1ticklabelaxisspec@box\endcsname}% + % + % decode it: we have to replace '#3' by the value that it has + % in that boxed ticklabel axis spec! + \def\pgfplots@loc@TMPa##1##2##3{% + % search for the correct entry. + \if x#2\def\pgfplotsretval{##1}\fi + \if y#2\def\pgfplotsretval{##2}\fi + \if z#2\def\pgfplotsretval{##3}\fi + }% + \expandafter\pgfplots@loc@TMPa\pgfplots@loc@TMPb + % + \if 2\pgfplotsretval + \pgfplots@error{internal assertion failed.}% + \fi + % + % invoke it again! + \pgfplotspointouternormalvectorofaxis@get@otheraxis@sign{#1}{#2}{\pgfplotsretval}% + \fi +} + +% very-low-level internal routine. Never invoke it directly. +% @PRECONDITION: +% an \begingroup has been opened. +% @POSTCONDITION +% an \endgroup has been closed and \pgf@x and \pgf@y are assigned. +% +% This grouping stuff has the intention to keep the "plug" things +% local. +% +% #1#2#3 are the three characters for the line, delimited by \relax. +% #4: the argument supplied as coordinate on that axis. +% #5: the shift along the outer unit normal. +\def\pgfplotspointoutsideofaxis@#1#2#3\relax#4#5{% + \if v#1% + \pgfplotspointoutsideofaxis@plug@getlimit{y}{#2}\let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotspointonorientedsurfaceabsetupforsety{\pgfplots@loc@TMPa}{#2}% + % + \pgfplotspointonorientedsurfaceabsetupfor xzy% + \pgfplotspointoutsideofaxis@plug@trafo{x}{#4}\let\pgfplots@loc@A=\pgfmathresult + \ifpgfplots@threedim + \pgfplotspointoutsideofaxis@plug@getlimit{z}{#3}\let\pgfplots@loc@B=\pgfmathresult + \else + \def\pgfplots@loc@B{0}% + \fi + \else + \if v#2% + \ifpgfplots@threedim + \pgfplotspointoutsideofaxis@plug@getlimit{z}{#3}\let\pgfplots@loc@TMPa=\pgfmathresult + \else + \def\pgfplots@loc@TMPa{0}% + \fi + \pgfplotspointonorientedsurfaceabsetupforsetz{\pgfplots@loc@TMPa}{#3}% + % + \pgfplotspointonorientedsurfaceabsetupfor yxz% + \pgfplotspointoutsideofaxis@plug@trafo{y}{#4}\let\pgfplots@loc@A=\pgfmathresult + \pgfplotspointoutsideofaxis@plug@getlimit{x}{#1}\let\pgfplots@loc@B=\pgfmathresult + \else + \pgfplotspointoutsideofaxis@plug@getlimit{x}{#1}\let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotspointonorientedsurfaceabsetupforsetx{\pgfplots@loc@TMPa}{#1}% + % + \pgfplotspointonorientedsurfaceabsetupfor zyx% + \ifpgfplots@threedim + \pgfplotspointoutsideofaxis@plug@trafo{z}{#4}\let\pgfplots@loc@A=\pgfmathresult + \else + \def\pgfplots@loc@A{0}% + \fi + \pgfplotspointoutsideofaxis@plug@getlimit{y}{#2}\let\pgfplots@loc@B=\pgfmathresult + \fi + \fi + % + % read dimen argument #5: + \afterassignment\pgfplots@gobble@until@relax + \pgf@xa=#5pt\relax + \edef\pgfplots@loc@distalong@normal{\pgf@sys@tonumber\pgf@xa}% + % +%\message{pgfplotspointoutsideofaxis{#1#2#3}{#4}{#5}: A = \pgfplots@loc@A, B = \pgfplots@loc@B.^^J}% + % + \pgf@process{% + \pgfpointadd + {\pgfplotspointonorientedsurfaceab{\pgfplots@loc@A}{\pgfplots@loc@B}} + {% + \pgfplotspointouternormalvectorofaxissetv{#1#2#3}{\pgfplots@loc@A}% + \pgfqpointscale + {\pgfplots@loc@distalong@normal}% + {\pgfplotspointouternormalvectorofaxis{#1#2#3}}% + }% + }% + \endgroup +}% +%-------------------------------------------------- +% \def\pgfplotspointoutsideofaxis@#1#2#3\relax#4#5{% +% \if v#1% +% \def\pgfplots@loc@point@orthogonal@to@v{% +% \pgfplotspointoutsideofaxis@plug@trafo{x}{#4}\let\pgfplots@loc@TMPa=\pgfmathresult +% \pgfplotspointoutsideofaxis@plug@getlimit{y}{#2}\let\pgfplots@loc@TMPb=\pgfmathresult +% \ifpgfplots@threedim +% \pgfplotspointoutsideofaxis@plug@getlimit{z}{#3}\let\pgfplots@loc@TMPc=\pgfmathresult +% \else +% \def\pgfplots@loc@TMPc{0}% +% \fi +% \pgfplotsqpointxyz{\pgfplots@loc@TMPa}{\pgfplots@loc@TMPb}{\pgfplots@loc@TMPc}% +% }% +% \else +% \if v#2% +% \def\pgfplots@loc@point@orthogonal@to@v{% +% \pgfplotspointoutsideofaxis@plug@trafo{y}{#4}\let\pgfplots@loc@TMPa=\pgfmathresult +% \pgfplotspointoutsideofaxis@plug@getlimit{x}{#1}\let\pgfplots@loc@TMPb=\pgfmathresult +% \ifpgfplots@threedim +% \pgfplotspointoutsideofaxis@plug@getlimit{z}{#3}\let\pgfplots@loc@TMPc=\pgfmathresult +% \else +% \def\pgfplots@loc@TMPc{0}% +% \fi +% \pgfplotsqpointxyz{\pgfplots@loc@TMPb}{\pgfplots@loc@TMPa}{\pgfplots@loc@TMPc}% +% }% +% \else +% \def\pgfplots@loc@point@orthogonal@to@v{% +% \ifpgfplots@threedim +% \pgfplotspointoutsideofaxis@plug@trafo{z}{#4}\let\pgfplots@loc@TMPa=\pgfmathresult +% \else +% \def\pgfplots@loc@TMPa{0}% +% \fi +% \pgfplotspointoutsideofaxis@plug@getlimit{x}{#1}\let\pgfplots@loc@TMPb=\pgfmathresult +% \pgfplotspointoutsideofaxis@plug@getlimit{y}{#2}\let\pgfplots@loc@TMPc=\pgfmathresult +% \pgfplotsqpointxyz{\pgfplots@loc@TMPb}{\pgfplots@loc@TMPc}{\pgfplots@loc@TMPa}% +% }% +% \fi +% \fi +% % +% % read dimen argument #5: +% \afterassignment\pgfplots@gobble@until@relax +% \pgf@xa=#5pt\relax +% \edef\pgfplots@loc@distalong@normal{\pgf@sys@tonumber\pgf@xa}% +% % +% % +% \pgf@process{% +% \pgfpointadd +% {\pgfplots@loc@point@orthogonal@to@v} +% {% +% \pgfqpointscale +% {\pgfplots@loc@distalong@normal}% +% {\pgfplotspointouternormalvectorofaxis{#1#2#3}}% +% }% +% }% +% \endgroup +% }% +%-------------------------------------------------- + +% Helper method for \pgfplotsqpointoutsideofaxis and its variants. +% #1: an axis (x,y or z) +% #2: o(\pgfplots@loc@TMPa - \pgfplots@loc@TMPb) ne of '0', '1' or '2' where +% 0 == add lower #1 axis limit, +% 1 == add upper #1 axis limit, +% 2 == add nothing. +% #3: the value to add. +\def\pgfplotspointoutsideofaxis@getlimit@#1#2{% + \if#20% + \expandafter\let\expandafter\pgfmathresult\csname pgfplots@#1min\endcsname + \else + \if#21% + \expandafter\let\expandafter\pgfmathresult\csname pgfplots@#1max\endcsname + \else + \expandafter\let\expandafter\pgfmathresult\csname pgfplots@logical@ZERO@#1\endcsname + \fi + \fi +}% + +\newif\ifpgfplots@sloped +\pgfplots@slopedtrue % its only purpose is to *DEACTIVATE* the sloped transformation after it has been activated. +\newif\ifpgfplots@sloped@resets@nontranslations +\newif\ifpgfplots@sloped@allowupsidedown +\pgfkeys{ + /pgfplots/sloped/true/.code={\pgfplots@slopedtrue}, + /pgfplots/sloped/false/.code={\pgfplots@slopedfalse}, + /pgfplots/sloped/allow upside down/.is if=pgfplots@sloped@allowupsidedown, + /pgfplots/sloped/allow upside down/.default=true, + /pgfplots/sloped/execute for upside down/.initial=, + /pgfplots/sloped/reset nontranslations/.is if=pgfplots@sloped@resets@nontranslations, + /pgfplots/sloped/reset nontranslations/.default=true, +} +% Installs a rotation transformation matrix such that labels or +% whatever are aligned precisely in direction of one of the two/three +% coordinate directions. +% +% \pgfplotstransformtoaxisdirection[<options>]{<axis char>} +% +% <axis char>: the coordinate direction (one of x,y or z) +% +% The code is pretty much the same as \pgftransformlineattime, except +% that the computation is considerably simpler as axis directions are +% a well known quantity. +% +% This command uses \ifpgfplots@sloped@allowupsidedown (=false) and +% \ifpgfplots@sloped@resets@nontranslations (= true). The default +% setting is reinitialised before options are processed +\def\pgfplotstransformtoaxisdirection{% + \pgfutil@ifnextchar[{\pgfplotstransformtoaxisdirection@}{\pgfplotstransformtoaxisdirection@[]}% +}% +\def\pgfplotstransformtoaxisdirection@[#1]#2{% + \pgfplots@sloped@allowupsidedownfalse + \pgfplots@sloped@resets@nontranslationstrue + % + \def\pgfplots@loc@TMPa{#1}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \pgfqkeys{/pgfplots/sloped}{#1}% + \fi + \ifpgfplots@sloped + % + \ifpgfplots@sloped@resets@nontranslations + \pgftransformresetnontranslations + \fi + % + % compute unit length vector pointing into the direction of + % '#1#2#3': + \pgfqpointscale{\csname pgfplotsunit#2invlength\endcsname}{\csname pgfplotspointunit#2\endcsname}% + % + \ifdim\pgf@x<0pt% + % oh. upside down. + \pgfkeysvalueof{/pgfplots/sloped/execute for upside down}% + \ifpgfplots@sloped@allowupsidedown + \else + % do not allow upside down labels: + \global\pgf@x=-\pgf@x% + \global\pgf@y=-\pgf@y% + \fi + \fi% + % + \pgf@ya=-\pgf@y% + % set up rotation matrix + % [ cos(alpha) sin(alpha); + % -sin(alpha) cos(alpha) ] + % where cos(alpha) = n_x and sin(alpha) = n_y: + \pgftransformcm% + {\pgf@sys@tonumber{\pgf@x}}{\pgf@sys@tonumber{\pgf@y}}% + {\pgf@sys@tonumber{\pgf@ya}}{\pgf@sys@tonumber{\pgf@x}}{\pgfpointorigin}% + \fi +} + + +% Adds a further, temporary anchor to every node which will be +% processed. The anchor will be named '#3'. It is placed such that +% 1. the node's center is on a line in direction of the inwards normal +% vector of the axis line denoted by '#2' and the 'at' position of the node, +% 2. the node does not intrude the axis. +% +% #1: either x,y or z the direction which varies +% #2: a three-char-string uniquely identifying the axis line. +% The parameter '#1' is redundand: it is the same as the 'v' +% character in '#2'. +% #3: the newly defined achor name. +% +% @see \pgfplotsdeclareborderanchorforticklabelaxis +\def\pgfplotsdeclareborderanchorforaxis#1#2#3{% + % + % + \pgfdeclaregenericanchor{#3}{\pgfplots@borderanchor@for@axis{#1}{#2}{##1}}% + \pgfdeclaregenericanchor{#3 opposite}{\pgfplots@borderanchor@for@axis@{#1}{#2}{##1}{+1}}% + % + % This variant will ALWAYS be placed on the boundary of the node. + % It is deprecated, I am keeping it for some time.... + \pgfdeclaregenericanchor{#3*}{% + \csname pgf@anchor@##1@border\endcsname{% + \pgf@process{% + % + % I want to rotate the node FIRST, then + % I'd like to get the boundary anchor! + % + % My idea: apply the INVERSE transformation + % matrix, then compute the boundary anchor. + % + % As soon as pgf draws the node, the + % transformation matrix will be applied and + % everything is fine. + \pgfutil@ifundefined{pgfreferencednodename}{% + % use given transformation matrix. + }{% + \ifx\pgfreferencednodename\pgfutil@empty + % just use the given transformation matrix - we are + % typesetting an unlabeled node. + \else + \pgfsettransform{\csname pgf@sh@nt@\pgfreferencednodename\endcsname}% + \fi + }% + \pgftransforminvert + % + % This here is the anchor as such. + \pgfqpointscale{-1}{\pgfplotspointouternormalvectorofaxis{#2}}% + % + \pgf@pos@transform\pgf@x\pgf@y + }% + }% + }% +}% + +% this does the work for \pgfplotsdeclareborderanchorforaxis. +% +% It depends on \pgfplotspointunit[xyz] and +% \pgfplotspointouternormalvectorofaxis +% +% #1: either x,y or z the direction which varies +% #2: a three-char-string uniquely identifying the axis line. +% The parameter '#1' is redundand: it is the same as the 'v' +% character in '#2'. +% #3: the shape, provided as argument by the pgf routine invoking the +% anchor. +\def\pgfplots@borderanchor@for@axis#1#2#3{% + \pgfplots@borderanchor@for@axis@{#1}{#2}{#3}{-1}% +} +% same as \pgfplots@borderanchor@for@axis{#1}{#2}{3} except that #4 is +% the SIGN for the outer normal. +% +% #4: the sign for the outer normal. #4=-1 means "use inner normal" +% and +1 means "use outer normal" +\def\pgfplots@borderanchor@for@axis@#1#2#3#4{% + \begingroup + \pgfutil@ifundefined{pgfreferencednodename}{% + % use given transformation matrix. + }{% + \ifx\pgfreferencednodename\pgfutil@empty + % just use the given transformation matrix - we are + % typesetting an unlabeled node. + \else + \pgfsettransform{\csname pgf@sh@nt@\pgfreferencednodename\endcsname}% + \fi + }% + % I only need to apply the trafo matrix to direction vectors. Eliminate + % shifts. + \pgf@pt@x=0pt % + \pgf@pt@y=0pt % + % + % I'll apply the inverse transformation matrix to direction + % vectors. To ensure the relative position of these vectors + % and the anchors of the node, I have to invert the matrix: + \pgftransforminvert + % + % + % This here is the normal direction (points to the axis) + \pgfqpointscale{#4}{\pgfplotspointouternormalvectorofaxis{#2}}% + % + % we apply the inverse CM onto it here: + \pgf@pos@transform\pgf@x\pgf@y + \edef\pgfplots@tmp@normaldir{\global\pgf@x=\the\pgf@x\space\global\pgf@y=\the\pgf@y\space}% + % + \pgfplots@borderanchor@snap@to@nearest@anchor{}% takes \pgf@x and \pgf@y + \let\pgfplots@anchor=\pgfplotsretval + % + % Now, I'd like the 'center' of the node on one line with the + % 'at={}' coordinate at which it shall be placed! + % This can be done as follows: + % + % Compute two lines: + % 1. a line parallel to the #1 axis which goes + % through our recently identified anchor, + % { x = x_a + r_1 * (#1 axis direction) + % 2. a line from center in direction of the normal, + % { x = x_c + r_2 n, r in R } + % + % Calculate the intersection point and return it! This + % involves a lot of arithmetics :-( + % + % UPDATE: I realized that using the 'center' anchor might be too + % restrictive. See the 'near ticklabel align' key. + % + % Note that this is actually too much work for the 2d case - I + % guess it would be more efficient without it. But for 3d, it + % really rocks. + % + % compute (unit#1 - normal): + \pgfplots@tmp@normaldir + \pgf@xb=\pgf@x + \pgf@yb=\pgf@y + % + % and the axis direction (in fact, I use -axis dir. But that + % doesn't matter for the intersection of two lines). + % Scale unit vector to length 1 to improve conditioning: + \pgfqpointscale + {\csname pgfplotsunit#1invlength\endcsname} + {\csname pgfplotspointunit#1\endcsname}% + % FIXME : shouldn't the values be copied AFTER the CM!? + \pgf@xa=\pgf@x + \pgf@ya=\pgf@y + \pgf@pos@transform\pgf@xa\pgf@ya + % + \ifcase\pgfplots@borderanchor@align\relax + % near ticklabel align=inside: + % make sure that we are close to the beginning of the axis + % direction vector. + \pgfplots@borderanchor@snap@to@nearest@anchor{% + \if\pgfkeysvalueof{/pgfplots/#1 dir/value}n% + % simply take \pgf@x and \pgf@y as-is. + \else + \global\pgf@x=-\pgf@x + \global\pgf@y=-\pgf@y + \fi + }% + \or + % near ticklabel align=center: + \def\pgfplotsretval{center}% Ah. simple. + \or + % near ticklabel align=outside: + % make sure that we are far away from the beginning of the + % axis direction vector. + \pgfplots@borderanchor@snap@to@nearest@anchor{% + \if\pgfkeysvalueof{/pgfplots/#1 dir/value}n% + \global\pgf@x=-\pgf@x + \global\pgf@y=-\pgf@y + \else + % simply take \pgf@x and \pgf@y as-is. + \fi + }% + \fi + \let\pgfplots@anchor@inner=\pgfplotsretval + % + % + % verify that |n^T d | + \pgf@xc=\pgf@sys@tonumber\pgf@xa\pgf@xb + \advance\pgf@xc by\pgf@sys@tonumber\pgf@ya\pgf@yb + \ifdim\pgf@xc<0pt \pgf@xc=-\pgf@xc \fi + \ifdim\pgf@xc<0.8pt + % ok. 'n' and 'd' are not parallel. + % + \edef\pgfplots@LEQ{% + % solve linear system + % a11 a12 + % a21 a22 + {\pgf@sys@tonumber\pgf@xb}{\pgf@sys@tonumber\pgf@xa}% + {\pgf@sys@tonumber\pgf@yb}{\pgf@sys@tonumber\pgf@ya}% + }% + % + % This here controls the anchor! Changing it might be more + % useful than I thought in the first place... + \pgf@sh@reanchor{#3}{\pgfplots@anchor@inner}% + \edef\pgfplots@loc@center{\global\pgf@x=\the\pgf@x\space\global\pgf@y=\the\pgf@y\space}% + % + % apply inverse matrix to right-hand-side (and compute RHS): + \pgfpointdiff% {<start>}{<end>} -> computes <end> - <start> + {\pgfplots@loc@center}% + {\pgf@sh@reanchor{#3}{\pgfplots@anchor}}% + \edef\pgfplots@RHS{{\pgf@sys@tonumber\pgf@x}{\pgf@sys@tonumber\pgf@y}}% + % + \pgfutilsolvetwotwoleq{\pgfplots@LEQ}{\pgfplots@RHS}% + \def\pgfplots@extract##1##2{% + \def\pgfplots@r{##1}% + }% + \expandafter\pgfplots@extract\pgfmathresult + % GOT IT! + % + % compute x_c + r*n: + \pgfpointadd + {\pgfplots@loc@center}% + {\pgfqpointscale{\pgfplots@r}{\pgfplots@tmp@normaldir}}% + \else + \pgfplotswarning{ticklabel anchor undetermined}{#1}{\the\pgf@xb,\the\pgf@yb}{\the\pgf@xa,\the\pgf@ya}{\the\pgf@xc}\pgfeov + % Something went awry: normal and unit#1 are almost parallel!? + % just use the determined anchor. + \def\pgfplots@r{0}% + \pgf@sh@reanchor{#3}{\pgfplots@anchor}% + \fi +%\message{==========>>>>>>>>>> I got finally (\the\pgf@x,\the\pgf@y). <<<<<<<<<===================}% + \pgf@process{}% <- transport outside of group + \endgroup +}% + +% #1: a direction vector. +% +% assigns the resulting anchor to \pgfplotsretval +\def\pgfplots@borderanchor@snap@to@nearest@anchor#1{% + \begingroup + #1% + % Now: + % auto-determine the canonical (north, north east etc) anchor + % at which the node touches the axis (remember: the axis is to + % be found in direction of the normal vector). + % + % This is kind of a snap-to-nearest-existing-anchor feature. But + % it tends to move the node too far away. It is used as starting + % point; we will refine it in the next step. + % + % This is a heuristicial procedure. + % + % Note that it does not hurt if there are "multiple best matches" + % (for example because they lie on the same line). + % The code below will move the final anchor point. + % + \def\pgfplots@thresh{0.17pt }% 80 degrees + %\def\pgfplots@thresh{0.3pt }% + %\def\pgfplots@thresh{0.707pt }% 45 degrees + \ifdim\pgf@y>0pt + \ifdim\pgf@y>\pgfplots@thresh + % only north anchor + \def\pgfplots@ycomp{north}% + \else + \def\pgfplots@ycomp{}% + \fi + \else + \ifdim\pgf@y<-\pgfplots@thresh + \def\pgfplots@ycomp{south}% + % south anchor + \else + \def\pgfplots@ycomp{}% + \fi + \fi + \ifdim\pgf@x>0pt + \ifdim\pgf@x>\pgfplots@thresh + \def\pgfplots@xcomp{east}% + \else + \def\pgfplots@xcomp{}% + \fi + \else + \ifdim\pgf@x<-\pgfplots@thresh + \def\pgfplots@xcomp{west}% + \else + \def\pgfplots@xcomp{}% + \fi + \fi + \edef\pgfplotsretval{% + \pgfplots@ycomp + \ifx\pgfplots@ycomp\pgfutil@empty + \else + \ifx\pgfplots@xcomp\pgfutil@empty + \else + \space + \fi + \fi + \pgfplots@xcomp + }% + \pgfmath@smuggleone\pgfplotsretval + \endgroup +} + +\def\pgfplotspointviewdir{% + %\pgfplotsmathvectordatascaletrafoinverse{\pgfplots@view@dir@threedim}{default}% + \let\pgfplotsretval=\pgfplots@view@dir@threedim + \pgfplotspointfromcsvvector{\pgfplotsretval}{default}% +}% + +\def\message@pgfplots@units{% + \begingroup + \pgfmathparse{veclen(\pgf@zx,\pgf@zy)}\let\Z=\pgfmathresult + \ifdim\Z pt=0pt + \def\Z{1}% + \fi + \pgfmathparse{veclen(\pgf@xx,\pgf@xy)/\Z}\let\X=\pgfmathresult + \pgfmathparse{veclen(\pgf@yx,\pgf@yy)/\Z}\let\Y=\pgfmathresult + \expandafter\ifx\csname pgfplots@view@dir@threedim\endcsname\relax + \def\normal{view = (---),^^J}% + \else + \pgfplotsmathvectortostring{\pgfplots@view@dir@threedim}{default}% + \edef\normal{view = (\pgfplotsretval),^^J}% + \fi + \message{^^J + x = (\the\pgf@xx,\the\pgf@xy),^^J + y =(\the\pgf@yx,\the\pgf@yy),^^J + z = (\the\pgf@zx,\the\pgf@zy),^^J + \normal + unit vector ratio=[\X\space\Y\space 1],^^J}% + \endgroup +}% + + +% ================================================================================== +% +% COORDINATE MATH. +% +% ================================================================================== + +% Declares a new "subclass" to perform coordinate math. +% +% Coordinate math usually needs a more powerful number format than the pgf +% basic layer, or at least a powerful mapping into the pgf basic +% layer. Both cases are realized by the coordinate math class. +% +% Different coordinates can use different instances, and it is also +% possible to use yet a further instance for point meta (or whatever). +% +% Coordinate math is used to compute axis limits and to map the range +% into the pgf number format. +% +% It is *not* necessarily used for \pgfmathparse, since switching +% the number format of \pgfmathparse is quite involved (at the time of +% this writing). Instead, it is used for *single* operations (like +% max, min, multiply, add). +% +% #1: the name of the coord math class +% #2: methods to override the default. +% +% The available methods are documented and shown below in the +% \pgfqkeys listing. +% +% @see the predefined examples, also shown below. +\def\pgfplotsdeclarecoordmath#1#2{% + \edef\pgfplotsdeclarecoordmath@{@#1@}% + \pgfqkeys{/pgfplots/@declare coord math}{% + initialise=, + parse=\edef\pgfmathresult{##1}\expandafter\pgfmathparse\expandafter{\pgfmathresult}, + parsenumber=\pgfmathfloatparsenumber{##1}\pgfmathfloattofixed{##1},% + zero= \pgfplotscoordmath{\pgfplotscoordmathid}{parsenumber}{0}, + one= \pgfplotscoordmath{\pgfplotscoordmathid}{parsenumber}{1}, + -one= \pgfplotscoordmath{\pgfplotscoordmathid}{parsenumber}{-1}, + log e= \pgfmathlog@{##1},% + log to display log=\pgfmath@basic@multiply@{##1}{2.3025851},% * log(10) + log from display log=\pgfmath@basic@multiply@{##1}{0.434294},% / log(10) + log unsigned int={% + \edef\pgfmathresult{% + \ifcase##1 + \or0 + \or0.693147 + \or1.098612 + \or1.386294 + \or1.60943791 + \or1.7917594 + \or1.94591014 + \or2.07944154 + \or2.197224 + \fi + }% + }, + set log basis=\edef\pgfmathresult{{#1}{##1}}\expandafter\pgfplotscoordmath@log@set@basis\pgfmathresult, + exp e={% + % make sure the exponential can be represented, i.e. use + % 'float' in the default repr: + \pgfmathfloatparsenumber{##1}% + \pgfmathfloatexp@\pgfmathresult% + \pgfplotscoordmath{\pgfplotscoordmathid}{parsenumber}{\pgfmathresult}% + }, + tofixed= \edef\pgfmathresult{##1},% + tostring= \edef\pgfmathresult{##1},% + max= \pgfplotsmathmax{##1}{##2},% + min= \pgfplotsmathmin{##1}{##2},% + min limit= \def\pgfmathresult{-16300},% + max limit= \def\pgfmathresult{16300},% + if less than= {\pgfplotsmathlessthan{##1}{##2}\ifpgfmathfloatcomparison ##3\else ##4\fi}, + if is= {% + \if##20 + \ifdim##1pt=0pt ##2\else ##3\fi + \else + \if##2+\ifdim##1pt>0pt ##2\else ##3\fi + \else + \if##2-\ifdim##1pt<0pt ##2\else ##3\fi + \else + \def\pgfplots@loc@TMPd{##1}\ifx\pgfplots@loc@TMPd\pgfutil@empty ##2\else ##3\fi + \fi + \fi + \fi + },% + if is bounded=\edef\pgfplotsretval{##1}\ifx\pgfplotsretval\pgfutil@empty ##3\else ##2\fi, + suffix= #1,% + datascaletrafo set params=, + datascaletrafo get params= \def\pgfmathresult{{0}{0}}\def\pgfplotsretval{0}\def\pgfplotsretvalb{0}, + datascaletrafo= \edef\pgfmathresult{##1}, + datascaletrafo inverse= \edef\pgfmathresult{##1}, + datascaletrafo noshift inverse= \edef\pgfmathresult{##1}, + datascaletrafo inverse to fixed= \edef\pgfmathresult{##1}, + datascaletrafo noshift inverse to fixed= \edef\pgfmathresult{##1}, + datascaletrafo noshift= \edef\pgfmathresult{##1}, + datascaletrafo undo shift= \edef\pgfmathresult{##1}, + datascaletrafo redo shift= \edef\pgfmathresult{##1}, + #2% + }% + \expandafter\edef\csname pgfpmth\pgfplotsdeclarecoordmath@ op\endcsname##1##2{% + \noexpand\edef\noexpand\pgfplotscoordmath@{##2}% + \noexpand\expandafter\noexpand\expandafter\noexpand\csname pgfmath\csname pgfpmth@#1@suffix\endcsname ##1@\noexpand\endcsname\noexpand\pgfplotscoordmath@ + }% + % + % + % these log function depend on the first argument of + % \pgfplotscoordmath{}, which is available as + % \pgfplotscoordmathid. + \pgfplotsutilforeachcommasep{% + exp,% + log,% + log to display log,% + log from display log,% + log to log 10,% + log unsigned int}\as\pgfplots@loc@TMPa + {% + \expandafter\edef\csname pgfpmth\pgfplotsdeclarecoordmath@\pgfplots@loc@TMPa\endcsname{% + % invoke \pgfpmth@#1@@<name>@<function> + % for example + % \pgfpmth@pgfbasic@@y@log + \noexpand\csname pgfpmth\pgfplotsdeclarecoordmath@ @\noexpand\pgfplotscoordmathid @\pgfplots@loc@TMPa\noexpand\endcsname + }% + }% + % + \pgfutil@ifundefined{pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log}{% + \pgfutil@namelet + {pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log} + {pgfpmth\pgfplotsdeclarecoordmath@ log e}% + }{}% + \pgfutil@ifundefined{pgfpmth\pgfplotsdeclarecoordmath@ tmpl@exp}{% + \pgfutil@namelet + {pgfpmth\pgfplotsdeclarecoordmath@ tmpl@exp} + {pgfpmth\pgfplotsdeclarecoordmath@ exp e}% + }{}% + \pgfplotscoordmath@def@log@to@log@ten{#1}{}{tmpl}% empty arg + % +}% +\pgfqkeys{/pgfplots/@declare coord math}{% + initialise/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ initialise\endcsname{#1% + \pgfplotscoordmath@initialise@logs + }},% + % takes a number literal as input and defines \pgfmathresult to be + % the parsed result. + parsenumber/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ parsenumber\endcsname##1{#1}},% + % + zero/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ zero\endcsname{#1}},% + one/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ one\endcsname{#1}},% + -one/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ -one\endcsname{#1}},% + % + % Calls pgfmathparse. Note that this might need to switch to the + % required math library (which is not necessarily cheap) + parse/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ parse\endcsname##1{#1}},% + % + % takes a parsed number and returns a fixed point number: + tofixed/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tofixed\endcsname##1{#1}},% + % + % chooses a human readable string (which can be processed by parsenumber): + tostring/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tostring\endcsname##1{#1}},% + % + % defines a max routine which returns the max of *exactly* two numbers: + max/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ max\endcsname##1##2{#1}},% + % + % counterpart for max: + min/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ min\endcsname##1##2{#1}},% + % + % defines \pgfmathresult to be the largest supported number. + max limit/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ max limit\endcsname{#1}},% + % + % defines \pgfmathresult to be the smallest supported number. + min limit/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ min limit\endcsname{#1}},% + % + % computes ##1 < ##2 and invokes ##3 in the true case and ##4 in + % the false case. + if less than/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ if less than\endcsname##1##2##3##4{#1}},% + % checks if ##1 is 0, positive, negative or unbounded + % ##1: the number to check + % ##2: either 0 or + or - or u (u = unbounded) + % ##3: true code + % ##4: false code + if is/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ if is\endcsname##1##2##3##4{#1}},% + % + % Checks if the argument ##1 is bounded and invokes ##2 in that + % case. IF the argument is unbounded, it invokes #3. + if is bounded/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ if is bounded\endcsname##1##2##3{#1}},% + % + % applies the natural logarithm. If the log is not defined, the + % argument is "unbounded", see 'if is bounded' + % + % 'log' is special in that it accepts a number literal which may + % be OUTSIDE of the accepted number format. The result, however, is + % then in the accepted number format. + log e/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ log e\endcsname##1{#1}},% + % + % Similar, but the log basis can be set with 'set log basis'. + % This allows \pgfplotscoordmath{x}{log}{} to use a different log + % basis thatn \pgfplotscoordmath{y}{log}{} (with special handling) + log/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log\endcsname##1{#1}},% + % applies a *scale* from the actual log basis to the actual + % *display* log basis. The display log basis is usually 10, unless + % the log basis has been changed. + log to display log/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log to display log\endcsname##1{#1}},% + % applies a *scale* from the displau log basis to the actual + % log basis (the inverse of `log to display log'). + log from display log/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log from display log\endcsname##1{#1}},% + log to log 10/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log to log 10\endcsname##1{#1}},% + % returns log(i) where i \in {1,2,3,...,basis-1} + % currently, it is only invoked for log basis 10 + log unsigned int/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log unsigned int\endcsname##1{#1}},% + % sets (changes) the actual log basis. + set log basis/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ set log basis\endcsname##1{#1}},% + % + % The inverse to 'log e '. + exp e/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ exp e\endcsname##1{#1}},% + % + % The inverse to 'log'. It also uses the correct log basis. + exp/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ tmpl@exp\endcsname##1{#1}},% + % + % A macro taking two parameters: + % #1: the EXPONENT (as integer) + % #2: the SHIFT (as fixed point number) + % + % After any change, \pgfplotscoordmathnotifydatascalesetfor{<id>} will be + % invoked where <id> is the argument to + % \pgfplotscoordmath{<id>}... + datascaletrafo set params/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo set params\endcsname##1##2{% + #1\relax\pgfplotscoordmathnotifydatascalesetfor{\pgfplotscoordmathid}% + }},% + datascaletrafo set shift/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo set shift\endcsname##1{% + #1\relax\pgfplotscoordmathnotifydatascalesetfor{\pgfplotscoordmathid}% + }},% + % + % Defines \pgfmathresult to contain the two parameters in the form + % {#1}{#2} required for 'datascaletrafo set params': + % #1: the EXPONENT (as integer) + % #2: the SHIFT (as fixed point number) + % AND \pgfplotsretval as the EXPONENT and \pgfplotsretvalb as the SHIFT + datascaletrafo get params/.code={% + \expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo get params\endcsname{#1}% + },% + datascaletrafo/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo\endcsname##1{#1}},% + datascaletrafo inverse/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo inverse\endcsname##1{#1}},% + datascaletrafo noshift inverse/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo noshift inverse\endcsname##1{#1}},% + datascaletrafo inverse to fixed/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo inverse to fixed\endcsname##1{#1}},% + datascaletrafo noshift inverse to fixed/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo noshift inverse to fixed\endcsname##1{#1}},% + datascaletrafo noshift/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo noshift\endcsname##1{#1}},% + datascaletrafo noshift/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo noshift\endcsname##1{#1}},% + datascaletrafo undo shift/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo undo shift\endcsname##1{#1}},% + datascaletrafo redo shift/.code= + {\expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ datascaletrafo redo shift\endcsname##1{#1}},% + % + % defines a suffix such that + % \csname pgfmath<suffix><op>@\endcsname + % exists. Example: <suffix>=float --> \pgfmathfloatmultiply@ for <op>=multiply + suffix/.code= + {\expandafter\edef\csname pgfpmth\pgfplotsdeclarecoordmath@ suffix\endcsname{#1}},% +}% + +\def\pgfplotscoordmath@initialise@logs{% + \edef\pgfplotsdeclarecoordmath@{@\pgfplotscoordmathclassfor{\pgfplotscoordmathid}@}% + \pgfutil@ifundefined{pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @log}{% + \pgfplotsutilforeachcommasep{% + exp,% + log,% + log to display log,% + log from display log,% + log to log 10,% + log unsigned int}\as\pgfplots@loc@TMPa + {% + \pgfutil@namelet + {pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @\pgfplots@loc@TMPa} + {pgfpmth\pgfplotsdeclarecoordmath@ tmpl@\pgfplots@loc@TMPa}% + }% + }{}% +}% + +% shared implementation for 'set log basis' It works for every +% subclass. +\def\pgfplotscoordmath@log@set@basis#1#2{% + \edef\pgfplotsdeclarecoordmath@{@#1@}% + % + \pgfplotscoordmath{\pgfplotscoordmathid}{log e}{#2}% + \let\pgfplots@loc@TMPa=\pgfmathresult% TMPa = log_e(#2) + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{reciprocal}{{\pgfmathresult}}% + \let\pgfplots@loc@TMPb=\pgfmathresult% TMPb = 1/log_e(#2) + % + % log_a(x) = log_e(x) / log_e(a) + \expandafter\edef\csname pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @log\endcsname##1{% + \noexpand\pgfplotscoordmath{\pgfplotscoordmathid}{log e}{##1}% + \noexpand\ifx\noexpand\pgfmathresult\noexpand\pgfutil@empty + \noexpand\else + \noexpand\pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{% + {\noexpand\pgfmathresult}% + {\pgfplots@loc@TMPb}% + }% + \noexpand\fi + }% + % + % a^x = exp(log_e(a^x)) = exp(x*log_e(a)) + \expandafter\edef\csname pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @exp\endcsname##1{% + \noexpand\edef\noexpand\pgfmathresult{##1}% + \noexpand\ifx\noexpand\pgfmathresult\noexpand\pgfutil@empty + \noexpand\else + \noexpand\pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{% + {\noexpand\pgfmathresult}% + {\pgfplots@loc@TMPa}% + }% + \noexpand\pgfplotscoordmath{\pgfplotscoordmathid}{exp e}{\noexpand\pgfmathresult}% + \noexpand\fi + }% + \expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @log to display log\endcsname##1{\edef\pgfmathresult{##1}}% + \expandafter\def\csname pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @log from display log\endcsname##1{\edef\pgfmathresult{##1}}% + % + % compute 'log unsigned int' for the new basis. + % + % Idea: re-scale the old implementation (of basis e for i = 1,...,9) + % and re-compute i>=10 : + \begingroup + \expandafter\let\expandafter\logi\csname pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log unsigned int\endcsname + \let\logscale=\pgfplots@loc@TMPb + % + \logi{1}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@1\endcsname=\pgfmathresult + % + \logi{2}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@2\endcsname=\pgfmathresult + % + \logi{3}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@3\endcsname=\pgfmathresult + % + \logi{4}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@4\endcsname=\pgfmathresult + % + \logi{5}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@5\endcsname=\pgfmathresult + % + \logi{6}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@6\endcsname=\pgfmathresult + % + \logi{7}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@7\endcsname=\pgfmathresult + % + \logi{8}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@8\endcsname=\pgfmathresult + % + \logi{9}% + \pgfplotscoordmath{\pgfplotscoordmathid}{op}{multiply}{{\pgfmathresult}{\logscale}}% + \expandafter\let\csname logi@@9\endcsname=\pgfmathresult + % + \xdef\pgfplots@glob@TMPa##1{% + \noexpand\ifcase##1 + \noexpand\def\noexpand\pgfmathresult{}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@1\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@2\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@3\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@4\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@5\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@6\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@7\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@8\endcsname}% + \noexpand\or\noexpand\def\noexpand\pgfmathresult{\csname logi@@9\endcsname}% + \noexpand\else + \noexpand\pgfplotscoordmath{\pgfplotscoordmathid}{log}{##1}% + \noexpand\fi + }% + \endgroup + \expandafter\let\csname pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @log unsigned int\endcsname=\pgfplots@glob@TMPa + \pgfplotscoordmath@def@log@to@log@ten{#1}\pgfplots@loc@TMPa{\pgfplotscoordmathid}% + % + \pgfutil@namelet + {pgfpmth\pgfplotsdeclarecoordmath@ @\pgfplotscoordmathid @log to log 10} + {pgfpmth\pgfplotsdeclarecoordmath@ tmpl@log to log 10}% +}% +% #1: the coord math class +% #2: either empty (basis e) or 1/ln(basis) +% #3: either 'tmpl' or '\pgfplotscoordmathid. It defines the target +% macro name (see the source code) +\def\pgfplotscoordmath@def@log@to@log@ten#1#2#3{% + \csname pgfpmth@#1@parsenumber\endcsname{0.434294}% + \edef\pgfplots@loc@TMPa{#2}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + % log basis e ---> log basis 10 + % log_10 x = log x / log(10) + \else + % log basis a ---> log basis 10 + % + % log_a x = log x / log a + % log_10 x = log_a x * log a / log(10) = log x / log(10) [OK] + \csname pgfpmth@#1@op\endcsname{multiply}{{#2}{\pgfmathresult}}% + \fi + \expandafter\edef\csname pgfpmth@#1@#3@log to log 10\endcsname##1{% + \noexpand\pgfplotscoordmath{\noexpand\pgfplotscoordmathid}{op}{multiply}{{##1}{\pgfmathresult}}% + }% +}% + +% Assumes that #2 is a macro, parses it as number with "coord math choice" #1, and overwrites it with the result. +\def\pgfplotscoordmathparsemacro#1#2{% + \pgfplotscoordmath{#1}{parsenumber}{#2}\let#2=\pgfmathresult +}% + + +\pgfplotsdeclarecoordmath{pgfbasic}{% + parsenumber={% + \pgfmathfloatparsenumber{#1}% + \expandafter\pgfmathfloatgetflagstomacro\expandafter{\pgfmathresult}\pgfplotsretval + \ifnum\pgfplotsretval>2 + \let\pgfmathresult=\pgfutil@empty + \else + \pgfmathfloattofixed\pgfmathresult + \fi + }, + suffix=@basic@, + zero=\def\pgfmathresult{0}, + one=\def\pgfmathresult{1}, + -one=\def\pgfmathresult{-1}, +} +\pgfplotsdeclarecoordmath{float}{% + initialise= + \pgfutil@ifundefined{pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid}{% + \expandafter\edef\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname{0}% + \expandafter\edef\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname{0}% + }{}, + parsenumber=\pgfmathfloatparsenumber{#1}, + parse={% + \begingroup + \pgfkeys{/pgf/fpu}% + \edef\pgfmathresult{#1}% + \expandafter\pgfmathparse\expandafter{\pgfmathresult}% + \pgfmath@smuggleone\pgfmathresult + \endgroup + }, + zero=\pgfmathfloatcreate{0}{0.0}{0},% + one=\pgfmathfloatcreate{1}{1.0}{0},% + -one=\pgfmathfloatcreate{2}{1.0}{0},% + tofixed=\pgfmathfloattofixed{#1}, + tostring=\pgfmathfloattosci{#1}, + max=\pgfplotsmathfloatmax{#1}{#2},% + min=\pgfplotsmathfloatmin{#1}{#2},% + max limit=\pgfmathfloatcreate{1}{1.0}{2147483645},% + min limit=\pgfmathfloatcreate{2}{1.0}{2147483645},% + log e=\pgfmathfloatparsenumber{#1}\pgfmathfloatln@{\pgfmathresult},% + if less than=\pgfmathfloatlessthan@{#1}{#2}\ifpgfmathfloatcomparison #3\else #4\fi, + if is bounded=% + \expandafter\pgfmathfloatgetflagstomacro\expandafter{#1}\pgfplotsretval + \ifnum\pgfplotsretval>2 #3\else #2\fi, + if is=% + \pgfmathfloatifflags{#1}{#2}{#3}{#4}, + log=\pgfmathlog@float{#1},% + datascaletrafo set params={% + \expandafter\edef\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname{#1}% + \expandafter\edef\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname{#2}% + },% + datascaletrafo set shift={% + \expandafter\edef\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname{#1}% + },% + datascaletrafo get params={% + \edef\pgfplotsretval{\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname}% + \edef\pgfplotsretvalb{\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname}% + \edef\pgfmathresult{% + {\pgfplotsretval}% + {\pgfplotsretvalb}% + }% + },% + datascaletrafo={% + \edef\pgfmathresult{#1}% + \pgfmathfloatshift@\pgfmathresult{\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname}% + \pgfmathfloattofixed\pgfmathresult + \expandafter\pgfmath@basic@subtract@\expandafter{\pgfmathresult}{\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname}% + },% + datascaletrafo noshift={% + \edef\pgfmathresult{#1}% + \pgfmathfloatshift@\pgfmathresult{\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname}% + \pgfmathfloattofixed{\pgfmathresult}% + },% + datascaletrafo undo shift= + \pgfmath@basic@subtract@{#1}{\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname},% + datascaletrafo redo shift=\pgfmath@basic@add@{#1}{\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname},% + datascaletrafo inverse={% + \pgfplotscoordmath@float@datascaletrafo@inverse{#1}% + },% + datascaletrafo inverse to fixed={% + \pgfplotscoordmath@float@datascaletrafo@inverse{#1}% + \pgfmathfloattofixed\pgfmathresult + },% + datascaletrafo noshift inverse={% + \pgfmathfloatparsenumber{#1}% + \pgfmathfloatshift@{\pgfmathresult}{-\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname}% + },% + datascaletrafo noshift inverse to fixed={% + \pgfmathfloatparsenumber{#1}% + \pgfmathfloatshift@{\pgfmathresult}{-\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname}% + \pgfmathfloattofixed\pgfmathresult + },% +} + +\def\pgfplotscoordmath@float@datascaletrafo@inverse#1{% + \pgfmath@basic@add@{#1}{\csname pgfplots@data@scale@trafo@SHIFT@\pgfplotscoordmathid\endcsname}% + \let\pgfplots@inverse@datascaletrafo@@shifted=\pgfmathresult + \pgfmathapproxequalto@{\pgfplots@inverse@datascaletrafo@@shifted}{0.0}% + \ifpgfmathcomparison + \pgfmathfloatcreate{0}{0.0}{0}% + \else + \pgfmathfloatparsenumber{\pgfplots@inverse@datascaletrafo@@shifted}% + \pgfmathfloatshift@{\pgfmathresult}{-\csname pgfplots@data@scale@trafo@EXPONENT@\pgfplotscoordmathid\endcsname}% + \fi +}% + +% Invokes a coordinate math routine. +% +% #1: the axis (x,y or z) +% #2: a method name declared by \pgfplotsdeclarecoordmath (one of +% 'op', 'parsenumber', 'tofixed' etc) +% #3-#9: any further arguments required to perform the call to '#2'. +% +% \pgfplotscoordmath {x}{op}{multiply}{{<a>}{<b>}} +% \pgfplotscoordmath {x}{parsenumber}{<a>} +\def\pgfplotscoordmath#1#2{% + \edef\pgfplotscoordmathid{#1}% + \csname pgfpmth@\csname pgfcrdmth@#1\endcsname @#2\endcsname}% + +\def\pgfplotscoordmathclassfor#1{\csname pgfcrdmth@#1\endcsname}% + +\def\pgfplotscoordmathnotifydatascalesetfor#1{}% + +% Enables a particular coordinate math class for the label `#1'. +% +% #1 a label (usually x,y or z) +% #2 the coordinate math class (one prepare by +% \pgfplotsdeclarecoordmath) +% +% From this point on, any call to \pgfplotscoordmath{#1}{...} +% will use the selected math class. +\def\pgfplotssetcoordmathfor#1#2{% + \pgfutil@ifundefined{pgfpmth@#2@initialise}{% + \pgfplotsthrow{invalid argument}{\pgfplots@loc@TMPa}{Sorry, \string\pgfplotssetcoordmathfor{#1}{#2} failed since `#2' is unknown. Maybe you misspelled it?}\pgfeov% + }{% + \expandafter\edef\csname pgfcrdmth@#1\endcsname{#2}% + \pgfplotscoordmath{#1}{initialise}% + }% +}% + +% Defines \pgfplotsretval to be the coordmath id for #1 +\def\pgfplotsgetcoordmathfor#1{% + \pgfutil@ifundefined{pgfcrdmth@#1}{% + \pgfplotsthrow{invalid argument}{\pgfplots@loc@TMPa}{Sorry, \string\pgfplotsgetcoordmathfor{#1} failed since `#1' is unknown. Maybe you misspelled it?}\pgfeov% + }{% + \pgfutil@namelet{pgfplotsretval}{pgfcrdmth@#1}% + }% +}% +\pgfplotssetcoordmathfor{pgfbasic}{pgfbasic}% +\pgfplotssetcoordmathfor{float}{float}% +\pgfplotssetcoordmathfor{meta}{float}% +\pgfplotssetcoordmathfor{default}{float}% + + + +% ================================================================================== + + + +% #1 the name of an input method for point meta. It must have been +% declared by \pgfplotsdeclarepointmetasource first. +% #2 any arguments supplied by the user (maybe empty). +\def\pgfplotssetpointmetainput#1#2{% + \csname pgfpmeta@#1@initfor\endcsname{#2}% + % + \edef\pgfplotspointmetainputhandler{#1}% +}% + +% Expands to the current value of 'point meta'. +\def\pgfplotspointmetainputhandler{} + +\def\pgfplotsaxisifhaspointmeta#1#2{% + \ifx\pgfplotspointmetainputhandler\pgfutil@empty #2\else #1\fi +}% + +% Invokes '#1' if the axis contains the coordinate designated by +% \pgfplots@current@point@[xyz] and '#2' if not. +\def\pgfplotsaxisifcontainspoint#1#2{% + \pgf@xa=\pgfplots@current@point@x pt % FIXME : SCOPE REGISTERS!? + \pgf@ya=\pgfplots@current@point@y pt % + \ifpgfplots@curplot@threedim + \pgf@yb=\pgfplots@current@point@z pt % + \fi + \def\pgfplots@loc@TMPa{#2}% + % + % I assume that \pgfplots@[xyz]min@reg and min@reg are registers + % containing the limits. + \ifdim\pgf@xa<\pgfplots@xmin@reg + \else + \ifdim\pgf@xa>\pgfplots@xmax@reg + \else + \ifdim\pgf@ya<\pgfplots@ymin@reg + \else + \ifdim\pgf@ya>\pgfplots@ymax@reg + \else + \ifpgfplots@curplot@threedim + \ifdim\pgf@yb<\pgfplots@zmin@reg + \else + \ifdim\pgf@yb>\pgfplots@zmax@reg + \else + \def\pgfplots@loc@TMPa{#1}% + \fi + \fi + \else + \def\pgfplots@loc@TMPa{#1}% + \fi + \fi + \fi + \fi + \fi + \pgfplots@loc@TMPa% +} + +% Declares a routine which can be used to get point meta input. +% +% Such a routine is invoked in a context where point coordinates are +% processed, i.e. during 'plot coordinates', 'plot table' or the like. +% +% The routine is called `#1'. It consists of several methods, which +% are described below, in the key definitions. +% +% #1: the name of the input routine. +% #2: a sequence of key-value pairs which can be used to overwrite +% 'assign', 'initfor' or the other components. +% See the definitions below for examples. +\def\pgfplotsdeclarepointmetasource#1#2{% + \expandafter\def\csname pgfpmeta@#1@assign\endcsname{\let\pgfplots@current@point@meta=\pgfutil@empty}% + \expandafter\def\csname pgfpmeta@#1@initfor\endcsname##1{}% + \expandafter\def\csname pgfpmeta@#1@issymbolic\endcsname{0}% + \expandafter\def\csname pgfpmeta@#1@explicitinput\endcsname{0}% + \expandafter\def\csname pgfpmeta@#1@activate\endcsname{}% + \expandafter\def\csname pgfpmeta@#1@LUA class\endcsname{}% + \edef\pgfplotsdeclarepointmetasource@{#1}% + \pgfqkeys{/pgfplots/@declare point meta src}{#2}% +}% +\pgfqkeys{/pgfplots/@declare point meta src}{% + % + % a macro used to initialise the point meta source when it is + % selected. + % This macro body is invoked by pgfplots when someone types + % 'point meta=x' -> will invoke 'pgfpmeta@x@initfor{}'. + % The first argument to initfor can be supplied by the user. + % PRECONDITION for 'initfor': + % - it will be invoked just before + % '\pgfplotspointmetainputhandler' will be changed. + % Default is to do nothing. + initfor/.code= + {\expandafter\def\csname pgfpmeta@\pgfplotsdeclarepointmetasource@ @initfor\endcsname##1{#1}},% + % + % Called during the survey phase before the first 'assign' call. + % It is usually empty. + activate/.code= + {\expandafter\def\csname pgfpmeta@\pgfplotsdeclarepointmetasource@ @activate\endcsname{#1}},% + % + % During the survey phase, this macro is expected to assign + % \pgfplots@current@point@meta + % if it is a numeric input method, it should return a + % floating point number. + % It is allowed to return an empty string to say "there is no point + % meta". + % PRECONDITION for '@assign': + % - the coordinate input method has already assigned its + % '\pgfplots@current@point@meta' (probably as raw input string). + % - the other input coordinates are already read. + % POSTCONDITION for '@assign': + % - \pgfplots@current@point@meta is ready for use: + % - EITHER a parsed floating point number + % - OR an empty string, + % - OR a symbolic string (if the issymbolic boolean is true) + % The default implementation is + % \let\pgfplots@current@point@meta=\pgfutil@empty + % + assign/.code= + {\expandafter\def\csname pgfpmeta@\pgfplotsdeclarepointmetasource@ @assign\endcsname{#1}},% + % + % expands to either '1' or '0' + % A numeric source will be processed numerically in float + % arithmetics. Thus, the output of the @assign routine should be + % a macro \pgfplots@current@point@meta in float format. + % + % The output of a numeric point meta source will result in meta + % limit updates and the final map to [0,1000] will be + % initialised automatically. + % + % A symbolic input routine won't be processed. + % Default is '0' + % + issymbolic/.code= + {\expandafter\def\csname pgfpmeta@\pgfplotsdeclarepointmetasource@ @issymbolic\endcsname{#1}},% + % + % expands to either + % '1' or '0'. In case '1', it expects explicit input from the + % coordinate input routines. For example, 'plot file' will look for + % further input after the x,y,z coordinates. + % Default is '0' + % + explicitinput/.code= + {\expandafter\def\csname pgfpmeta@\pgfplotsdeclarepointmetasource@ @explicitinput\endcsname{#1}},% + % + % the associated LUA class name (if any). Use an empty string if + % there is none. + LUA class/.code= + {\expandafter\def\csname pgfpmeta@\pgfplotsdeclarepointmetasource@ @LUA class\endcsname{#1}},% +}% + +% An empty one. This is simple to check with +% \ifx\pgfplotspointmetainputhandler\pgfutil@empty: +\pgfplotsdeclarepointmetasource{}{} +\pgfplotsdeclarepointmetasource{x}{assign={% + \let\pgfplots@current@point@meta=\pgfplots@current@point@x + \pgfplotscoordmath{meta}{parsenumber}{\pgfplots@current@point@meta}% + \let\pgfplots@current@point@meta=\pgfmathresult + }, + LUA class=pgfplots.XcoordAssignmentPointMetaHandler} +\pgfplotsdeclarepointmetasource{y}{assign={% + \let\pgfplots@current@point@meta=\pgfplots@current@point@y + \pgfplotscoordmath{meta}{parsenumber}{\pgfplots@current@point@meta}% + \let\pgfplots@current@point@meta=\pgfmathresult + }, + LUA class=pgfplots.YcoordAssignmentPointMetaHandler} +\pgfplotsdeclarepointmetasource{z}{assign={% + \let\pgfplots@current@point@meta=\pgfplots@current@point@z + \pgfplotscoordmath{meta}{parsenumber}{\pgfplots@current@point@meta}% + \let\pgfplots@current@point@meta=\pgfmathresult + }, + LUA class=pgfplots.ZcoordAssignmentPointMetaHandler} + +\pgfplotsdeclarepointmetasource{explicit}{% + assign={% + \ifx\pgfplots@current@point@meta\pgfutil@empty + \else + \pgfplotscoordmath{meta}{parsenumber}{\pgfplots@current@point@meta}% + \let\pgfplots@current@point@meta=\pgfmathresult + \fi + }, + explicitinput=1,% + LUA class=pgfplots.ExplicitPointMetaHandler.new(), +}% +\pgfplotsdeclarepointmetasource{explicit symbolic}{% + assign={},% no math, simply collect. + explicitinput=1,% + issymbolic=1% +}% + +\pgfplotsdeclarepointmetasource{expr}{% + assign={% + \csname pgfpmeta@\pgfpmeta@expr@origchoice @assign\endcsname + % + \pgfkeysgetvalue{/pgfplots/point meta/expr}\pgfplots@loc@TMPa + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \pgfmathparse{\pgfplots@loc@TMPa}% + \pgfplotscoordmath{meta}{parsenumber}{\pgfmathresult}% + \let\pgfplots@current@point@meta=\pgfmathresult + \fi + },% + initfor={% + \pgfkeyssetvalue{/pgfplots/point meta/expr}{#1}% + \def\pgfplots@loc@TMPa{expr}% + \ifx\pgfplots@loc@TMPa\pgfplotspointmetainputhandler + \else + \let\pgfpmeta@expr@origchoice\pgfplotspointmetainputhandler + \fi + \ifx\pgfpmeta@expr@origchoice\pgfplots@loc@TMPa + \let\pgfpmeta@expr@origchoice\pgfutil@empty + \fi + % + \pgfplotsutilifcontainsmacro{#1}{% + % oh. The point meta expression contains a backslash - it + % depends on a macro. This means: it depends on \thisrow + % or similar TeX stuff - which must be evaluated by TeX. + % + % LUA cannot be used for this point meta handler. + \let\pgfpmeta@expr@LUA@class\pgfutil@empty + }{% + \def\pgfpmeta@expr@LUA@class{pgfplots.ExpressionPointMetaHandler.new("#1")}% + }% + }, + LUA class=\pgfpmeta@expr@LUA@class, +}% +\pgfkeyssetvalue{/pgfplots/point meta/expr}{}% + +\pgfplotsdeclarepointmetasource{f(x)}{% + activate={% + \ifpgfplots@curplot@threedim + \def\pgfplotspointmetainputhandler{z}% + \else + \def\pgfplotspointmetainputhandler{y}% + \fi + \csname pgfpmeta@\pgfplotspointmetainputhandler @activate\endcsname + }, +}% + +\pgfplotsdeclarepointmetasource{TeX code}{% + assign={% + \begingroup + \let\pgfplotspointmeta=\pgfutil@empty + \pgfplots@invoke@pgfkeyscode{/pgfplots/point meta/code/.@cmd}{}% + \pgfplotscoordmath{meta}{parsenumber}{\pgfplotspointmeta}% + \let\pgfplots@current@point@meta=\pgfmathresult + \pgfmath@smuggleone\pgfplots@current@point@meta + \endgroup + },% + initfor={% + \pgfkeysdef{/pgfplots/point meta/code}{#1}% + }, +}% +\pgfplotsdeclarepointmetasource{TeX code symbolic}{% + assign={% + \begingroup + \let\pgfplotspointmeta=\pgfutil@empty + \pgfplots@invoke@pgfkeyscode{/pgfplots/point meta/code/.@cmd}{}% + \let\pgfplots@current@point@meta=\pgfplotspointmeta + \pgfmath@smuggleone\pgfplots@current@point@meta + \endgroup + },% + initfor={% + \pgfkeysdef{/pgfplots/point meta/code}{#1}% + }, + issymbolic=1% +}% +\pgfkeysdef{/pgfplots/point meta/code}{}% + +% Internal stream methods. +% +% Please overwrite +% - \pgfplots@coord@stream@start@, +% - \pgfplots@coord@stream@end@ and +% - \pgfplots@coord@stream@coord@ +% if you implement streams. +% +% REMARK: +% - the stream methods automatically collect first and last +% coordinates. +% - I have experimented with global \addplot accumulation to reduce +% copy operations. That experiment was not successfull (it was not +% faster :-( ). However, the streaming methods still assign their +% things globally... +\def\pgfplots@coord@stream@start{% + \let\pgfplots@current@point@x=\pgfutil@empty + \let\pgfplots@current@point@y=\pgfutil@empty + \let\pgfplots@current@point@z=\pgfutil@empty + \let\pgfplots@current@point@meta=\pgfutil@empty + \let\pgfplots@current@point@error@x@plus=\pgfutil@empty + \let\pgfplots@current@point@error@x@minus=\pgfutil@empty + \let\pgfplots@current@point@error@y@plus=\pgfutil@empty + \let\pgfplots@current@point@error@y@minus=\pgfutil@empty + \let\pgfplots@current@point@error@z@plus=\pgfutil@empty + \let\pgfplots@current@point@error@z@minus=\pgfutil@empty + \pgfplots@coord@stream@start@}% +\def\pgfplots@coord@stream@end{\pgfplots@coord@stream@end@} + +% Will be invoked for every point coordinate. +% +% It invokes \pgfplots@coord@stream@coord@. +% +% Arguments: +% \pgfplots@current@point@[xyz] +% \pgfplots@current@point@[xyz]@error (if in argument list) +% \pgfplots@current@point@meta +\def\pgfplots@coord@stream@coord{% + \pgfplots@coord@stream@coord@% +}% +\def\pgfplotscoordstream@firstlast@init{% + \global\let\pgfplots@currentplot@firstcoord@x=\pgfutil@empty + \global\let\pgfplots@currentplot@firstcoord@y=\pgfutil@empty + \global\let\pgfplots@currentplot@firstcoord@z=\pgfutil@empty + \global\let\pgfplots@currentplot@lastcoord@x=\pgfutil@empty + \global\let\pgfplots@currentplot@lastcoord@y=\pgfutil@empty + \global\let\pgfplots@currentplot@lastcoord@z=\pgfutil@empty +}% +\def\pgfplotscoordstream@firstlast@update{% + \ifx\pgfplots@current@point@x\pgfutil@empty + % only one \if is enough as ONE empty coordinate causes all + % others to be reset as well. + \else + \ifx\pgfplots@currentplot@firstcoord@x\pgfutil@empty + \global\let\pgfplots@currentplot@firstcoord@x=\pgfplots@current@point@x + \global\let\pgfplots@currentplot@firstcoord@y=\pgfplots@current@point@y + \global\let\pgfplots@currentplot@firstcoord@z=\pgfplots@current@point@z + \fi + \global\let\pgfplots@currentplot@lastcoord@x=\pgfplots@current@point@x + \global\let\pgfplots@currentplot@lastcoord@y=\pgfplots@current@point@y + \global\let\pgfplots@currentplot@lastcoord@z=\pgfplots@current@point@z + \fi +}% + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% Scanline management. The idea is to handle complete sequences of +% input coordinates, which are usually separated by a blank line. +% +% This allows a simple syntax to provide matrix input - by means of scanlines. +% Furthermore, 2d plots can use it to interrupt the display. +% +% An empty line in 'addplot coordinates {}' indicates the end of a +% scan line. Similarly, an empty line in 'addplot file' or 'table' +% also indicates the end of a scan line. +% +% The steps taken whenever a scan line is complete depend on the +% configuration of the /pgfplots/empty line choice key (queried in +% \pgfplotsscanlinelengthinitzero). +% +% +% The following methods constitute the scanline interface. +% +% Usage: +% +% \pgfplotsscanlinelengthinitzero +% +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinecomplete +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinecomplete +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinelengthincrease +% <process point> +% \pgfplotsscanlinecomplete +% +% \pgfplotsscanlinelengthcleanup +% +% In other words, the \pgfplotsscanlinelengthincrease routine is +% invoked *before* the point is processed. That's important. +% +% Now, \pgfplotsscanlinelength expands to either +% a) a negative number in which case there is no +% unique scanline length. +% More precisely, -1 means "there was no end-of-scanline marker" +% -2 means "there where end-of-scanline markers, but the scanlines +% had different lengths. +% b) the scanline length. +\def\pgfplotsscanlinelengthinitzero{% + \def\pgfplotsscanlinelength{-1}% + \pgfkeysgetvalue{/pgfplots/empty line}\pgfplots@loc@TMPa% + \edef\pgfplots@loc@TMPa{\pgfplots@loc@TMPa}% + \def\pgfplots@loc@TMPb{auto}% + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + \pgfplotsdetermineemptylinehandler + \pgfkeysgetvalue{/pgfplots/empty line}\pgfplots@loc@TMPa% + \fi + \def\pgfplots@loc@TMPb{jump}% + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + \def\pgfplots@loc@TMPa{nan}% alias for jump + \fi + \def\pgfplots@loc@TMPb{no op}% + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + \def\pgfplots@loc@TMPa{none}% alias for no op + \fi + \pgfutil@ifundefined{pgfplotsscanlinelength@\pgfplots@loc@TMPa @initzero}{% + \pgfplots@error{Sorry, the choice `empty line=\pgfkeysvalueof{/pgfplots/empty line}' is unknown. Maybe you misspelled it}% + }{}% + \expandafter\let\expandafter\pgfplotsscanlinelength@initzero \csname pgfplotsscanlinelength@\pgfplots@loc@TMPa @initzero\endcsname + \expandafter\let\expandafter\pgfplotsscanlinelengthincrease \csname pgfplotsscanlinelength@\pgfplots@loc@TMPa @increase\endcsname + \edef\pgfplotsscanlinecomplete{% + \expandafter\noexpand\csname pgfplotsscanlinelength@\pgfplots@loc@TMPa @complete\endcsname + \noexpand\pgfplotsplothandlernotifyscanlinecomplete + }% + \expandafter\let\expandafter\pgfplotsscanlinelengthcleanup \csname pgfplotsscanlinelength@\pgfplots@loc@TMPa @cleanup\endcsname + \pgfplotsscanlinelength@initzero +}% + +\newif\ifpgfplots@emptyline@compat + +% Invoked for 'empty line=auto'. +% +% @POSTCONDITION: '/pgfplots/empty line' is set to something useful +% (not auto) +\def\pgfplotsdetermineemptylinehandler{% + \if n\pgfplots@meshmode + % no mesh/surf plot: + \pgfkeyssetvalue{/pgfplots/empty line}{jump}% + \ifpgfplots@emptyline@compat + \pgfkeyssetvalue{/pgfplots/empty line}{none}% do nothing for backwards compatibility with 2D processing. + \fi + \else + % it is a mesh or surf plot; use scanline: + \pgfkeyssetvalue{/pgfplots/empty line}{scanline}% + \fi +}% +\def\pgfplotsscanlinedisablechanges{% + \let\pgfplotsscanlinecomplete=\relax + \let\pgfplotsscanlinelengthincrease=\relax + \let\pgfplotsscanlinelengthcleanup=\relax + \let\pgfplotsscanlinelengthinitzero=\relax + \let\pgfplotsscanlineendofinput=\relax +}% + +% ------------------------------------------------------------------------------- +% empty line=scanline +% class: +\def\pgfplotsscanlinelength@scanline@initzero{% + \c@pgfplots@scanlineindex=0 + \def\pgfplots@scanlinelength{-1}% +} +\def\pgfplotsscanlinelength@scanline@increase{% + \advance\c@pgfplots@scanlineindex by1 +} +\def\pgfplotsscanlinelength@scanline@complete{% + \ifnum\pgfplots@scanlinelength>0 + \ifnum\c@pgfplots@scanlineindex=0 + % + % \pgfplotsscanlinecomplete + % \pgfplotsscanlinecomplete + % \pgfplotsscanlinecomplete + % should have the same effect as a single statement. Do + % nothing here. + \else + \ifnum\pgfplots@scanlinelength=\c@pgfplots@scanlineindex\relax + \else +%\message{Found inconsistent scan line length: \pgfplots@scanlinelength\space vs. \the\c@pgfplots@scanlineindex\space near line \pgfplotstablelineno.}% + % special marker which means 'inconsistent scan line length found' + \def\pgfplots@scanlinelength{-2}% + \fi + \fi + \else + \ifnum\pgfplots@scanlinelength=-2 + \else + \edef\pgfplots@scanlinelength{\the\c@pgfplots@scanlineindex}% + \fi + \fi + \c@pgfplots@scanlineindex=0 +} +\def\pgfplotsscanlinelength@scanline@cleanup{% + \ifnum\c@pgfplots@scanlineindex=0 + % I assume the last scan line is already complete. + \else + \pgfplotsscanlinecomplete + \fi + \let\pgfplotsscanlinelength=\pgfplots@scanlinelength +} +% ------------------------------------------------------------------------------- +% +% empty line=none class: +% +\let\pgfplotsscanlinelength@none@initzero=\pgfutil@empty +\let\pgfplotsscanlinelength@none@increase=\relax +\let\pgfplotsscanlinelength@none@complete=\relax +\let\pgfplotsscanlinelength@none@cleanup=\relax +% ------------------------------------------------------------------------------- +% +% empty line=nan class: +\def\pgfplotsscanlinelength@nan@initzero{% + \def\pgfplotsscanlinelength@nan@isfirst{1}% + \let\pgfplotsscanlinelength@nan@pendingwork=\relax + \pgfplotsifinaxis{}{\let\pgfplotsaxisserializedatapoint=\relax}% +}% +\def\pgfplotsscanlinelength@nan@increase{% + \def\pgfplotsscanlinelength@nan@isfirst{0}% + \pgfplotsscanlinelength@nan@pendingwork +}% +\def\pgfplotsscanlinelength@nan@complete{% + \if1\pgfplotsscanlinelength@nan@isfirst + \else + \def\pgfplotsscanlinelength@nan@pendingwork{% + % this will be executed when the next point has been + % found. + \def\pgfplots@current@point@x{}% + \def\pgfplots@current@point@y{}% + \def\pgfplots@current@point@z{}% + % simply serialize an empty point. That works -- the + % visualization phase checks if the coordinates are empty and + % visualizes them as "jump" + % + % Note that \pgfplotsplothandlersurveypoint is not a good + % choice here unless one employs its 'unbounded coords=jump' + % feature + \def\pgfplotsaxisplothasjumps{1}% + \pgfplotsaxisserializedatapoint + % + \let\pgfplotsscanlinelength@nan@pendingwork=\relax + }% + \fi + \def\pgfplotsscanlinelength@nan@isfirst{1}% +}% +\let\pgfplotsscanlinelength@nan@cleanup=\relax +% +% ------------------------------------------------------------------------------- + + +\def\pgfplotsaxisfilteredcoordsaway{0}% +\def\pgfplotsaxisplothasjumps{0}% +\newif\ifpgfplotsaxisparsecoordinateok + +% Initialises +% \pgfplots@coord@stream@start +% \pgfplots@coord@stream@coord +% \pgfplots@coord@stream@end +% such that a following coordinate stream is processed properly. The +% following coordinate stream may come from different input methods. +% +% This coordinate stream is the first time a coordinate will be +% reported and processed by pgfplots. The task of this first pass is +% to +% - compute and update any axis limits, +% - collect and prepare ranges for color data, +% - handle stacked plots and error bars, +% - store the complete state of the plot's preprocessing in an +% internal datastructure for later completion. +% This involves a serialization of all processed points (i.e. the +% generation of a long coordinate list) +% +% Any \addplot command should issue \pgfplots@PREPARE@COORD@STREAM +% eventually. +% +% Arguments: +% #1: any trailing path commands after the 'plot' command as such, +% for example \addplot plot coordinates {...} -- (0,0); +% would yield #1 =' -- (0,0)' +% +% PRECONDITION: +% - needs to be called inside of \addplot. +% - \pgfplots@addplot@survey@@optionlist contains the <options> +% provided to \addplot (all of them, including automatically +% determined ones) +% +% REMARK: +% The following code is permissable: +% \pgfplots@PREPARE@COORD@STREAM{...} +% \pgfplots@coord@stream@start +% ... +% \pgfplots@coord@stream@coord +% .. +% \pgfplots@coord@stream@coord +% .. +% \pgfplots@coord@stream@end +% -> All need to be the SAME LEVEL OF SCOPING! The '@coord' commands +% may not be scoped deeper than 'begin' and 'end'! +% - I had a version which allowed that. it was actually slower! +% - For now, the following things are global / local: +% - point coordinate list: local +% - meta data limits: global, +% - what about stacked plot stuff: appears to be a combination +% of local/global. +% - all that will be serialized and written into +% \pgfplots@stored@plotlist in \pgfplots@coord@stream@end. +% This list is global, so, if I am not mistaken, the scoping +% level of the complete stream operation from setup to @end can +% be as deep as necessary - as long as all operations have the +% same level of scoping. +% +% @see the detailed documentation in pgfplotsplothandlers.code.tex +\long\def\pgfplots@PREPARE@COORD@STREAM#1{% + \ifpgfplots@curplot@threedim + \global\pgfplots@threedimtrue + \fi + \def\pgfplotsaxisfilteredcoordsaway{0}% + \def\pgfplotsaxisplothasjumps{0}% + % + % FIXME : these macros should not be redefined! They are defined + % in \pgfplots@prepare@axis@API right during \begin{axis}... they + % probably shouldn't be changed. + \ifpgfplots@curplot@threedim + \let\pgfplotsaxisupdatelimitsforcoordinate=\pgfplotsaxisupdatelimitsforcoordinatethreedim + \let\pgfplotsaxisparsecoordinate=\pgfplotsaxisparsecoordinatethreedim + \else + \let\pgfplotsaxisupdatelimitsforcoordinate=\pgfplotsaxisupdatelimitsforcoordinatetwodim + \let\pgfplotsaxisparsecoordinate=\pgfplotsaxisparsecoordinatetwodim + \fi + \begingroup + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \let\E=\noexpand + % +%\message{Assembled update-limits \ifpgfplots@curplot@threedim 3D\else 2D\fi macro to {\meaning\pgfplotsaxisupdatelimitsforcoordinate}}% + \ifpgfplots@bb@isactive + \else + % we are inside of + % \pgfplotsinterruptdatabb + % .. + % \endpgfinterruptboundingbox + % -> don't change data limits! + \gdef\pgfplotsaxisupdatelimitsforcoordinate##1##2##3{}% + \fi + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + % + % + % Takes a coordinate which is already parsed and applies steps + % such that it becomes its final values. + % + % This implements the stacked plot feature currently. + % + % PRECONDITION: + % \pgfplotsaxisparsecoordinate has already been called. + % + % POSTCONDITION: + % the point has its final coordinates; the axis won't change it + % anymore. + \xdef\pgfplotsaxispreparecoordinate{% + \E\ifpgfplotsaxisparsecoordinateok + % All following routines (limit updating/stacking/error + % bars) will use float numerics if necessary (controlled + % by ifs). + \E\pgfplotsaxistransformfromdatacs + \ifpgfplots@stackedmode + \E\pgfplots@stacked@preparepoint@inmacro% + \fi + \E\fi + }% + % + % A macro which should be called once for every data point during the + % survey phase. + % + % The caller is the plot handler's point survey routine. + % + % A data point might be a complicated thing which contains + % multiple coordinates. You need to invoke + % \pgfplotsaxisparsecoordinate and + % \pgfplotsaxispreparecoordinate for each of them. But + % \pgfplotsaxisdatapointsurveyed is invoked once for the complete + % set. + % + % @PRECONDITION + % - \pgfplots@current@point@[xyz] contain final coordinates + % (i.e. output of \pgfplotsaxispreparecoordinate) + % + % @POSTCONDITION + % - stacked plot things, + % - error bars, + % - xtick=data + % are all processed. + % + \xdef\pgfplotsaxisdatapointsurveyed{% + \E\ifpgfplotsaxisparsecoordinateok + % All following routines (limit updating/stacking/error + % bars) will use float numerics if necessary (controlled + % by ifs). + % + % Prepare \pgfplots@current@point@meta (see the preparation + % routine above): + \E\pgfplotsaxissurveysetpointmeta + % + \ifpgfplots@errorbars@enabled + \E\pgfplots@errorbars@survey@point + \fi + % + \ifpgfplots@collect@firstplot@astick + \ifnum\pgfplots@numplots=0 + \E\ifx\E\pgfplots@firstplot@coords@x\E\pgfutil@empty + \E\t@pgfplots@tokc={}% + \E\else + \E\t@pgfplots@tokc=\E\expandafter{\E\pgfplots@firstplot@coords@x,}% + \E\fi + \E\xdef\E\pgfplots@firstplot@coords@x{\E\the\E\t@pgfplots@tokc\E\pgfplots@current@point@x}% + \E\ifx\E\pgfplots@firstplot@coords@y\E\pgfutil@empty + \E\t@pgfplots@tokc={}% + \E\else + \E\t@pgfplots@tokc=\E\expandafter{\E\pgfplots@firstplot@coords@y,}% + \E\fi + \E\xdef\E\pgfplots@firstplot@coords@y{\E\the\E\t@pgfplots@tokc\E\pgfplots@current@point@y}% + % + \ifpgfplots@curplot@threedim + \E\ifx\E\pgfplots@firstplot@coords@z\E\pgfutil@empty + \E\t@pgfplots@tokc={}% + \E\else + \E\t@pgfplots@tokc=\E\expandafter{\E\pgfplots@firstplot@coords@z,}% + \E\fi + \E\xdef\E\pgfplots@firstplot@coords@z{\E\the\E\t@pgfplots@tokc\E\pgfplots@current@point@z}% + \fi + \fi + \fi + \E\pgfplotscoordstream@firstlast@update + \E\pgfplotsaxisserializedatapoint + \E\else + % COORDINATE HAS BEEN FILTERED AWAY: + % + % make ALL empty to simplify special case checking: + \E\let\E\pgfplots@current@point@x=\E\pgfutil@empty + \E\let\E\pgfplots@current@point@y=\E\pgfutil@empty + \E\let\E\pgfplots@current@point@z=\E\pgfutil@empty + % check whether we have UNBOUNDED or just unfiltered + % coords: + \if\pgfplots@unbounded@handler d% unbounded coords=discard + \E\def\E\pgfplotsaxisfilteredcoordsaway{1}% + \ifpgfplots@warn@for@filter@discards + \E\pgfplots@message{% + NOTE: coordinate (\E\pgfplots@current@point@x@unfiltered,\E\pgfplots@current@point@y@unfiltered\ifpgfplots@curplot@threedim,\E\pgfplots@current@point@z@unfiltered\fi) + has been dropped because + \E\ifx\E\pgfplots@unbounded@dir\E\pgfutil@empty + of a coordinate filter. + \E\else + it is unbounded (in \E\pgfplots@unbounded@dir). + \E\fi + (see also unbounded coords=jump). + }% + \fi + \else + % unbounded coords=jump + \E\ifx\E\pgfplots@unbounded@dir\E\pgfutil@empty + \E\def\E\pgfplotsaxisfilteredcoordsaway{1}% + \ifpgfplots@warn@for@filter@discards + \E\pgfplots@message{% + NOTE: coordinate (\E\pgfplots@current@point@x@unfiltered,\E\pgfplots@current@point@y@unfiltered\ifpgfplots@curplot@threedim,\E\pgfplots@current@point@z@unfiltered\fi) + has been dropped because of a coordinate filter. + }% + \fi + \E\else + \E\def\E\pgfplotsaxisplothasjumps{1}% + \E\pgfplotsaxisserializedatapoint + \E\fi + \fi + \E\fi + % + % increase \pgfplots@current@point@coordindex: + \E\advance\E\c@pgfplots@coordindex by1 + }% + % + % + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \endgroup + % + \def\pgfplotsaxissurveysetpointmeta{% + \pgfplotsplothandlersurveybeforesetpointmeta + \pgfplots@set@perpointmeta + \pgfplotsplothandlersurveyaftersetpointmeta + }% + % +%\message{Prepared macro \string\pgfplots@update@limits@for@one@point: {\meaning\pgfplotsaxisupdatelimitsforcoordinate}}% +%\message{Prepared macro \string\pgfplots@process@one@point: {\meaning\pgfplots@process@one@point}}% + % + \let\pgfplots@coord@stream@start@=\pgfplots@PREPARE@COORD@STREAM@start@ + \def\pgfplots@coord@stream@coord@{% + \def\pgfplots@set@perpointmeta@done{0}% + % NOTE: this might call LUA (if supported): + \pgfplotsplothandlersurveypoint + }% + \def\pgfplots@coord@stream@end@{\pgfplots@PREPARE@COORD@STREAM@end@{#1}}% +}% + +% The \pgfplots@coord@stream@start@ routine used inside of +% \pgfplots@PREPARE@COORD@STREAM. +% +% It prepares everything for the first pass through all input +% coordinates. +\def\pgfplots@PREPARE@COORD@STREAM@start@{% + % The current implementation of pgfplots stores the preprocessed + % coordinate stream into a long list of coordinates. + % Since macro append is an expensive operation, it uses the highly + % optimized 'applistXX' structure: + \pgfplotsapplistXXnewempty + % + \edef\plotnumofactualtype{\numplotsofactualtype}% + \csname pgfpmeta@\pgfplotspointmetainputhandler @activate\endcsname + \pgfplots@LUA@survey@start + \pgfplotsplothandlersurveystart + \pgfplotscoordstream@firstlast@init + % + \pgfkeyssetvalue{/data point/x}{\pgfplots@current@point@x}% + \pgfkeyssetvalue{/data point/y}{\pgfplots@current@point@y}% + \pgfkeyssetvalue{/data point/z}{\pgfplots@current@point@z}% + \pgfkeyssetvalue{/data point/meta}{\pgfplots@current@point@meta}% + % + \ifpgfplots@stackedmode + \pgfplots@stacked@beginplot + \fi + \ifpgfplots@errorbars@enabled + % prepare error bar processing. + \pgfplots@errorbars@survey@begin + \fi + % + % + \pgfplots@prepare@visualization@dependencies + % + % Inside of math expressions, 'x', 'y' and 'z' expand to the + % current x,y and z coords respectively. Introduce these (and some + % more) shortcuts: + % FIXME : defining the resulting x/y coordinates as 'x' and 'y' constants was a really really bad idea in the first place :-( + \pgfplotsmathdeclarepseudoconstant{x}{\let\pgfmathresult=\pgfplots@current@point@x}% + \pgfplotsmathdeclarepseudoconstant{y}{\let\pgfmathresult=\pgfplots@current@point@y}% + \pgfplotsmathdeclarepseudoconstant{z}{\let\pgfmathresult=\pgfplots@current@point@z}% + \pgfplotsmathdeclarepseudoconstant{rawx}{\let\pgfmathresult=\pgfplots@current@point@x@unfiltered}% + \pgfplotsmathdeclarepseudoconstant{rawy}{\let\pgfmathresult=\pgfplots@current@point@y@unfiltered}% + \pgfplotsmathdeclarepseudoconstant{rawz}{\let\pgfmathresult=\pgfplots@current@point@z@unfiltered}% + \pgfplotsmathdeclarepseudoconstant{meta}{% + \let\pgfmathresult=\pgfplots@current@point@meta + \ifx\pgfmathresult\pgfutil@empty + \pgfplotscoordmath{meta}{parsenumber}{0}% + \fi + }% + % + % %%%%%%%%%%%%%% + % + % Define \pgfplots@set@perpointmeta properly: + \def\pgfplots@set@perpointmeta{% + \if0\pgfplots@set@perpointmeta@done + \csname pgfpmeta@\pgfplotspointmetainputhandler @assign\endcsname + \def\pgfplots@set@perpointmeta@done{1}% + \pgfplots@set@perpointmeta@limits + \fi + }% + % append limit updating to \pgfplots@set@perpointmeta : + \if0\csname pgfpmeta@\pgfplotspointmetainputhandler @issymbolic\endcsname + % We need to work with per point meta data. + % So, also compute the data range on a per-plot basis! + % These limits are important later. + \pgfkeysgetvalue{/pgfplots/point meta min}\pgfplots@metamin + \t@pgfplots@tokb={}% + \ifx\pgfplots@metamin\pgfutil@empty + \global\let\pgfplots@metamin=\pgfplots@invalidrange@metamin + \t@pgfplots@tokb=\expandafter{\the\t@pgfplots@tokb + \pgfplotscoordmath{meta}{min}{\pgfplots@metamin}{\pgfplots@current@point@meta}% + \global\let\pgfplots@metamin=\pgfmathresult + }% + \else + \pgfplotscoordmath{meta}{parsenumber}{\pgfplots@metamin}% + \global\let\pgfplots@metamin=\pgfmathresult + \fi + \pgfkeysgetvalue{/pgfplots/point meta max}\pgfplots@metamax + \ifx\pgfplots@metamax\pgfutil@empty + \global\let\pgfplots@metamax=\pgfplots@invalidrange@metamax + \t@pgfplots@tokb=\expandafter{\the\t@pgfplots@tokb + \pgfplotscoordmath{meta}{max}{\pgfplots@metamax}{\pgfplots@current@point@meta}% + \global\let\pgfplots@metamax=\pgfmathresult + }% + \else + \pgfplotscoordmath{meta}{parsenumber}{\pgfplots@metamax}% + \global\let\pgfplots@metamax=\pgfmathresult + \fi + % + \edef\pgfplots@set@perpointmeta@limits{% + \noexpand\ifx\noexpand\pgfplots@current@point@meta\noexpand\pgfutil@empty + \noexpand\else + \the\t@pgfplots@tokb + \noexpand\fi + }% + \def\pgfplotsaxisupdatelimitsforpointmeta##1{% + \begingroup + \def\pgfplots@current@point@meta{##1}% + \pgfplots@set@perpointmeta@limits + \endgroup + }% + \else + % there is no point meta: + \global\let\pgfplots@metamin=\pgfutil@empty + \global\let\pgfplots@metamax=\pgfutil@empty + \let\pgfplots@set@perpointmeta@limits=\relax + \def\pgfplotsaxisupdatelimitsforpointmeta##1{}% + \fi +}% +% This is the \pgfplots@coord@stream@end@ routine which is invoked by +% \pgfplots@PREPARE@COORD@STREAM. +% +% It finalizes the first pass through the input coordinates and +% remembers the preprocessed \addplot command. +% +% Technical note: The parameters provided to +% \pgfplots@PREPARE@COORD@STREAM +% are needed here. This doesn't fit directly into the framework of +% coordinate streams, see \pgfplots@PREPARE@COORD@STREAM how this +% invocation works. +% +% #1,#2: see \pgfplots@PREPARE@COORD@STREAM +\def\pgfplots@PREPARE@COORD@STREAM@end@#1{% + \pgfkeysvalueof{/pgfplots/execute at end survey}% + \ifpgfplots@LUA@backend@supported + \pgfplots@LUA@survey@end + \fi + % FIXME : move this the \pgfplotsplothandlersurveyend of mesh plot + % handler: + \pgfkeyssetvalue{/pgfplots/mesh/num points}{\pgfplots@current@point@coordindex}% + % + \pgfplotsplothandlersurveyend + \ifx\pgfplots@metamin\pgfutil@empty + \else + \if\pgfplots@axiswide@metamin@autocompute1% + \pgfplotscoordmath{meta}{min}{\pgfplots@axiswide@metamin}{\pgfplots@metamin}% + \global\let\pgfplots@axiswide@metamin=\pgfmathresult + \fi + \if\pgfplots@axiswide@metamax@autocompute1% + \pgfplotscoordmath{meta}{max}{\pgfplots@axiswide@metamax}{\pgfplots@metamax}% + \global\let\pgfplots@axiswide@metamax=\pgfmathresult + \fi + \fi + \if1\pgfplots@colorbar@set@src% this 0|1 switch is set in \pgfplots@start@plot@with@behavioroptions + \ifx\pgfplots@metamin\pgfutil@empty + \pgfplotsthrow{no such element}{\pgfplots@loc@TMPa}{Sorry, `colorbar source' can't be processed: the current \string\addplot\space command doesn't have point meta. Ignoring it.}\pgfeov% + \else + \global\let\pgfplots@colorbar@src@metamin=\pgfplots@metamin + \global\let\pgfplots@colorbar@src@metamax=\pgfplots@metamax + \fi + \fi + \ifpgfplots@autocompute@all@limits + \global\let\pgfplots@data@xmin=\pgfplots@xmin + \global\let\pgfplots@data@xmax=\pgfplots@xmax + \global\let\pgfplots@data@ymin=\pgfplots@ymin + \global\let\pgfplots@data@ymax=\pgfplots@ymax + \global\let\pgfplots@data@zmin=\pgfplots@zmin + \global\let\pgfplots@data@zmax=\pgfplots@zmax + \fi + \ifpgfplots@errorbars@enabled + \pgfplots@errorbars@survey@end + \fi + \ifpgfplots@stackedmode + \pgfplots@stacked@survey@endplot + \fi + \ifx\pgfplots@currentplot@firstcoord@x\pgfutil@empty + \pgfplotswarning{plot without coordinates}\pgfeov% + \else + % Idea: use + % \scope[plot specification] + % <any paths for error bars> + % \endscope + % \draw plot coordinates {...}; + % to share plot specifications between error bars and plot + % coordinates. Unfortunately, it is NOT sufficient to use + % \tikzset + \pgfplotspreparemeshkeydefaults% + \pgfplots@PREPARE@COORD@STREAM@end@determinecoordsorting x% + \pgfplots@PREPARE@COORD@STREAM@end@determinecoordsorting y% + % + \pgfplots@remember@survey@option@list + % + % warning: rememberplotspec calls list macros which + % overwrite \t@pgfplots@toka + \t@pgfplots@toka=\expandafter{\pgfplots@addplot@survey@@optionlist}% + % ATTENTION: do NOT call list macros from here on! + % + \pgfplotsplothandlerserializestateto\pgfplots@loc@TMPa + \t@pgfplots@tokb=\expandafter{\pgfplots@loc@TMPa}% + % + \pgfplots@markers@survey@set@visphasename + \let\pgfplots@markers@visphase@name=\pgfplotsretval + % + \pgfplotssurveyphase@set@visphase@names{#1}% + \let\pgfplots@visphase@names=\pgfplotsretval + % + \t@pgfplots@tokc={#1}% + % + % SERIALIZE RESULT: + % + % everything which has been accumulated so far (including the + % preprocessed coordinates) will be serialized into the + % structure \pgfplots@stored@plotlist (globally). + % + % assemble a \pgfplots@addplot@enqueue@coords command ... + % BEGIN HERE ... + % vvvvvvvvvv + \xdef\pgfplots@glob@TMPa{% + \noexpand\pgfplots@addplot@enqueue@coords + {% precommand(s): + \expandafter\noexpand\csname pgfplots@curplot@threedim\ifpgfplots@curplot@threedim true\else false\fi\endcsname + % + % Did we prepare the data within LUA? remember that! + \ifpgfplots@LUA@backend@supported + \noexpand\pgfplots@LUA@backend@supportedtrue + \else + \noexpand\pgfplots@LUA@backend@supportedfalse + \fi + \noexpand\def\noexpand\plotnum{\the\pgfplots@numplots}% + % + % store \plotnumofactualtype + \noexpand\def\noexpand\plotnumofactualtype{\plotnumofactualtype}% + % ... and make sure that it + % remains the same type even if some plot handler uses + % other plot handlers internally: + \noexpand\def\noexpand\pgfplotsplothandlername@actual{\pgfplotsplothandlername@actual}% + \noexpand\let\noexpand\numplotsofactualtype\noexpand\pgfplots@numplotsofactualtype@duringplot + % + \noexpand\def\noexpand\numcoords{\pgfplots@current@point@coordindex}% + % \pgfplots@current@point@coordindex will always contain the current index. + % Maybe overwritten if not provided using \c@pgfplots@coordindex. + \noexpand\def\noexpand\pgfplots@current@point@coordindex{\noexpand\the\noexpand\c@pgfplots@coordindex}% + \noexpand\def\noexpand\coordindex{\noexpand\pgfplots@current@point@coordindex}% valid inside of \addplot + % + \ifpgfplots@stackedmode + \pgfplots@stacked@serialized@commands + \fi + % + % save the possibly prepare/adjusted plot + % variables [FIXME: move after \pgfplots@define@currentplotstyle@as ?]: + \noexpand\pgfkeyssetvalue{/pgfplots/samples}{\pgfplots@plot@samples}% + \noexpand\pgfkeyssetvalue{/pgfplots/domain}{\pgfplots@plot@domain}% + \noexpand\pgfkeyssetvalue{/pgfplots/samples at}{\pgfplots@plot@samples@at}% + \noexpand\pgfkeyssetvalue{/pgfplots/mesh/rows}{\pgfkeysvalueof{/pgfplots/mesh/rows}}% + \noexpand\pgfkeyssetvalue{/pgfplots/mesh/cols}{\pgfkeysvalueof{/pgfplots/mesh/cols}}% + \noexpand\pgfkeyssetvalue{/pgfplots/mesh/num points}{\pgfkeysvalueof{/pgfplots/mesh/num points}}% + % either '+' or '-' : + \noexpand\pgfkeyssetvalue{/pgfplots/x coord sorting}{\pgfkeysvalueof{/pgfplots/x coord sorting}}% + \noexpand\pgfkeyssetvalue{/pgfplots/y coord sorting}{\pgfkeysvalueof{/pgfplots/y coord sorting}}% + % + % remember 'current plot style': + \noexpand\pgfplots@define@currentplotstyle@as{% + \the\t@pgfplots@toka + }% + % per-point meta data ranges which apply only to + % this plot: + \noexpand\xdef\noexpand\pgfplots@metamin{\pgfplots@metamin}% + \noexpand\xdef\noexpand\pgfplots@metamax{\pgfplots@metamax}% + \noexpand\def\noexpand\pgfplotspointmetainputhandler{\pgfplotspointmetainputhandler}% + \noexpand\def\noexpand\pgfplots@serialized@state@plothandler{\the\t@pgfplots@tokb}% + \noexpand\def\noexpand\pgfplots@markers@visphase@name{\pgfplots@markers@visphase@name}% + \noexpand\def\noexpand\pgfplots@visphase@names{\pgfplots@visphase@names}% + \noexpand\def\noexpand\pgfplotsaxisfilteredcoordsaway{\pgfplotsaxisfilteredcoordsaway}% + \noexpand\def\noexpand\pgfplotsaxisplothasjumps{\pgfplotsaxisplothasjumps}% + \noexpand\pgfkeyssetvalue{/pgfplots/on layer}{\pgfkeysvalueof{/pgfplots/on layer}}% + \noexpand\def\noexpand\pgfplots@serialized@afterpath{\the\t@pgfplots@tokc}% + }% + {% draw command: + \noexpand\path% + }% + }% + \pgfplotsapplistXXlet\pgfplots@coord@stream@recorded + \pgfplotsapplistXXclear + \t@pgfplots@tokc=\expandafter{\pgfplots@coord@stream@recorded}% + \t@pgfplots@toka=\expandafter{\pgfplots@glob@TMPa}% + \xdef\pgfplots@glob@TMPa{% + \the\t@pgfplots@toka + {% coordinates which need to be processed in \endaxis. + % See + % \pgfplots@coord@stream@finalize@storedcoords@START + % (will become available as \pgfplots@stored@current@data) + \the\t@pgfplots@tokc + }% + }% + % + \pgfplots@glob@TMPa + {% + % Post commands are empty here. + }% + %^^^^^^^^^^^^ ... END of \pgfplots@addplot@enqueue@coords HERE + \fi + \pgfplots@end@plot +}% + +\def\pgfplots@remember@survey@option@list{% + \t@pgfplots@tokc=\expandafter{\pgfplots@addplot@survey@@optionlist,% + /pgfplots/.cd,/pgfplots/every axis plot post}% + \edef\pgfplots@addplot@survey@@optionlist{\the\t@pgfplots@tokc}% + \ifpgfplots@curplot@isirrelevant + % for \label commands: + \expandafter\pgfplots@rememberplotspec@for@label\expandafter{\pgfplots@addplot@survey@@optionlist}% + \else + \expandafter\pgfplots@rememberplotspec\expandafter{\pgfplots@addplot@survey@@optionlist}% + \fi +}% + +\def\pgfplots@LUA@survey@log@deactivation#1{% + \pgfplots@log{\pgfplots@LUA@loglevel@info}{Using 'lua backend=false' for plot \the\pgfplots@numplots\space (type '\pgfplotsplothandlername'): #1.}% + \pgfplots@LUA@backend@failed +}% + +\def\pgfplots@LUA@survey@get@filter#1{% + \begingroup + \pgfkeysgetvalue{/pgfplots/#1 filter/.@cmd}\pgfplots@loc@TMPc + \ifx\pgfplots@loc@TMPc\pgfplots@empty@command@key + \let\pgfplotsretval=\pgfutil@empty + \else + \pgfplots@ifisfilterexpression{#1 filter}{% + \pgfkeysgetvalue{/pgfplots/#1 filter/@expressionvalue}\pgfplotsretval + \expandafter\pgfplotsutilifcontainsmacro\expandafter{\pgfplotsretval}{% + \aftergroup\pgfplots@LUA@backend@supportedfalse + \pgfplots@command@to@string\pgfplotsretval\pgfplots@loc@TMPa + \pgfplots@LUA@survey@log@deactivation{#1 filter/.expression='\pgfplots@loc@TMPa' contains a TeX macro}% + \let\pgfplotsretval=\pgfutil@empty + }{% + }% + }{% + \aftergroup\pgfplots@LUA@backend@supportedfalse + \pgfplots@LUA@survey@log@deactivation{LUA does not support #1 filter (yet)}% + \let\pgfplotsretval=\pgfutil@empty + }% + \fi + \pgfmath@smuggleone\pgfplotsretval + \endgroup +}% + +\def\pgfplots@LUA@survey@start{% + \ifpgfplots@LUA@backend@supported + \ifx\pgfplotsplothandlerLUAfactory\pgfutil@empty + \pgfplots@LUA@survey@log@deactivation{plot handler does not support LUA}% + \pgfplots@LUA@backend@supportedfalse + \fi + % + \ifx\pgfplotspointmetainputhandler\pgfutil@empty + \def\pgfplots@loc@TMPa{nil}% + \else + \edef\pgfplots@loc@TMPa{% + \csname pgfpmeta@\pgfplotspointmetainputhandler @LUA class\endcsname}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \pgfplots@LUA@survey@log@deactivation{point meta choice does not support LUA}% + \pgfplots@LUA@backend@supportedfalse + \fi + \fi + \ifpgfplots@stackedmode + \pgfplots@LUA@survey@log@deactivation{LUA does not support stacked plots (yet)}% + \pgfplots@LUA@backend@supportedfalse + \fi + \ifpgfplots@errorbars@enabled + \pgfplots@LUA@survey@log@deactivation{LUA does not support error bars (yet)}% + \pgfplots@LUA@backend@supportedfalse + \fi + \ifpgfplots@collect@firstplot@astick + \pgfplots@LUA@survey@log@deactivation{LUA does not support xtick=data (yet)}% + \pgfplots@LUA@backend@supportedfalse + \fi + \pgfkeysgetvalue{/pgfplots/pre filter/.@cmd}\pgfplots@loc@TMPc\ifx\pgfplots@loc@TMPc\pgfplots@empty@command@key\else \pgfplots@LUA@backend@supportedfalse\pgfplots@LUA@survey@log@deactivation{LUA does not support filter (yet)}\fi + \pgfplots@LUA@survey@get@filter x% + \let\pgfplots@loc@filter@x=\pgfplotsretval + \pgfplots@LUA@survey@get@filter y% + \let\pgfplots@loc@filter@y=\pgfplotsretval + \pgfplots@LUA@survey@get@filter z% + \let\pgfplots@loc@filter@z=\pgfplotsretval + \pgfkeysgetvalue{/pgfplots/filter point/.@cmd}\pgfplots@loc@TMPc\ifx\pgfplots@loc@TMPc\pgfplots@empty@command@key\else \pgfplots@LUA@backend@supportedfalse\pgfplots@LUA@survey@log@deactivation{LUA does not support filter (yet)}\fi + % + \pgfkeysgetvalue{/pgfplots/execute for finished point}\pgfplots@loc@TMPc\ifx\pgfplots@loc@TMPc\pgfutil@empty\else \pgfplots@LUA@backend@supportedfalse\fi + % + \pgfkeysgetvalue{/pgfplots/visualization depends on/list}\pgfplots@loc@TMPc \ifx\pgfplots@loc@TMPc\pgfutil@empty\else \pgfplots@LUA@backend@supportedfalse\pgfplots@LUA@survey@log@deactivation{LUA does not support 'visualization depends on' (yet)} \fi + % + % + \edef\pgfplots@loc@TMPc{\pgfkeysvalueof{/pgfplots/data cs}}% + \edef\pgfplots@loc@TMPd{\pgfkeysvalueof{/pgfplots/@expected axis cs}}% + \ifx\pgfplots@loc@TMPc\pgfplots@loc@TMPd\else\pgfplots@LUA@backend@supportedfalse\pgfplots@LUA@survey@log@deactivation{LUA does not support 'data cs' (yet)}\fi + % + % hm. There are various cases which are supported during a + % SURVEY -- but not during a visualization. Check that here: + \if m\pgfplots@colormap@access + \else + \pgfplots@LUA@survey@log@deactivation{color map access=direct not supported (yet)}% + \pgfplots@LUA@backend@supportedfalse + \fi + % + \ifpgfplots@LUA@backend@supported + \begingroup + \pgfkeysgetvalue{/pgfplots/point meta min}\pgfplots@loc@metamin + \pgfkeysgetvalue{/pgfplots/point meta max}\pgfplots@loc@metamax + \pgfplots@log{\pgfplots@LUA@loglevel@debug}{lua backend=true: Activating LUA backend for plot \the\pgfplots@numplots\space (type '\pgfplotsplothandlername').}% + \edef\pgfplots@loc@TMPa{% + local gca = pgfplots.gca;^^J% + gca.min = {^^J% + pgfplots.pgftonumber("\pgfplots@xmin"), ^^J% + pgfplots.pgftonumber("\pgfplots@ymin"), ^^J% + pgfplots.pgftonumber("\pgfplots@zmin")}; ^^J% + gca.max = {^^J% + pgfplots.pgftonumber("\pgfplots@xmax"), ^^J% + pgfplots.pgftonumber("\pgfplots@ymax"), ^^J% + pgfplots.pgftonumber("\pgfplots@zmax")}; ^^J% + % FIXME : what about datamin/datamax!? + local plothandlerFactory = \pgfplotsplothandlerLUAfactory; ^^J% + local plothandler = plothandlerFactory(gca, \pgfplots@loc@TMPa);^^J% second arg: point meta handler + \ifx\pgfplots@loc@metamin\pgfutil@empty + \else + plothandler.autocomputeMetaMin = false;^^J% + plothandler.metamin = pgfplots.pgftonumber("\pgfplots@loc@metamin");^^J% + \fi + \ifx\pgfplots@loc@metamax\pgfutil@empty + \else + plothandler.autocomputeMetaMax = false;^^J% + plothandler.metamax = pgfplots.pgftonumber("\pgfplots@loc@metamax");^^J% + \fi + local config = plothandler.config;^^J% + config.unboundedCoords = "\pgfplots@unbounded@handler";^^J% + config.warnForfilterDiscards = \pgfplots@boolval{pgfplots@warn@for@filter@discards};^^J% + config.pointmetarel = \pgfplots@perpointmeta@rel@choice;^^J% + config.updateLimits = \ifpgfplots@bb@isactive true\else false\fi;^^J% + config.filterExpressionByDir = {^^J% + "\pgfplots@loc@filter@x",^^J% + "\pgfplots@loc@filter@y",^^J% + "\pgfplots@loc@filter@z"};^^J% + gca.plothandlers[\the\pgfplots@numplots+1] = plothandler;^^J% + gca.currentPlotHandler = plothandler;^^J% + plothandler:surveystart();^^J% + }% +%\message{Executing ^^J\pgfplots@loc@TMPa^^J^^J}% + \directlua{\pgfplots@loc@TMPa}% + \endgroup + \fi + \fi +}% + +\def\pgfplots@LUA@survey@point{% + \directlua{pgfplots.texSurveyPoint("\pgfplots@current@point@x","\pgfplots@current@point@y","\pgfplots@current@point@z","\pgfplots@current@point@meta")}% +}% + +\def\pgfplots@LUA@survey@end{% + % LUA defines a couple of TeX macros here... + \directlua{pgfplots.texSurveyEnd()}% + % + \pgfplotsapplistXXpushback{--- acquire from LUA! --}% +}% + +% this appears to be necessary for the mesh legend... +\def\b@pgfplots@LUA@visualization@enabled{0}% + +% PRECONDITION : \pgfplots@LUA@visualization@init has already been +% executed. +\def\pgfplots@LUA@visualization@of@current@plot{% + \def\b@pgfplots@LUA@visualization@enabled{0}% + \ifpgfplots@LUA@backend@supported + \pgfkeysgetvalue{/pgfplots/axis type}\pgfplots@loc@TMPa + \def\pgfplots@loc@TMPb{rectangle}% + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + \else + % disable visualizer - we cannot do this right now. + \pgfplots@LUA@backend@failed + \let\pgfplotsplothandlerLUAvisualizerfactory=\pgfutil@empty + \fi + % + \ifx\pgfplotsplothandlerLUAvisualizerfactory\pgfutil@empty + % hm. This plot cannot be visualized in LUA - BUT it has a + % LUA survey! Ok, then: acquire the survey results. + % Otherwise we would have nothing here. + % FIXME : what about \pgfplots@LUA@backend@failed in this context!? + \pgfplots@log{\pgfplots@LUA@loglevel@info}{Using 'lua backend=false' for visualization of plot \the\pgfplots@numplots\space (type '\pgfplotsplothandlername'): it has no LUA visualizer.}% + \expandafter\def\expandafter\pgfplots@stored@current@data\expandafter{% + \directlua{pgfplots.texGetSurveyedCoordsToPgfplots()}% + }% + \else + % visualize using LUA! ... and acquire the coordinates. + \expandafter\def\expandafter\pgfplots@stored@current@data\expandafter{% + \directlua{pgfplots.texVisualizePlot(\pgfplotsplothandlerLUAvisualizerfactory)}% + }% +%\message{plot \plotnum: LUA backend returned \pgfplots@stored@current@data^^J}% + % + % ... and ensure that the resulting + % \pgfplots@stored@current@data can be deserialized. It + % contains the fully mapped X/Y coordinates as first item. + \let\pgfplotsaxisdeserializedatapointfrom@private@nonLUA=\pgfplotsaxisdeserializedatapointfrom@private + \def\pgfplotsaxisdeserializedatapointfrom@private##1{% + \pgfplotsaxisdeserializedatapointfrom@private@LUA##1% + }% + \def\pgfplotsaxisdeserializedatapointfrom@private@LUA##1##2##3{% + \global\pgf@x=##1pt % + \global\pgf@y=##2pt % + \pgfplotsaxisdeserializedatapointfrom@private@nonLUA{##3}% + }% + % FIXME : do I need to adopt the serializer as well!? + % + \def\b@pgfplots@LUA@visualization@enabled{1}% + \fi + \fi +}% + +% Defines \pgfplotsretval to contain a comma-separated-list of +% visualization phase names. May be empty. +% +% These names will be stored as \pgfplots@visphase@names during the +% visualization phase. +% +% The role of "visualization phases" is to call the plot +% handler, and perhaps further visualization phases. +% +% This is entirely *independent* of plot marks which have their own, +% very special visualization phase. +% +% It is allowed if a plot has an empty list of visualization phases +% (common for 'only marks'). +% +% #1: any tikz path instructions after the \addplot command but before +% the semicolon. +\def\pgfplotssurveyphase@set@visphase@names#1{% + % 1. check if we need the 'default' visualization phase: + \pgfplots@getcurrent@plothandler\pgfplots@basiclevel@plothandler + \ifx\pgfplots@basiclevel@plothandler\pgfplothandlerdiscard + % Ah - "only marks". In this case, we rely on the (special) + % marker visualization phase - there is no need for a further + % phase. + \pgfplotsutil@trim{#1}% + \ifx\pgfplotsretval\pgfutil@empty + % OK, we do not have after-path instructions. + % No need for this phase. + \let\pgfplotsretval=\pgfutil@empty + \else + % Hm. We found after-path instructions! These *need* to be + % done during the standard visualization phase. Ok, then + % do it, even if it has no uses otherwise! + \let\pgfplotsretval=\pgfplotsaxis@visphase@name@default + \fi + \else + \let\pgfplotsretval=\pgfplotsaxis@visphase@name@default + \fi + % + % 2. error bar phase: + \ifpgfplots@errorbars@enabled + \ifx\pgfplotsretval\pgfutil@empty + \else + \edef\pgfplotsretval{\pgfplotsretval,}% + \fi + % + \edef\pgfplotsretval{\pgfplotsretval \pgfplotsaxis@visphase@name@errorbars}% + \fi + % + % markers have the special phase \pgfplots@markers@visphase@name . +}% + +\def\pgfplotsaxis@visphase@name@default{default} +\def\pgfplotsaxis@visphase@name@markers{markers} + +% This defines \pgfplots@visphase@default: +\expandafter\def\csname pgfplots@visphase@\pgfplotsaxis@visphase@name@default\endcsname{% + \pgfplots@coord@stream@finalize@storedcoords@START +}% + +% A routine which transforms the current set of +% \pgfplots@current@point@[xyz] values to the coordinate system +% accepted by the actual axis. +\def\pgfplotsaxistransformfromdatacs{% + \pgfkeyslet{/data point/x}\pgfplots@current@point@x + \pgfkeyslet{/data point/y}\pgfplots@current@point@y + \pgfkeyslet{/data point/z}\pgfplots@current@point@z + \pgfplotsaxistransformcs + {\pgfkeysvalueof{/pgfplots/data cs}} + {\pgfkeysvalueof{/pgfplots/@expected axis cs}}% + \pgfkeysgetvalue{/data point/x}\pgfplots@current@point@x + \pgfkeysgetvalue{/data point/y}\pgfplots@current@point@y + \pgfkeysgetvalue{/data point/z}\pgfplots@current@point@z +}% + +% Changes '/data point/[xyz]' to the new coordinate system +% (cs) designated by '#2'. +% +% #1: the actual coordinate system's name +% #2: the desired coordinate system's name +% +% PRECONDITION: '/data point/[xyz]' contain the current +% point's coordinates in the '#1' system. The z coordinate is ignored for 2d plots (or +% for coordinate systems which are inherently two-dimensional). +% +% POSTCONDITION: 'data point/[xyz]' contain same point as +% before, but represented in the '#2' system. +% +% The coordinate system transformations must be defined, +% see \pgfplotsdefinecstransform. +% +% Example: +% \pgfkeyssetvalue{/data point/x}{90} +% \pgfkeyssetvalue{/data point/y}{1} +% \pgfplotsaxistransformcs{polar}{cart} +% --> +% \pgfkeysvalueof{/data point/x}= 0 +% \pgfkeysvalueof{/data point/y}= 1 +\def\pgfplotsaxistransformcs#1#2{% + \edef\pgfplots@loc@TMPa{#1}% + \edef\pgfplots@loc@TMPb{#2}% + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + % nothing to do + \else + \pgfutil@ifundefined{pgfp@transform@\pgfplots@loc@TMPa @to@\pgfplots@loc@TMPb}{% + \pgfutil@ifundefined{pgfp@transform@\pgfplots@loc@TMPa @to@cart}{% + \pgfplotsaxistransformcs@error + }{% + \pgfplotsaxistransformcs{#1}{cart}% + \pgfplotsaxistransformcs{cart}{#2}% + }% + }{% + \csname pgfp@transform@\pgfplots@loc@TMPa @to@\pgfplots@loc@TMPb\endcsname + }% + \fi +}% + +% Defines a new coordinate transformation for use in +% \pgfplotsaxistransformcs. +% #1: the source coordinate system +% #2: the target coordinate system +% #3: the transformation code. +% +% @see \pgfplotsaxistransformcs for what #3 should do. +% +% This does also declare a coordinate system for use in 'data cs'. +% The minimal requirements are to define the transformations from and +% to "cart" (cartesian coordinates). +% +\def\pgfplotsdefinecstransform#1#2#3{% + \expandafter\def\csname pgfp@transform@#1@to@#2\endcsname{#3}% +}% + +\pgfplotsdefinecstransform{polar}{cart}{% + \pgfplotscoordmath{default}{parsenumber}{\pgfkeysvalueof{/data point/x}}% + \let\pgfplots@current@point@x=\pgfmathresult + \pgfplotscoordmath{default}{parsenumber}{\pgfkeysvalueof{/data point/y}}% + \let\pgfplots@current@point@y=\pgfmathresult + \pgfplotsmathpoltocart\pgfplots@current@point@x\pgfplots@current@point@y\pgfplots@current@point@x@\pgfplots@current@point@y@ + \pgfplotscoordmath{x}{parsenumber}{\pgfplots@current@point@x@}% + \pgfkeyslet{/data point/x}\pgfmathresult + \pgfplotscoordmath{y}{parsenumber}{\pgfplots@current@point@y@}% + \pgfkeyslet{/data point/y}\pgfmathresult +}% +\pgfplotsdefinecstransform{cart}{polar}{% + \pgfplotscoordmath{default}{parsenumber}{\pgfkeysvalueof{/data point/x}}% + \let\pgfplots@current@point@x=\pgfmathresult + \pgfplotscoordmath{default}{parsenumber}{\pgfkeysvalueof{/data point/y}}% + \let\pgfplots@current@point@y=\pgfmathresult + \pgfplotsmathcarttopol\pgfplots@current@point@x\pgfplots@current@point@y\pgfplots@current@point@x@\pgfplots@current@point@y@ + \pgfplotscoordmath{x}{parsenumber}{\pgfplots@current@point@x@}% + \pgfkeyslet{/data point/x}\pgfmathresult + \pgfplotscoordmath{y}{parsenumber}{\pgfplots@current@point@y@}% + \pgfkeyslet{/data point/y}\pgfmathresult +}% + +\pgfplotsdefinecstransform{polarrad}{polar}{% + \pgfplotsgetcoordmathfor{default}\let\pgfplots@coordmath@id=\pgfplotsretval + \pgfutil@ifundefined{pgfp@polarradscale@\pgfplots@coordmath@id}{% + \pgfplotscoordmath{default}{parsenumber}{57.2957795130823}% + \expandafter\global\expandafter\let\csname pgfp@polarradscale@\pgfplots@coordmath@id\endcsname=\pgfmathresult + }{}% + % + \pgfplotscoordmath{default}{parsenumber}{\pgfkeysvalueof{/data point/x}}% + \pgfplotscoordmath{default}{op}{multiply}{{\pgfmathresult}{\csname pgfp@polarradscale@\pgfplots@coordmath@id\endcsname}}% + \pgfkeyslet{/data point/x}\pgfmathresult +}% +\pgfplotsdefinecstransform{polar}{polarrad}{% + \pgfplotsgetcoordmathfor{default}\let\pgfplots@coordmath@id=\pgfplotsretval + \pgfutil@ifundefined{pgfp@polarradiscale@\pgfplots@coordmath@id}{% + \pgfplotscoordmath{default}{parsenumber}{0.0174532925199433}% + \expandafter\global\expandafter\let\csname pgfp@polarradiscale@\pgfplots@coordmath@id\endcsname=\pgfmathresult + }{}% + % + \pgfplotscoordmath{default}{parsenumber}{\pgfkeysvalueof{/data point/x}}% + \pgfplotscoordmath{default}{op}{multiply}{{\pgfmathresult}{\csname pgfp@polarradiscale@\pgfplots@coordmath@id\endcsname}}% +}% +\pgfplotsdefinecstransform{polarrad}{cart}{% + \pgfplotsaxistransformcs{polarrad}{polar}% + \pgfplotsaxistransformcs{polar}{cart}% +}% +\pgfplotsdefinecstransform{cart}{polarrad}{% + \pgfplotsaxistransformcs{cart}{polar}% + \pgfplotsaxistransformcs{polar}{polarrad}% +}% + +\def\pgfplotsaxistransformcs@error{% + \pgfplotsthrow{invalid argument}{\pgfplots@loc@TMPa}{Sorry, I do not know how to transform the coordinate system '\pgfplots@loc@TMPa' to '\pgfplots@loc@TMPb'. Maybe you misspelled the 'data cs'? Or perhaps the feature is not yet implemented?}\pgfeov% +}% + +% Takes the current point and serializes it into \pgfplotsretval. +% +% The serialization includes the coordinates (as returned by the +% current plot handler), the point meta, and any "visualization +% depends on" keys. +% +% See \pgfplotsaxisdeserializedatapointfrom +% +% POSTCONDITION: +% \pgfplotsretval contains everything that is needed to restore the +% current coordinate. This includes +% - the coordinate values for x,y, and z +% - any special coordinate values reported by the plot handler +% (like u,v,w for quiver plots) +% - the point meta +% - any 'visualization depends on' value +% - anything which is needed for other purposes (stacked plots have +% a plugin). +% +% The result has an EXTRA SET OF BRACES which needs to be dealt with. +% +% Example: +% \pgfplotsaxisserializedatapointtostring +% +% \expandafter\pgfplotsaxisdeserializedatapointfrom\pgfplotsretval +% +% -> note the absence of extra braces for the deserialization! +\def\pgfplotsaxisserializedatapointtostring{% + \pgfplotsplothandlerserializepointto\pgfplotsaxisserializedatapoint@val + \pgfplotsaxisserializedatapoint@private + \t@pgfplots@toka=\expandafter{\pgfplotsaxisserializedatapoint@val}% + \t@pgfplots@tokb=\expandafter{\pgfplotsretval}% + \edef\pgfplotsretval{{\the\t@pgfplots@tokb;\the\t@pgfplots@toka}}% +}% + +\def\pgfplotsaxisserializedatapoint{% + \pgfplotsaxisserializedatapointtostring + \expandafter\pgfplotsapplistXXpushback\expandafter{\pgfplotsretval}% +}% +\def\pgfplotsaxisserializedatapoint@private{% + \let\pgfplotsretval=\pgfplots@current@point@meta +}% +\def\pgfplotsaxisdeserializedatapointfrom@private#1{% + \def\pgfplots@current@point@meta{#1}% +}% +% Restores the variables serialized in '#1'. +% +% As a side--effect, the macro +% \pgfplotsaxisdeserializedatapointfrom@private@lastvalue will contain +% the serialized part which is specific to pgfplots (i.e. the private +% parts which can be read with +% \pgfplotsaxisdeserializedatapointfrom@private) +\def\pgfplotsaxisdeserializedatapointfrom#1{% + \expandafter\pgfplotsaxisdeserializedatapointfrom@#1\pgfplots@EOI +}% +\def\pgfplotsaxisdeserializedatapointfrom@#1;#2\pgfplots@EOI{% + \def\pgfplotsaxisdeserializedatapointfrom@private@lastvalue{#1}% + \pgfplotsaxisdeserializedatapointfrom@private{#1}% + \pgfplotsplothandlerdeserializepointfrom{#2}% +}% + +% Handle User-defined parts which should be serialized as well. +% This preparation tool should be called at the start of both, survey +% and visualization phase. +% +% @PRECONDITION +% - the macros +% \pgfplotsaxisserializedatapoint@private +% \pgfplotsaxisdeserializedatapointfrom@private +% are known and valid. +% - '/pgfplots/visualization depends on' contains its correct value. +% +% @POSTCONDITION +% Both, +% \pgfplotsaxisserializedatapoint@private +% and +% \pgfplotsaxisdeserializedatapointfrom@private +% have been patched to incorporate the '/pgfplots/visualization +% depends on' feature. +% +\def\pgfplots@prepare@visualization@dependencies{% + \pgfkeysgetvalue{/pgfplots/visualization depends on/list}\pgfplots@loc@TMPa + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + % SERIALIZATION format: + % visualization depends on={{value1}\as \macro1, {<value2>}\as \macro2,...} + % -> + % {<original private data>}<\macro1>{<value1>}<\macro2>{<value2>}...<\macroN>{<valueN>} + % + % prepare + % \t@pgfplots@tokb={<\macro1>{<value1>}<\macro2>{<value2>}...<\macroN>{<valueN>}} + \t@pgfplots@tokb={}% + % + % prepare + % \t@pgfplots@tokc={<\macro1><\macro2><\macro3>...} + \t@pgfplots@tokc={}% + \expandafter\pgfplotsutilforeachcommasep\expandafter{\pgfplots@loc@TMPa}\as\pgfplots@loc@TMPa{% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \expandafter\pgfplots@prepare@visualization@depends@on\pgfplots@loc@TMPa\pgfplots@EOI% + \fi + }% + % Step 1: modify the SERIALIZATION method: + \t@pgfplots@toka=\expandafter{\pgfplotsaxisserializedatapoint@private}% + \edef\pgfplotsaxisserializedatapoint@private{% + \the\t@pgfplots@tokc + \the\t@pgfplots@toka + % nothing is expanded here, only \t@pgfplots@tokb + \noexpand\t@pgfplots@toka=\noexpand\expandafter{\noexpand\pgfplotsretval}% + \noexpand\edef\noexpand\pgfplotsretval{{\noexpand\the\t@pgfplots@toka},\the\t@pgfplots@tokb}% + }% + % Step 2: modify the DESERIALIZATION method: + \let\pgfplotsaxisdeserializedatapointfrom@private@orig=\pgfplotsaxisdeserializedatapointfrom@private + \let\pgfplotsaxisdeserializedatapointfrom@private=\pgfplotsaxisdeserializedatapointfrom@private@withdeplist + \fi + % + \pgfkeysgetvalue{/pgfplots/execute for finished point}\pgfplots@loc@TMPa + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \expandafter\def\expandafter\pgfplotsaxisserializedatapoint@private\expandafter{% + \pgfplotsaxisserializedatapoint@private + \pgfkeysvalueof{/pgfplots/execute for finished point}% + }% + \fi +}% +\def\pgfplots@prepare@visualization@depends@on#1\pgfplots@EOI{% + \pgfutil@in@\as{#1}% + \ifpgfutil@in@ + % ok, we have the '<content>\as<\macro>' syntax: + \pgfplots@prepare@visualization@depends@on@#1\pgfplots@EOI + \else + \pgfplots@prepare@visualization@depends@on@preparetype@checkvalue#1value\pgfplots@EOI + \ifpgfutil@in@ + % ok, then it should be 'value <\macro>'. + % extract the <\macro>: + \def\pgfplots@loc@TMPa value{\pgfplots@loc@TMPb}% + \def\pgfplots@loc@TMPb##1{\pgfplots@loc@TMPc ##1}% this step should remove leading white spaces + \def\pgfplots@loc@TMPc##1\pgfplots@EOI{% + % sanitize: check if ##1 is a defined macro: + \begingroup + \escapechar=-1 + \xdef\pgfplots@glob@TMPa{\string##1}% + \endgroup + \pgfutil@ifundefined{\pgfplots@glob@TMPa}{% + \begingroup + \t@pgfplots@toka={##1}% + \pgfplotsthrow{invalid argument} + {\pgfplots@loc@TMPa}% + {Sorry, `visualization depends on=value <\string\macro>' expected a defined control sequence name instead of `\the\t@pgfplots@toka'. Please make sure `\the\t@pgfplots@toka' is a properly defined macro or use the `visualization depends on=value <content> \string\as <\string\macro>' syntax instead}% + \pgfeov + \endgroup + }{% + \def\pgfplots@loc@TMPa{% + \pgfplots@prepare@visualization@depends@on@ value}% + \expandafter\pgfplots@loc@TMPa##1\as##1\pgfplots@EOI + }% + }% + \pgfplots@loc@TMPa#1\pgfplots@EOI + \else + % then, I expect '<\macro>'. + % sanitize: check if #1 is a defined macro: + \begingroup + \escapechar=-1 + \xdef\pgfplots@glob@TMPa{\string#1}% + \endgroup + \pgfutil@ifundefined{\pgfplots@glob@TMPa}{% + \begingroup + \t@pgfplots@toka={#1}% + \pgfplotsthrow{invalid argument} + {\pgfplots@loc@TMPa}% + {Sorry, `visualization depends on' expected a defined control sequence name instead of `\the\t@pgfplots@toka'. Please make sure `\the\t@pgfplots@toka' is a properly defined macro or use the `visualization depends on=<expression> \string\as <\string\macro>' syntax instead}% + \pgfeov + \endgroup + }{% + \expandafter\pgfplots@prepare@visualization@depends@on@#1\as#1\pgfplots@EOI + }% + \fi + \fi +}% +\def\pgfplots@prepare@visualization@depends@on@#1\as#2\pgfplots@EOI{% + \pgfplots@prepare@visualization@depends@on@preparetype{#1}\as{#2}% + % prepare the serialization: + \t@pgfplots@tokb=\expandafter{\the\t@pgfplots@tokb\noexpand#2{\csname\string#2@value\endcsname}}% + \t@pgfplots@tokc=\expandafter{\the\t@pgfplots@tokc\csname assign@\string#2\endcsname}% +}% + +% task: define a macro '\csname assign@\string#2\endcsname' which, when executed, +% defines \csname\string#2@value\endcsname such that it expands +% to a the correct value. +\def\pgfplots@prepare@visualization@depends@on@preparetype#1\as#2{% + \pgfplots@prepare@visualization@depends@on@preparetype@checkvalue#1value\pgfplots@EOI + \ifpgfutil@in@ + \pgfplots@prepare@visualization@depends@on@preparetype@value#1\as{#2}% no braces here. + \else + \pgfplots@prepare@visualization@depends@on@preparetype@expr{#1}\as{#2}% + \fi +}% +\def\pgfplots@prepare@visualization@depends@on@preparetype@expr#1\as#2{% + \pgflibraryfpuifactive{% + \expandafter\def\csname assign@\string#2\endcsname{% + \pgfmathparse{#1}% + \pgfmathfloattofixed{\pgfmathresult}% + \expandafter\let\csname \string#2@value\endcsname=\pgfmathresult + }% + }{% + \expandafter\def\csname assign@\string#2\endcsname{% + \pgfmathparse{#1}% + \expandafter\let\csname \string#2@value\endcsname=\pgfmathresult + }% + }% +} +\def\pgfplots@prepare@visualization@depends@on@preparetype@checkvalue#1value#2\pgfplots@EOI{% + \def\pgfplots@loc@TMPa{#1}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \pgfutil@in@true + \else + \pgfutil@in@false + \fi +}% +\def\pgfplots@prepare@visualization@depends@on@preparetype@value value#1\as#2{% + % remove spaces from #1: + \pgfkeys@spdef\pgfplots@loc@TMPa{#1}% + % + % ok, prepare the value. + \def\pgfplots@loc@TMPb{#2}% + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + % oh - a special case! We have value\macro\as\macro. + \expandafter\def\csname\string#2@value\endcsname{#2}% + % + % this is special; we do not need to EXECUTE assign@\string#2 to arrive at its value. + % But we need to define #2@value as that will be stored. + \expandafter\let\csname assign@\string#2\endcsname=\relax + \else + \begingroup + \t@pgfplots@toka=\expandafter{\pgfplots@loc@TMPa}% + \t@pgfplots@tokb=\expandafter{\csname\string#2@value\endcsname}% + \xdef\pgfplots@glob@TMPa{% + \noexpand\def\the\t@pgfplots@tokb{\the\t@pgfplots@toka}% + }% + \endgroup + \expandafter\let\csname assign@\string#2\endcsname=\pgfplots@glob@TMPa + \fi +} + +\def\pgfplotsaxisdeserializedatapointfrom@private@withdeplist#1{% + \pgfplotsaxisdeserializedatapointfrom@private@withdeplist@#1\pgfplots@EOI +}% +\def\pgfplotsaxisdeserializedatapointfrom@private@withdeplist@#1,{% + \pgfplotsaxisdeserializedatapointfrom@private@orig{#1}% + \pgfplotsaxisdeserializedatapointfrom@private@withdeplist@@ +}% +\def\pgfplotsaxisdeserializedatapointfrom@private@withdeplist@@#1{% + \def\pgfplots@loc@TMPa{#1}% + \ifx\pgfplots@loc@TMPa\pgfplots@EOI + \else + \afterassignment\pgfplotsaxisdeserializedatapointfrom@private@withdeplist@@ + \expandafter\def\expandafter#1% + \fi +}% + +% PRECONDITION: must be called inside of +% \pgfplots@PREPARE@COORD@STREAM@end@. +% +% POSTCONDITION: +% assigns '/pgfplots/#1 coord sorting=[+-]' +% i.e. whether #1 (x or y or z) coordinates are in ascending (+) ordering or in +% descending order (-). +\def\pgfplots@PREPARE@COORD@STREAM@end@determinecoordsorting#1{% + \pgfplotscoordmath{#1}{if less than} + {\csname pgfplots@currentplot@firstcoord@#1\endcsname}% + {\csname pgfplots@currentplot@lastcoord@#1\endcsname}% + {\pgfkeyssetvalue{/pgfplots/#1 coord sorting}{+}}% + {\pgfkeyssetvalue{/pgfplots/#1 coord sorting}{-}}% +}% + +% Defines the linear transformation macro \pgfplots@perpointmeta@trafo, +% +% phi : [meta_min,meta,max] -> [0,10^k] +% +% which operates on the per-point meta data (if any). +% The trafo will be skipped if there is no such data. +% +% The trafo is expected to prepare meta information before it is used +% as input to \pgfplotscolormapaccess (or +% \pgfplotscolormapdefinemappedcolor). Thus, the 10^k is chosen to be +% the same as \pgfplotscolormaprange (which is 1000 per default). +% +% If there is no data range (for example because meta information is +% not available or is not of numeric type), the trafo will simply +% copy the input argument symbolically. +% +% Note: it does not hurt to call it multiple times. It checks automatically whether it already is up-to-date. +\def\pgfplots@perpointmeta@preparetrafo{% + \def\pgfplotspointmetarangeexponent{1}% pre-fill + \pgfutil@ifundefined{pgfplots@perpointmeta@trafo}{% + \edef\pgfplots@loc@TMPa{\pgfplotscolormaprange}% + \ifnum\pgfplots@loc@TMPa=1000 + \else + \pgfplots@error{LOGIC ERROR: sorry, I have hard-coded the assumption \string\pgfplotscolormaprange = 1000, but now it is \pgfplots@loc@TMPa.}% + \fi + % + \let\pgfplots@current@point@meta=\pgfutil@empty + \pgfutil@ifundefined{pgfplots@metamax}{\let\pgfplots@metamax=\pgfutil@empty}{} + \ifpgfplots@warn@for@filter@discards + \global\let\pgfplots@perpointmeta@unboundedwarning@stop=\relax + \def\pgfplots@perpointmeta@unboundedwarning##1{% + \ifx\pgfplots@perpointmeta@unboundedwarning@stop\relax + \begingroup + \pgfplotscoordmath{meta}{tostring}{##1}% + \pgfplotswarning{point meta unbounded}{\pgfmathresult}{##1}\pgfeov + \endgroup + \gdef\pgfplots@perpointmeta@unboundedwarning@stop{1}% + \fi + }% + \else + \def\pgfplots@perpointmeta@unboundedwarning##1{}% + \fi + \if m\pgfplots@colormap@access + % colormap access=map + \ifx\pgfplots@metamax\pgfutil@empty + \def\pgfplots@perpointmeta@trafo##1{% + \pgfplotscoordmath{meta}{if is}{##1}{u} + {% + \def\pgfmathresult{0}% + \pgfplots@perpointmeta@unboundedwarning{##1}% + }{% + \pgfplotscoordmath{meta}{tofixed}{##1}% + }% + }% + \def\pgfplots@perpointmeta@traforange{0:1000}% + \edef\pgfplotspointmetarange{0:1000}% + \else + % The transformation is + % + % phi(m) = ( m- meta_min) * 1000/ (meta_max-meta_min). + % + % -> precompute the scaling factor! + \if\pgfplots@perpointmeta@rel@choice0% + % point meta rel=axis wide: + \pgfplots@perpointmeta@preparetrafo@initfrom{pgfplots@axiswide@}% + \else + \pgfplots@perpointmeta@preparetrafo@initfrom{pgfplots@}% + \fi + \fi + \else + % colormap access=direct + \def\pgfplots@perpointmeta@trafo##1{% + \pgfplotscoordmath{meta}{if is}{##1}{u}{% + \def\pgfmathresult{0}% + \pgfplots@perpointmeta@unboundedwarning{##1}% + }{% + \pgfplotscoordmath{meta}{tofixed}{##1}% + }% + }% + \def\pgfplots@perpointmeta@traforange{0:0}% + \edef\pgfplotspointmetarange{\pgfplots@metamin:\pgfplots@metamax}% + \fi + \edef\pgfplotspointmetatransformedrange{\pgfplots@perpointmeta@traforange}% + }{}% +}% + +% Employs \csname #1metamin\endcsname and its metamax counterpart to +% initialize the trafo. +% +% This unifies the approaches for \pgfplots@axiswide@metamax and +% \pgfplots@metamax. +\def\pgfplots@perpointmeta@preparetrafo@initfrom#1{% + \edef\pgfplotspointmetarange{\csname #1metamin\endcsname:\csname #1metamax\endcsname}% + % Now, prepare the trafo as such. + % It assigns \pgfmathresult (in fixed point). + \ifpgfplots@LUA@backend@supported + \def\pgfplots@perpointmeta@trafo##1{% + \edef\pgfmathresult{% + \directlua{% + pgfplots.texPerpointMetaTrafo("\pgfplots@current@point@meta") + }% + }% + }% + \else + \def\pgfplots@perpointmeta@trafo##1{% + \pgfplotscoordmath{meta}{if is}{##1}{u}{% + \def\pgfmathresult{0}% + \pgfplots@perpointmeta@unboundedwarning{##1}% + }{% + \pgfplotscoordmath{meta}{op}{subtract}{{##1}{\csname #1metamin\endcsname}}% + \pgfplotscoordmath{meta}{op}{multiply}{{\pgfmathresult}{\pgfplots@perpointmeta@trafo@factor}}% + \pgfplots@perpointmeta@trafo@clipresult + \pgfplotscoordmath{meta}{tofixed}{\pgfmathresult}% + }% + }% + \pgfplotscoordmath{meta}{op}{subtract}{{\csname #1metamax\endcsname}{\csname #1metamin\endcsname}}% + \let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotscoordmath{meta}{zero}% + \let\pgfplots@perpointmeta@lowerrange=\pgfmathresult + \pgfplotscoordmath{meta}{parsenumber}{1000}% + \let\pgfplots@perpointmeta@upperrange=\pgfmathresult + \pgfplotscoordmath{meta}{op}{divide}{{\pgfmathresult}{\pgfplots@loc@TMPa}}% + \let\pgfplots@perpointmeta@trafo@factor=\pgfmathresult + \fi + % + % Expands to the transformation range as 'a:b': + \def\pgfplots@perpointmeta@traforange{0:1000}% + % + \expandafter\let\expandafter\pgfplots@loc@TMPa\csname #1metamax\endcsname + \pgfplotscoordmath{meta}{tostring}{\pgfplots@loc@TMPa}% + \pgfmathfloatparsenumber\pgfmathresult + \pgfmathfloatgetexponent\pgfmathresult\c@pgf@countd + \edef\pgfplotspointmetarangeexponent{\the\c@pgf@countd}% +} + +\def\pgfplots@perpointmeta@trafo@clipresult{% + \let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotscoordmath{meta}{if less than}{\pgfplots@loc@TMPa}{\pgfplots@perpointmeta@upperrange}{% + \pgfplotscoordmath{meta}{if less than}{\pgfplots@loc@TMPa}{\pgfplots@perpointmeta@lowerrange}{% + \let\pgfmathresult=\pgfplots@perpointmeta@lowerrange + }{% + \let\pgfmathresult=\pgfplots@loc@TMPa + }% + }{% + \let\pgfmathresult=\pgfplots@perpointmeta@upperrange + }% +}% + +% define it globally - this simplifies some mesh plots. +\pgfplotscoordmath{meta}{one}% +\let\pgfplotspointmeta=\pgfmathresult +\def\pgfplotspointmetatransformed{1000}% use the maximum because it is usually divided by 1000 + +% A command which is readily available during the visualization phase of each plot. +% +% It takes existing point meta data and transforms it, i.e. it defines +% \pgfplotspointmetatransformed. +% +% The command won't be invoked automatically, it is task of a plot +% handler to decide if it is needed. It's application is relatively +% fast, however. +% +% PRECONDITION: +% - point meta has been set up during the survey phase (i.e. the +% /pgfplots/point meta!=none), +% - there *is* point meta data for the current data point. +% +% POSTCONDITION: +% - the macros \pgfplotspointmeta and \pgfplotspointmetatransformed +% are defined. +% +% @see also \pgfplotsaxisifhaspointmeta +\def\pgfplotsaxisvisphasetransformpointmeta{% + \if1\csname pgfpmeta@\pgfplotspointmetainputhandler @issymbolic\endcsname + % symbolic point meta may be empty. + \let\pgfplotspointmeta=\pgfplots@current@point@meta + \let\pgfplotspointmetatransformed=\pgfplotspointmeta + \else + % numeric point meta may NOT be empty. + \ifx\pgfplots@current@point@meta\pgfutil@empty% + \pgfplots@error{could not access the 'point meta' (used for example by scatter plots and color maps). Maybe you need to add '\string\addplot[point meta=y]' or something like that?}% + \pgfplotscoordmath{meta}{one}% + \let\pgfplotspointmeta=\pgfmathresult + \def\pgfplotspointmetatransformed{1.0}% + \else + % prepare arguments: + \let\pgfplotspointmeta=\pgfplots@current@point@meta + \pgfplots@perpointmeta@trafo{\pgfplotspointmeta}% + \let\pgfplotspointmetatransformed=\pgfmathresult + \fi + \fi +}% + +\def\pgfplotsaxisvisphasetransformpointmetaifany{% + \pgfplotsaxisifhaspointmeta{\pgfplotsaxisvisphasetransformpointmeta}{}% +} + +% A looping method which applies +% \pgfplots@coord@stream@start +% for each coordinate '(x,y)' or '(x,y) +- (ex,ey)', +% assign \pgfplots@current@point@[xyz] +% assign \pgfplots@current@point@[xyz]@error (if in argument list) +% assign \pgfplots@current@point@meta +% call \pgfplots@coord@stream@coord +% \pgfplots@coord@stream@end +% +% #1 a sequence of coordinates of the form +% '(x,y)' or '(x,y,z)' +% or +% '(x,y[,z]) +- (ex,ey)' +% or +% '(x,y[,z]) += (ex+,ey+) -= (ex-,ey-)' +% or +% '(x,y) [meta]' +% or +% '(x,y) +- (ex,ey) [meta]' +% separated by white-space. +% +\long\def\pgfplots@coord@stream@foreach#1{% + \pgfplots@coord@stream@start + \pgfplotsscanlinelengthinitzero + \pgfplots@foreach@plot@coord@ITERATE#1\pgfplots@EOI% + \pgfplotsscanlinelengthcleanup + \pgfplots@coord@stream@end +}% + +\begingroup +\def\\{\global\let\pgfplots@let@space@token= } \\ % now, \pgfplots@let@space@token is a space token +\endgroup + + +% A looping command to loop through plot coordinates. +% For every point, \pgfplots@coord@stream@coord will be invoked. +% +% No scoping is used during this operation, so you can access outer +% variables. +\def\pgfplots@foreach@plot@coord@ITERATE{% + \futurelet\pgfplots@foreach@plot@coord@ITERATE@tok\pgfplots@foreach@plot@coord@ITERATE@ +}% +\long\def\pgfplots@foreach@plot@coord@ITERATE@#1{% + \ifx\pgfplots@foreach@plot@coord@ITERATE@tok(% + \pgfplotsscanlinelengthincrease + \let\pgfplots@loop@next=\pgfplots@foreach@plot@coord@NEXT% + \else + \ifx\pgfplots@foreach@plot@coord@ITERATE@tok\pgfplots@let@space@token + \def\pgfplots@loop@next{\pgfplots@foreach@plot@coord@ITERATE#1}% + \else + \ifx\pgfplots@foreach@plot@coord@ITERATE@tok\pgfplots@EOI + % ok, do nothing more + \let\pgfplots@loop@next=\relax + \else + \ifx\pgfplots@foreach@plot@coord@ITERATE@tok\par + \pgfplotsscanlinecomplete + \let\pgfplots@loop@next=\pgfplots@foreach@plot@coord@ITERATE + \else + \if\noexpand\pgfplots@foreach@plot@coord@ITERATE@tok\noexpand\anymacro + % Ah. #1 has the same character (!) code as \anymacro, + % that means it is a macro! Expand it: + \def\pgfplots@loop@next{\expandafter\pgfplots@foreach@plot@coord@ITERATE#1}% + \else + \def\pgfplots@loop@next{\pgfplots@foreach@plot@coord@error#1}% + \fi + \fi + \fi + \fi + \fi + \pgfplots@loop@next +} + +\long\def\pgfplots@foreach@plot@coord@error#1\pgfplots@EOI{% + \def\pgfplots@loc@TMPa{#1}% + \pgfplots@command@to@string\pgfplots@loc@TMPa\pgfplots@loc@TMPa + \pgfplots@error{Sorry, I could not read the plot coordinates near '\pgfplots@loc@TMPa'. Please check for format mistakes}% +}% +\def\pgfplots@foreach@plot@coord@NEXT#1,#2){% + \ifpgfplots@plot@coords@mathparser + \pgfmathparse{#1}\let\pgfplots@current@point@x=\pgfmathresult + \pgfmathparse{#2}\let\pgfplots@current@point@y=\pgfmathresult + \else + \def\pgfplots@current@point@x{#1}% + \def\pgfplots@current@point@y{#2}% + \fi + \let\pgfplots@current@point@error@x@plus=\pgfutil@empty + \let\pgfplots@current@point@error@x@minus=\pgfutil@empty + \let\pgfplots@current@point@error@y@plus=\pgfutil@empty + \let\pgfplots@current@point@error@y@minus=\pgfutil@empty + \let\pgfplots@current@point@meta=\pgfutil@empty + \pgfplots@foreach@plot@coord@NEXT@cont +} +\def\pgfplots@foreach@plot@coord@NEXT@cont{% + \pgfutil@ifnextchar+{% + \pgfplots@foreach@plot@coord@NEXT@plus% + }{% + \pgfutil@ifnextchar-{% + \pgfplots@foreach@plot@coord@NEXT@minus% + }{% + \pgfutil@ifnextchar[{% + \pgfplots@foreach@plot@coord@NEXT@meta + }{% + \pgfplots@coord@stream@coord + \pgfplots@foreach@plot@coord@ITERATE + }% + }% + }% +} +\def\pgfplots@foreach@plot@coord@NEXT@meta[#1]{% + \def\pgfplots@current@point@meta{#1}% + \pgfplots@coord@stream@coord + \pgfplots@foreach@plot@coord@ITERATE +}% +\def\pgfplots@foreach@plot@coord@NEXT@plus+{% + \pgfutil@ifnextchar={% + \pgfplots@foreach@plot@coord@NEXT@pluseq% + }{% + \pgfplots@foreach@plot@coord@NEXT@plusminus% + }% +} +\def\pgfplots@foreach@plot@coord@NEXT@minus-=#1({% + \def\pgfplots@foreach@plot@coord@state{-}% + \pgfplots@foreach@plot@coord@NEXT@WITH@ERRORRANGE@ +} +\def\pgfplots@foreach@plot@coord@NEXT@pluseq=#1({% + \def\pgfplots@foreach@plot@coord@state{+}% + \pgfplots@foreach@plot@coord@NEXT@WITH@ERRORRANGE@ +} +\def\pgfplots@foreach@plot@coord@NEXT@plusminus-#1({% + \def\pgfplots@foreach@plot@coord@state{B}% + \pgfplots@foreach@plot@coord@NEXT@WITH@ERRORRANGE@ +} + +% processing something like '(x,y) +- (error_x,error_y)' +\def\pgfplots@foreach@plot@coord@NEXT@WITH@ERRORRANGE@#1,#2){% + \ifpgfplots@plot@coords@mathparser + \pgfmathparse{#1}% + \let\pgfplots@loc@TMPb=\pgfmathresult + \pgfmathparse{#2}% + \let\pgfplots@loc@TMPc=\pgfmathresult + \else + \def\pgfplots@loc@TMPb{#1}% + \def\pgfplots@loc@TMPc{#2}% + \fi + % + \if +\pgfplots@foreach@plot@coord@state + % ah, it was a "+=" item: + \let\pgfplots@current@point@error@x@plus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@y@plus=\pgfplots@loc@TMPc + \else + \if -\pgfplots@foreach@plot@coord@state + % ah, it was a "-=" item: + \let\pgfplots@current@point@error@x@minus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@y@minus=\pgfplots@loc@TMPc + \else + % ah, it was a "+-" item: + \let\pgfplots@current@point@error@x@plus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@x@minus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@y@plus=\pgfplots@loc@TMPc + \let\pgfplots@current@point@error@y@minus=\pgfplots@loc@TMPc + \fi + \fi + % + \pgfplots@foreach@plot@coord@NEXT@cont +} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5 +% The same for three dim coords: +\long\def\pgfplots@coord@stream@foreach@threedim#1{% + \pgfplots@coord@stream@start + \pgfplotsscanlinelengthinitzero + \pgfplots@foreach@plot@coord@threedim@ITERATE#1\pgfplots@EOI% + \pgfplotsscanlinelengthcleanup + \pgfplots@coord@stream@end +}% +\def\pgfplots@foreach@plot@coord@threedim@ITERATE{% + \futurelet\pgfplots@foreach@plot@coord@threedim@ITERATE@tok\pgfplots@foreach@plot@coord@threedim@ITERATE@ +}% +\long\def\pgfplots@foreach@plot@coord@threedim@ITERATE@#1{% + \ifx\pgfplots@foreach@plot@coord@threedim@ITERATE@tok(% + \pgfplotsscanlinelengthincrease + \let\pgfplots@loop@next=\pgfplots@foreach@plot@coord@threedim@NEXT% + \else + \ifx\pgfplots@foreach@plot@coord@threedim@ITERATE@tok\pgfplots@let@space@token + \def\pgfplots@loop@next{\pgfplots@foreach@plot@coord@threedim@ITERATE#1}% + \else + \ifx\pgfplots@foreach@plot@coord@threedim@ITERATE@tok\pgfplots@EOI + % ok, do nothing more + \let\pgfplots@loop@next=\relax + \else + \ifx\pgfplots@foreach@plot@coord@threedim@ITERATE@tok\par + \pgfplotsscanlinecomplete + \let\pgfplots@loop@next=\pgfplots@foreach@plot@coord@threedim@ITERATE + \else + \if\noexpand\pgfplots@foreach@plot@coord@threedim@ITERATE@tok\noexpand\anymacro + % Ah. #1 has the same character (!) code as \anymacro, + % that means it is a macro! Expand it: + \def\pgfplots@loop@next{\expandafter\pgfplots@foreach@plot@coord@threedim@ITERATE#1}% + \else + \def\pgfplots@loop@next{\pgfplots@foreach@plot@coord@error#1}% + \fi + \fi + \fi + \fi + \fi + \pgfplots@loop@next +} +\def\pgfplots@foreach@plot@coord@threedim@NEXT#1,#2,#3){ + \ifpgfplots@plot@coords@mathparser + \pgfmathparse{#1}\let\pgfplots@current@point@x=\pgfmathresult + \pgfmathparse{#2}\let\pgfplots@current@point@y=\pgfmathresult + \pgfmathparse{#3}\let\pgfplots@current@point@z=\pgfmathresult + \else + \def\pgfplots@current@point@x{#1}% + \def\pgfplots@current@point@y{#2}% + \def\pgfplots@current@point@z{#3}% + \fi + \let\pgfplots@current@point@error@x@plus=\pgfutil@empty + \let\pgfplots@current@point@error@x@minus=\pgfutil@empty + \let\pgfplots@current@point@error@y@plus=\pgfutil@empty + \let\pgfplots@current@point@error@y@minus=\pgfutil@empty + \let\pgfplots@current@point@error@z@plus=\pgfutil@empty + \let\pgfplots@current@point@error@z@minus=\pgfutil@empty + % + \let\pgfplots@current@point@meta=\pgfutil@empty + % + \pgfplots@foreach@plot@coord@threedim@NEXT@cont +} +\def\pgfplots@foreach@plot@coord@threedim@NEXT@cont{% + \pgfutil@ifnextchar+{% + \pgfplots@foreach@plot@coord@threedim@NEXT@plus% + }{% + \pgfutil@ifnextchar-{% + \pgfplots@foreach@plot@coord@threedim@NEXT@minus% + }{% + \pgfutil@ifnextchar[{% + \pgfplots@foreach@plot@coord@threedim@NEXT@meta + }{% + \pgfplots@coord@stream@coord + \pgfplots@foreach@plot@coord@threedim@ITERATE + }% + }% + }% +} +\def\pgfplots@foreach@plot@coord@threedim@NEXT@meta[#1]{% + \def\pgfplots@current@point@meta{#1}% + \pgfplots@coord@stream@coord + \pgfplots@foreach@plot@coord@threedim@ITERATE +}% + +\def\pgfplots@foreach@plot@coord@threedim@NEXT@plus+{% + \pgfutil@ifnextchar={% + \pgfplots@foreach@plot@coord@threedim@NEXT@pluseq% + }{% + \pgfplots@foreach@plot@coord@threedim@NEXT@plusminus% + }% +} +\def\pgfplots@foreach@plot@coord@threedim@NEXT@minus-=#1({% + \def\pgfplots@foreach@plot@coord@state{-}% + \pgfplots@foreach@plot@coord@threedim@NEXT@WITH@ERRORRANGE@ +} +\def\pgfplots@foreach@plot@coord@threedim@NEXT@pluseq=#1({% + \def\pgfplots@foreach@plot@coord@state{+}% + \pgfplots@foreach@plot@coord@threedim@NEXT@WITH@ERRORRANGE@ +} +\def\pgfplots@foreach@plot@coord@threedim@NEXT@plusminus-#1({% + \def\pgfplots@foreach@plot@coord@state{B}% + \pgfplots@foreach@plot@coord@threedim@NEXT@WITH@ERRORRANGE@ +} +% processing something like '(x,y) +- (error_x,error_y)' +\def\pgfplots@foreach@plot@coord@threedim@NEXT@WITH@ERRORRANGE@#1,#2,#3){% + \ifpgfplots@plot@coords@mathparser + \pgfmathparse{#1}\let\pgfplots@loc@TMPb=\pgfmathresult + \pgfmathparse{#2}\let\pgfplots@loc@TMPc=\pgfmathresult + \pgfmathparse{#3}\let\pgfplots@loc@TMPd=\pgfmathresult + \else + \def\pgfplots@loc@TMPb{#1}% + \def\pgfplots@loc@TMPc{#2}% + \def\pgfplots@loc@TMPd{#3}% + \fi + % + \if +\pgfplots@foreach@plot@coord@state + % ah, it was a "+=" item: + \let\pgfplots@current@point@error@x@plus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@y@plus=\pgfplots@loc@TMPc + \let\pgfplots@current@point@error@z@plus=\pgfplots@loc@TMPd + \else + \if -\pgfplots@foreach@plot@coord@state + % ah, it was a "-=" item: + \let\pgfplots@current@point@error@x@minus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@y@minus=\pgfplots@loc@TMPc + \let\pgfplots@current@point@error@z@minus=\pgfplots@loc@TMPd + \else + % ah, it was a "+-" item: + \let\pgfplots@current@point@error@x@plus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@x@minus=\pgfplots@loc@TMPb + \let\pgfplots@current@point@error@y@plus=\pgfplots@loc@TMPc + \let\pgfplots@current@point@error@y@minus=\pgfplots@loc@TMPc + \let\pgfplots@current@point@error@z@plus=\pgfplots@loc@TMPd + \let\pgfplots@current@point@error@z@minus=\pgfplots@loc@TMPd + \fi + \fi + % + \pgfplots@foreach@plot@coord@threedim@NEXT@cont +} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5 +% +% A coordinate stream which works like this: +% +% ------------- +% \pgfplots@coord@stream@start +% +% foreach encoded coordinate: +% \def\pgfplots@coord@stream@foreach@NORMALIZED@curencoded{<encoded data>}% +% \def\pgfplots@coord@stream@foreach@NORMALIZED@curencoded@braced{{<encoded data>}}% note the extra braces. +% \pgfplotsaxisdeserializedatapointfrom{<encoded data>} +% \pgfplots@coord@stream@coord +% +% \pgfplots@coord@stream@end +% ------------- +% +% The format of #1 is +% {<datapoint>}{<datapoint>}...{<datapoint>} +% Each data point is decoded with +% \pgfplotsaxisserializedatapoint +% and then, \pgfplots@coord@stream@coord will be called. +\long\def\pgfplots@coord@stream@foreach@NORMALIZED#1{% + \pgfplots@coord@stream@start + \pgfplotscoordstream@firstlast@init + \pgfplots@foreach@plot@coord@NORMALIZED@ITERATE#1\pgfplots@EOI% + \pgfplots@coord@stream@end +}% +% No scoping is used during this operation, so you can access outer +% variables. +\def\pgfplots@foreach@plot@coord@NORMALIZED@ITERATE#1{% + \def\pgfplots@coord@stream@foreach@NORMALIZED@curencoded{#1}% + \ifx\pgfplots@coord@stream@foreach@NORMALIZED@curencoded\pgfplots@EOI + \else + \def\pgfplots@coord@stream@foreach@NORMALIZED@curencoded@braced{{#1}}% + \pgfplotsaxisdeserializedatapointfrom{#1}% + \pgfplots@coord@stream@coord + \pgfplotsplothandlerifcurrentpointcanbefirstlast{% + \pgfplotscoordstream@firstlast@update + }{}% + \expandafter\pgfplots@foreach@plot@coord@NORMALIZED@ITERATE + \fi +} + +% A common routine which resets internal data structures for the +% survey phase, i.e. it is the shared implementation for all \addplot +% variations. +% +% It takes all options which are provided to \addplot, sets them (at +% least partially) and remembers them for the command serialization. +% +% #1: arguments to \addplot plot[#1] +% -> these are called 'behavior' options in the manual; they are set +% immediately. +% +% PRECONDITION: +% \pgfplots@addplotimpl@plot@withoptions has already been invoked +% +% POSTCONDITION: +% - internal datastructures are initialised (coordinate indexing, fpu) +% - all keys which are required for the current plot are determined +% (and set if necessary). +% They are stored into +% \pgfplots@addplot@survey@@optionlist. +% +\def\pgfplots@start@plot@with@behavioroptions#1{% + %\begingroup%<-- has been moved to \pgfplots@addplotimpl@plot@withoptions + \c@pgfplots@coordindex=0 + \def\pgfplots@current@point@coordindex{\the\c@pgfplots@coordindex}% can be used inside of coordinate filters. + \def\coordindex{\pgfplots@current@point@coordindex}% valid inside of \addplot + \def\pgfplots@addplot@running{1}% + % + \def\pgfplots@colorbar@set@src{0}% + \pgfkeysdef{/pgfplots/colorbar source}{% + \pgfplotsutilifstringequal{##1}{true}{% + \def\pgfplots@colorbar@set@src{1}% + }{% + \pgfplotsutilifstringequal{##1}{false}{% + \def\pgfplots@colorbar@set@src{0}% + }{% + \pgfplots@error{Sorry, I don't know the value `colorbar source={##1}' and I am going to ignore it. Maybe you misspelled it?}% + }% + }% + }% + % + \pgfplots@start@plot@with@behavioroptions@setkeys{#1}% + % + % enable FPU after any \pgfplotsset operations. Otherwise things like + % linewidth=... which use the math parser might fail. + \ifpgfplots@usefpu + \pgfkeys{/pgf/fpu=true}% + \fi + % + % make sure it is reset, just in case it is not supported by the + % input method. + \pgfplotsscanlinelengthinitzero + % + \pgfplots@getcurrent@plothandler\pgfplots@basiclevel@plothandler + \pgfplotsresetplothandler + \pgfplots@basiclevel@plothandler + % + \pgfplots@countplots@init + % + % hooks: + \pgfkeysvalueof{/pgfplots/execute at begin plot@@}% + \pgfkeysvalueof{/pgfplots/execute at begin plot}% + % + \if1\pgfplots@colorbar@set@src + \t@pgfplots@tokc={/pgfplots/point meta rel=per plot}% + \t@pgfplots@toka=\expandafter{\pgfplots@addplot@survey@@optionlist}% + \edef\pgfplots@addplot@survey@@optionlist{\the\t@pgfplots@tokc,\the\t@pgfplots@toka}% + \fi + % + % + \pgfplots@validate@plot@domain@arguments +} + +\def\pgfplots@disable@non@survey@keys{% + % + % this here would try to compute something. DON'T DO THIS DURING + % SURVEY! + \pgfkeysdef{/tikz/name intersections}{}% + \pgfkeysdef{/tikz/intersection segments}{}% + % +}% + +\def\pgfplots@start@plot@with@behavioroptions@setkeys#1{% + % these styles may contain behavior options (error bars, + % samples,... ) activate them! + % + % As of february 20, 2009, #1 will contain BOTH, /pgfplots + % and /tikz options. The /tikz ones are primarily for drawing + % and are UNIMPORTANT at this stage of processing. + % In fact, transparency etc. will only confuse everything. + % + % So: ignore them and set only /pgfplots keys here: + % This may actually redefine styles, for example + % \addplot[every mark/.append style={}] will use + % /pgfplots/every mark/.append style. + % But that doesn't hurt here. + % + % there are some exceptions like /tikz/id etc. These + % exceptions need special styles in the /pgfplots root - or I + % need to change the .unknown handler. See the available + % compatibility styles! + % +% \pgfkeysdef{/pgfplots/.unknown}{% +%\message{In \string\addplot[#1]: I am silently ignoring key `\pgfkeyscurrentkeyRAW' during the preparation phase.}% +% }% + % ATTENTION: + % as of january 30, 2010, I will set /tikz keys as well. This won't hurt + % too much, I hope... there are no graphics operations anyway. But it *is* + % necessary since I *need* the plot handler for the new version. And the plot + % handler is, most likely, a /tikz key. + % + % it is possible that '#1' contains 'forget plot'. So, we need to + % set the options before checking \ifpgfplots@curplot@isirrelevant: + \pgfplots@disable@non@survey@keys + \pgfplotsset{/pgfplots/every axis plot,#1}% + % + \ifpgfplots@curplot@isirrelevant + \def\pgfplots@addplot@survey@@optionlist{/pgfplots/every axis plot,/pgfplots/every forget plot}% + \pgfplotsset{/pgfplots/every forget plot,/pgfplots/every axis plot post}% + \else + \edef\pgfplots@addplot@survey@@optionlist{/pgfplots/every axis plot,/pgfplots/every axis plot no \the\pgfplots@numplots/.try}% + \pgfplotsset{/pgfplots/every axis plot no \the\pgfplots@numplots/.try,/pgfplots/every axis plot post}% + \fi + % + \t@pgfplots@tokc=\expandafter{\pgfplots@addplot@survey@@optionlist,#1}% this allows '#' inside of '#1' + \edef\pgfplots@addplot@survey@@optionlist{\the\t@pgfplots@tokc}% + % + \pgfplots@set@trig@format@plots +} + +\long\def\pgfplotssurveyphaseaddoptionsbeforesurveybegins#1{% + \pgfplotsset{% + /pgfplots/execute at end survey/.add={}{% + \t@pgfplots@tokc=\expandafter{\pgfplots@addplot@survey@@optionlist,#1}% this allows '#' inside of '#1' + \edef\pgfplots@addplot@survey@@optionlist{\the\t@pgfplots@tokc}% + },% + #1% + }% +}% +\long\def\pgfplotsplothandlersurveyaddoptions#1{% + \t@pgfplots@tokc=\expandafter{\pgfplots@addplot@survey@@optionlist,#1}% this allows '#' inside of '#1' + \edef\pgfplots@addplot@survey@@optionlist{\the\t@pgfplots@tokc}% + \pgfplotsset{#1}% +}% + + +% The main interface to draw a plot into an axis. +% +% Usage: +% \addplot +% plot coordinates { +% (0,0) +% (1,1) +% }; +% +% or +% +% \addplot[color=blue,mark=*] +% plot coordinates { +% (0,0) +% (1,1) +% }; +% +% or one of the other input types. +% +% The first syntax will use the next plot specification in the list +% \autoplotspeclist +% and the first will use blue color and * markers. +% +% \addplot [<style options>] plot[<behavior options>] <input type and args> <post plot path> ; +% \addplot3[<style options>] plot[<behavior options>] <input type and args> <post plot path> ; +% +% The complete accumulation is done GLOBALLY. It should be safe to put +% '\addplot' into local groups. +% +% +% The linespec. will be used in the legend. +% +% Low-level implementation: +% +% \pgfplots@addplot +% \pgfplots@addplotimpl +% \pgfplots@start@plot@with@behavioroptions <--- \begingroup +% ... +% ... remember options GLOBALLY +% ... update limits GLOBALLY +% ... \pgfplots@addplot@enqueue@coords GLOBALLY +% ... +% \pgfplots@end@plot <--- \endgroup +\def\pgfplots@addplot{% + \pgfutil@ifnextchar3{% + \pgfplots@curplot@threedimtrue + \pgfplots@addplot@three + }{% + \pgfplots@curplot@threedimfalse + \pgfplots@addplot@ + }% +} +\def\pgfplots@addplot@three3{\pgfplots@addplot@}% +\def\pgfplots@addplot@{% + \pgfutil@ifnextchar+{% + \pgfplots@getautoplotspec into\nextplotspec + \pgfplots@addplotimplAPPEND + }{% + \pgfutil@ifnextchar[{% + \pgfplots@addplotimpl% + }{% + \pgfplots@getautoplotspec into\nextplotspec + % the space after ']' is required here: + % FIXME: + % - \addplot[]plot coordinates is NOT allowed!? + \expandafter\pgfplots@addplotimpl\expandafter[\nextplotspec]% + }% + }% +} + +\def\pgfplots@addplotimplAPPEND+{\pgfutil@ifnextchar[{\pgfplots@addplotimplAPPEND@}{\pgfplots@addplotimplAPPEND@[]}}% this allows to gobble spaces and to skip the '[]' +\def\pgfplots@addplotimplAPPEND@[{% + \expandafter\pgfplots@addplotimpl\expandafter[\nextplotspec,% +} + +\long\def\pgfplots@addplotimpl[#1]{% + \pgfplotsutil@ifnextchar p{% + \pgfplots@addplotimpl@plot{#1}% + }{% + \pgfplots@addplotimpl@plot{#1}plot + }% +} + +\long\def\pgfplots@addplotimpl@plot#1plot{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@plot@withoptions{#1}% + }{% + \pgfplots@addplotimpl@plot@withoptions{#1}[]% + }% +} + +\long\def\pgfplots@addplotimpl@plot@withoptions#1[#2]{ + \begingroup% <-- This groups ends in \pgfplots@end@plot + % + \pgfplotsutil@ifnextchar c{% + \pgfplots@addplotimpl@coordinates{#1}{#2}plot + }{% + \pgfplotsutil@ifnextchar f{% + \pgfplots@addplotimpl@f{#1}{#2}% + }{% + \pgfplotsutil@ifnextchar t{% + \def\pgfplotssurveyphaseinputclass{table}% + \pgfplots@start@plot@with@behavioroptions{#1,/pgfplots/.cd,#2}% + \pgfplots@addplotimpl@table{#1,#2}% + }{% + \pgfplotsutil@ifnextchar ({% + \pgfplots@addplotimpl@expression{#1}{#2}% + }{% + \pgfplotsutil@ifnextchar\bgroup{% + \pgfplots@addplotimpl@expression@curly{#1}{#2}% + }{% + \pgfplotsutil@ifnextchar e{% + \pgfplots@addplotimpl@expression@e{#1}{#2}% + }{% + \pgfplotsutil@ifnextchar g{% + \pgfplots@addplotimpl@g{#1}{#2}% + }{% + \pgfplotsutil@ifnextchar s{% + \pgfplots@addplotimpl@shell{#1}{#2}% + }{% + + \pgfplots@error{Sorry, the supplied plot command is unknown or unsupported by pgfplots! Ignoring it.}% + \pgfplots@gobble@until@semicolon + }% + }% + }% + }% + }% + }% + }% + }% +} +\long\def\pgfplots@addplotimpl@f#1#2f{% + \pgfplotsutil@ifnextchar i{% + \pgfplots@addplotimpl@fil{#1}{#2}% + }{% + \pgfplots@addplotimpl@function{#1}{#2}% + }% +}% + +\long\def\pgfplots@addplotimpl@fil#1#2il{% + \pgfplotsutil@ifnextchar e{% + \pgfplots@addplotimpl@file{#1}{#2}% + }{% + \pgfplots@addplotimpl@fillbetween{#1}{#2}% + }% +}% + +\def\pgfplots@addplotimpl@fillbetween#1#2l between{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@fillbetween@opt{#1}{#2}% + }{% + \pgfplots@addplotimpl@fillbetween@opt{#1}{#2}[]% + }% +} +% \addplot[#1] [#2] fill between[#3] #4; +\long\def\pgfplots@addplotimpl@fillbetween@opt#1#2[#3]#4;{\pgfplots@addplotimpl@fillbetween@opt@{#1}{#2}{#3}{#4}}% + +\long\def\pgfplots@addplotimpl@fillbetween@opt@#1#2#3#4{% + \pgfkeysifdefined{/tikz/fill between/of/.@cmd}{% + \pgfplotslibraryfillbetween@addplot{#1,#2}{#3}{#4}% + }{% + \pgfplotsthrow{invalid argument} + {\pgfplots@loc@TMPa}% + {Please load \string\usepgfplotslibrary{fillbetween} in order to use `\string\addplot\space fill between'.}% + \pgfeov + }% + % + \pgfplots@end@plot% +}% + +\def\pgfplots@gobble@until@semicolon#1;{} + +% PRECONDITION: +% the key-value sets have all been set in the current scope. +% +% POSTCONDITION: +% 1. the following macros are initialised and sanitized: +% \pgfplots@plot@domain +% \pgfplots@plot@ydomain (will be set to \pgfplots@plot@domain if empty) +% \pgfplots@plot@samples@at +% \pgfplots@plot@samples@y (will be set to the x variant if empty) +% \tikz@plot@var (will become a macro like '\x') +% \pgfplots@plot@var@nonmacro (the same as \tikz@plot@var, but without backslash) +% \pgfplots@plot@var@y (like \tikz@plot@var, but for y) +% \pgfplots@plot@var@y@nonmacro (like \pgfplots@plot@var@nonmacro, but for y) +% 2. the following key-value things are set: +% /pgfplots/mesh/rows +% /pgfplots/mesh/cols +% /pgfplots/samples y (will contain a value ) +% 3. the macro +% \b@pgfplots@should@sample@LINE +% will be +% \def\b@pgfplots@should@sample@LINE{1} +% if the expression plotter should sample a line +% and +% \def\b@pgfplots@should@sample@LINE{0} +% if it should sample a mesh. +\def\pgfplots@plot@expression@preparekeys{% + \pgfkeysgetvalue{/pgfplots/domain}\pgfplots@plot@domain + \pgfkeysgetvalue{/pgfplots/samples y}\pgfplots@plot@samples@y + \pgfkeysgetvalue{/pgfplots/samples at}\pgfplots@plot@samples@at + \pgfkeysgetvalue{/pgfplots/variable y}\pgfplots@plot@var@y + % + % \tikz@plot@var is '\x' be default: + \pgfplots@gettikzinternal@keyval{variable}{tikz@plot@var}{\x}% + % + \begingroup + \escapechar=-1 + \xdef\pgfplots@glob@TMPa{\expandafter\string\tikz@plot@var}% + \xdef\pgfplots@glob@TMPb{\expandafter\string\pgfplots@plot@var@y}% + \endgroup + % \pgfplots@plot@var@nonmacro is the value '\tikz@plot@var' + % without the '\', i.e. 'x' by default: + \let\pgfplots@plot@var@nonmacro=\pgfplots@glob@TMPa + \let\pgfplots@plot@var@y@nonmacro=\pgfplots@glob@TMPb + % + % make sure the 'plot vars' have a backslash (as it was in tikz + % plot expression): + \edef\pgfplots@loc@TMPa{\expandafter\string\tikz@plot@var}% + \ifx\pgfplots@plot@var@nonmacro\pgfplots@loc@TMPa + \edef\tikz@plot@var{\expandafter\noexpand\csname \tikz@plot@var\endcsname}% + \fi + % + \edef\pgfplots@loc@TMPa{\expandafter\string\pgfplots@plot@var@y}% + \ifx\pgfplots@plot@var@y@nonmacro\pgfplots@loc@TMPa + \edef\pgfplots@plot@var@y{\expandafter\noexpand\csname \pgfplots@plot@var@y\endcsname}% + \fi + % + % Check if we have to sample a line or a matrix. + % + \pgfkeysgetvalue{/pgfplots/sample dim}\pgfplots@loc@TMPa + \def\pgfplots@loc@TMPb{auto}% + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + \ifpgfplots@curplot@threedim + \def\b@pgfplots@should@sample@LINE{0}% + \else + \def\b@pgfplots@should@sample@LINE{1}% + \fi + \else + \ifcase\pgfplots@loc@TMPa\relax + % sample dim=0 not useful!? + \def\b@pgfplots@should@sample@LINE{1}% + \or + \def\b@pgfplots@should@sample@LINE{1}% + \or + \def\b@pgfplots@should@sample@LINE{0}% + \else + \pgfplots@error{Sorry, sample dim=\pgfplots@loc@TMPa\space is unsupported (use either 1 or 2)}% + \fi + \fi + % + \if0\b@pgfplots@should@sample@LINE + % sample a matrix. Check the keys; if they are one + % dimensional, switch back to line sampling: + \pgfkeysgetvalue{/pgfplots/y domain}{\pgfplots@plot@ydomain}% + \edef\pgfplots@plot@ydomain{\pgfplots@plot@ydomain}% + \def\pgfplots@loc@TMPa{0:0}% + \ifx\pgfplots@plot@ydomain\pgfplots@loc@TMPa + \def\b@pgfplots@should@sample@LINE{1}% + \fi + \ifx\pgfplots@plot@ydomain\pgfutil@empty + \let\pgfplots@plot@ydomain=\pgfplots@plot@domain + \pgfkeyssetvalue{/pgfplots/y domain}{\pgfkeysvalueof{/pgfplots/domain}}% + \fi + \ifx\pgfplots@plot@samples@y\pgfutil@empty + \else + \ifnum\pgfplots@plot@samples@y<2 + \def\b@pgfplots@should@sample@LINE{1}% + \fi + \fi + \else + \def\b@pgfplots@should@sample@LINE{1}% + \fi + \ifx\pgfplots@plot@samples@y\pgfutil@empty + \pgfkeyssetvalue{/pgfplots/samples y}{\pgfkeysvalueof{/pgfplots/samples}}% + \pgfkeysgetvalue{/pgfplots/samples y}\pgfplots@plot@samples@y + \fi + % + \iftikz@plot@raw@gnuplot + % FIXME : verify this case + \else + \pgfkeyssetvalue{/pgfplots/mesh/rows}{\pgfkeysvalueof{/pgfplots/samples y}}% + \pgfkeyssetvalue{/pgfplots/mesh/cols}{\pgfkeysvalueof{/pgfplots/samples}}% + \fi + \if1\b@pgfplots@should@sample@LINE + \pgfkeyssetvalue{/pgfplots/sample dim}{1}% + \pgfkeyssetvalue{/pgfplots/mesh/cols}{1}% + \else + \pgfkeyssetvalue{/pgfplots/sample dim}{2}% + \fi + % +}% + +% Plot expression. It invokes the pgf math parser and a customized +% pgfplots point sampling routine. Combined with the 'fixed point +% library' of pgf, it results in highly accurate plots. +% +% +\long\def\pgfplots@addplotimpl@expression#1#2(#3,#4)#5;{\pgfplots@addplotimpl@expression@{#1}{#2}{#3}{#4}{#5}}% +% \addplot[#1] [#2] (#3,#4) #5; +\long\def\pgfplots@addplotimpl@expression@#1#2#3#4#5{% + \pgfplots@addplotimpl@expression@set@options{#1}{#2}% + \pgfplots@addplotimpl@expression@@{#3}{#4}{#5}% +} + +\long\def\pgfplots@addplotimpl@expression@set@options#1#2{% + \def\pgfplotssurveyphaseinputclass{expression}% + \pgfplots@start@plot@with@behavioroptions{#1,/pgfplots/.cd,#2,/pgfplots/mesh input=lattice,/pgfplots/mesh/ordering/x varies}% + \pgfplots@plot@expression@preparekeys +}% + +% \addplot (#1,#2) #3; +\long\def\pgfplots@addplotimpl@expression@@#1#2#3{% + % + \pgfplots@PREPARE@COORD@STREAM{#3}% + % + \def\pgfplots@addplotimpl@expression@xEXPR{#1}% + % + % Determine whether the x range is parameterized or uniform and + % prepare a macro which assigns \pgfplots@current@point@x: + \def\pgfplots@addplotimpl@expression@prepare@x{% + \pgfmathparse{#1}% + \let\pgfplots@current@point@x=\pgfmathresult + }% + \def\pgfplots@addplotimpl@expression@prepare@y{% + \pgfmathparse{\pgfplots@addplotimpl@expression@yEXPR}% + \let\pgfplots@current@point@y=\pgfmathresult + }% + \def\pgfplots@addplotimpl@expression@hasuniform@x{0}% + % do we have '\x' as x coordinate? + \expandafter\def\expandafter\pgfplots@loc@TMPb\expandafter{\tikz@plot@var}% + \ifx\pgfplots@addplotimpl@expression@xEXPR\pgfplots@loc@TMPb + \def\pgfplots@addplotimpl@expression@hasuniform@x{1}% + \else + \edef\pgfplots@loc@TMPb{\pgfplots@plot@var@nonmacro}% + % do we have 'x' as x coordinate? + \ifx\pgfplots@addplotimpl@expression@xEXPR\pgfplots@loc@TMPb + \def\pgfplots@addplotimpl@expression@hasuniform@x{1}% + \fi + \fi + \if\pgfplots@addplotimpl@expression@hasuniform@x1% + % if '#1' is '\x' or 'x', we don't need the math parser - + % we can simply take \tikz@plot@var. + \def\pgfplots@addplotimpl@expression@prepare@x{% + \edef\pgfplots@current@point@x{\tikz@plot@var}% + }% + \fi + % + \def\pgfplots@addplotimpl@expression@hasuniform@y{0}% + % + % + % Now, prepare the loops. + % + % I am using \pgfplotsforeachungrouped in favor of + % \foreach because \foreach does NOT allow extended + % precision. Besides, \pgfplotsforeachungrouped avoids + % scoping problems. + \let\pgfplots@plot@data@notify@next@x=\relax + \let\pgfplots@plot@data@notify@next@y=\relax + % + \ifpgfplots@curplot@threedim + \def\pgfplots@addplotimpl@expression@split@yz##1,##2\pgfplots@EOI{% + \def\pgfplots@addplotimpl@expression@yEXPR{##1}% + \def\pgfplots@addplotimpl@expression@zEXPR{##2}% + }% + \pgfplots@addplotimpl@expression@split@yz#2\pgfplots@EOI% + % + % we don't have 'samples at' for 3D plots -> use domain! + \expandafter\pgfplots@domain@to@foreach\pgfplots@plot@domain\relax{\pgfplots@plot@samples}% + \let\pgfplots@expression@xdomain=\pgfplotsretval + % + % do we have '\y' as y coordinate? + \expandafter\def\expandafter\pgfplots@loc@TMPb\expandafter{\pgfplots@plot@var@y}% + \ifx\pgfplots@addplotimpl@expression@yEXPR\pgfplots@loc@TMPb + \def\pgfplots@addplotimpl@expression@hasuniform@y{1}% + \def\pgfplots@addplotimpl@expression@prepare@y{% + \edef\pgfplots@current@point@y{\pgfplots@plot@var@y}% + }% + \else + \edef\pgfplots@loc@TMPb{\pgfplots@plot@var@y@nonmacro}% + % do we have 'y' as y coordinate? + \ifx\addplotimpl@expression@yEXPR\pgfplots@loc@TMPb + \def\pgfplots@addplotimpl@expression@hasuniform@y{1}% + \def\pgfplots@addplotimpl@expression@prepare@y{% + \edef\pgfplots@current@point@y{\pgfplots@plot@var@y}% + }% + \fi + \fi + % + % + \if0\b@pgfplots@should@sample@LINE + % Samples twodimensionally (a lattice): + \expandafter\pgfplots@domain@to@foreach\pgfplots@plot@ydomain\relax{\pgfplots@plot@samples@y}% + \let\pgfplots@expression@ydomain=\pgfplotsretval + % + % Assemble a + % \pgfplots@plot@data##1 -> + % \foreach \y in {-5,-4.6,...,5} {##1}; + % \foreach \x in {-5,-4.6,...,5} + % macro: + \edef\pgfplots@plot@data##1{% + \noexpand\pgfplotsforeachungrouped\expandafter\noexpand\pgfplots@plot@var@y in {\pgfplots@expression@ydomain} + {% + \pgfplots@plot@data@notify@next@y + \noexpand\pgfplotsforeachungrouped\expandafter\noexpand\tikz@plot@var in {\pgfplots@expression@xdomain} {% + \pgfplots@plot@data@notify@next@x + ##1% + }% + \noexpand\pgfplotsplothandlernotifyscanlinecomplete + }% + }% + \else + % sample a line: + \def\pgfplots@plot@ydomain{0:0}% + \edef\pgfplots@plot@data##1{% + \noexpand\pgfplotsforeachungrouped\expandafter\noexpand\tikz@plot@var in {\pgfplots@expression@xdomain} {% + \pgfplots@plot@data@notify@next@x + ##1% + }% + }% + % + % If we have (\x,\y,f(x)), use (\x,0,f(x)) instead and + % suppress the error message which would occur for \y. + \if1\pgfplots@addplotimpl@expression@hasuniform@y + \def\pgfplots@addplotimpl@expression@yEXPR{0}% + \def\pgfplots@plot@var@y{0}% + \else + \expandafter\edef\pgfplots@plot@var@y{\pgfplots@plot@var@y@nonmacro}% this provides an error message, see above. + \fi + \fi + \else + % Assemble a + % \pgfplots@plot@data##1 -> \foreach \x in {-5,-4.6,...,5} {##1} macro: + % + % + % if( + % x is logarithmic && + % #1 == '\x' && + % the 'samples at' key has not been used ) + % -> sample logarithmically! + \def\pgfplots@samples@logarithmically{0}% + \ifpgfplots@xislinear + \else + \if\pgfplots@addplotimpl@expression@hasuniform@x1% + \ifx\pgfplots@plot@samples@at\pgfutil@empty + % we don't have 'samples at' -> use domain! + \def\pgfplots@samples@logarithmically{1}% + \fi + \fi + \fi + \if\pgfplots@samples@logarithmically1% + \def\pgfplotsforeachlogarithmicmathid{x}% use \pgfplotscoordmath{x} + % sample logarithmically: + \edef\pgfplots@plot@data##1{% + \noexpand\pgfplotsforeachlogarithmicungrouped[\pgfplots@plot@samples] + \expandafter\noexpand\tikz@plot@var/\noexpand\pgfplots@current@point@x@log + in {\pgfplots@plot@domain}% + {% + \pgfplots@plot@data@notify@next@x + ##1% + }% + }% + % we have a logarithmic sampling sequence, + % \pgfplots@current@point@x@log is already available + % logarithmic! We can safe time and accuracy for the x + % coordinate by using that one instead of computing + % log(exp(\x)) numerically: + \pgfplots@disablelogfilter@xtrue + \def\pgfplots@addplotimpl@expression@prepare@x{% + \let\pgfplots@current@point@x=\pgfplots@current@point@x@log + }% + \pgflibraryfpuifactive + {\relax} + {% + % ok, if the FPU is NOT active, we should return + % results as fixed points. + % We need to configure that for + % \pgfplotsforeachlogarithmicungrouped manually: + \pgfplotsforeachlogarithmicformatresultwith{% + \pgfmathfloattofixed{\pgfmathresult}% + }% + }% + \else + \ifx\pgfplots@plot@samples@at\pgfutil@empty + % we don't have 'samples at' -> use domain! + \expandafter\pgfplots@domain@to@foreach\pgfplots@plot@domain\relax{\pgfplots@plot@samples}% + \let\pgfplots@loc@TMPa=\pgfplotsretval + \else + % use 'samples at': + \let\pgfplots@loc@TMPa=\pgfplots@plot@samples@at + \fi + \edef\pgfplots@plot@data##1{% + \noexpand\pgfplotsforeachungrouped\expandafter\noexpand\tikz@plot@var in {\pgfplots@loc@TMPa}% + {% + \pgfplots@plot@data@notify@next@x + ##1% + }% + }% + \fi + \expandafter\def\pgfplots@plot@var@y{0}% + \def\pgfplots@addplotimpl@expression@yEXPR{#2}% + \def\pgfplots@addplotimpl@expression@zEXPR{}% + \def\pgfplots@current@point@z{}% + \fi + % + % + % START: + % (NOTE: this does also define 'x', 'y', and 'z' math + % expressions!) + \pgfplots@coord@stream@start + % + \pgfplots@addplotimpl@expression@check@LUA + \if1\pgfplotsretval + \pgfplots@log{\pgfplots@LUA@loglevel@debug}{lua backend=true: Activating LUA version of plot expression for plot \the\pgfplots@numplots\space (type '\pgfplotsplothandlername').}% + \begingroup + \expandafter\def\tikz@plot@var{\pgfplots@plot@var@nonmacro}% + \expandafter\def\pgfplots@plot@var@y{\pgfplots@plot@var@y@nonmacro}% + \expandafter\pgfplots@parse@domain\pgfplots@plot@domain\relax{pgfplots@plot@domain}% + % + \pgfmathparse{\pgfplots@plot@samples}% + \let\pgfplots@plot@samples=\pgfmathresult + % + \if0\b@pgfplots@should@sample@LINE + \expandafter\pgfplots@parse@domain\pgfplots@plot@ydomain\relax{pgfplots@plot@ydomain}% + \pgfmathparse{\pgfplots@plot@samples@y}% + \let\pgfplots@plot@samples@y=\pgfmathresult + \else + \def\pgfplots@plot@ydomain@min{0}% + \def\pgfplots@plot@ydomain@max{0}% + \def\pgfplots@plot@samples@y{1}% + \fi + % + % FIXME : there are some cases in which this here might be a + % bad idea: + % - if someone has redefined math functions on TeX + % - if someone has defined his own math functions (only in + % TeX) + % - if a plot expression contains directlua -- the expansion will play + % funny tricks in this case + \xdef\pgfplotsglobalretval{% + \directlua{% + pgfplots.texAddplotExpressionCoordinateGenerator(^^J% + \ifpgfplots@curplot@threedim true \else false\fi,^^J% + "#1", ^^J% + "\pgfplots@addplotimpl@expression@yEXPR",^^J% + "\pgfplots@addplotimpl@expression@zEXPR",^^J% + \b@pgfplots@should@sample@LINE,^^J% + "\pgfplots@plot@domain@min", "\pgfplots@plot@domain@max",^^J% + "\pgfplots@plot@ydomain@min", "\pgfplots@plot@ydomain@max",^^J% + "\pgfplots@plot@samples",^^J% + "\pgfplots@plot@samples@y",^^J% + "\pgfplots@plot@var@nonmacro",^^J% + "\pgfplots@plot@var@y@nonmacro", + "\pgfplots@plot@samples@at", + "\pgfplots@LUA@backend@debugmode")^^J% + }% + }% + \endgroup + \if0\pgfplotsglobalretval + \pgfplots@log{\pgfplots@LUA@loglevel@info}{lua backend=true: LUA version of plot expression failed. Using TeX version. (plot \the\pgfplots@numplots).}% + \pgfplots@LUA@backend@failed + \pgfplots@addplotimpl@expression@streamall + \else + \fi + \else + \pgfplots@addplotimpl@expression@streamall + \fi + % + \pgfplots@coord@stream@end +}% + +% Defines \pgfplotsretval to be '1' if the pure LUA version of +% \addplot expression is enabled. It defines \pgfplotsretval to be 0 +% if not. +\def\pgfplots@addplotimpl@expression@check@LUA{% + \def\pgfplotsretval{0}% + \ifpgfplots@LUA@backend@supported + \def\pgfplotsretval{1}% + \ifpgfplotsplothandlermesh@patch@type@sampling + \def\pgfplotsretval{0}% + \pgfplots@LUA@plotexpression@log@deactivation{patch type sampling unsupported (yet)}% + \fi + % + \if1\pgfplots@addplotimpl@expression@hasuniform@x + \else + \expandafter\pgfplotsutilifcontainsmacro\expandafter{\pgfplots@addplotimpl@expression@xEXPR}{% + \def\pgfplotsretval{0}% + \pgfplots@command@to@string\pgfplots@addplotimpl@expression@xEXPR\pgfplots@loc@TMPa + \pgfplots@LUA@plotexpression@log@deactivation{x expression '\pgfplots@loc@TMPa' contains a TeX macro}% + }{% + }% + \fi + % + \if1\pgfplots@addplotimpl@expression@hasuniform@y + \else + \expandafter\pgfplotsutilifcontainsmacro\expandafter{\pgfplots@addplotimpl@expression@yEXPR}{% + \def\pgfplotsretval{0}% + \pgfplots@command@to@string\pgfplots@addplotimpl@expression@yEXPR\pgfplots@loc@TMPa + \pgfplots@LUA@plotexpression@log@deactivation{y expression '\pgfplots@loc@TMPa' contains a TeX macro}% + }{% + }% + \fi + % + \ifpgfplots@curplot@threedim + \expandafter\pgfplotsutilifcontainsmacro\expandafter{\pgfplots@addplotimpl@expression@zEXPR}{% + \def\pgfplotsretval{0}% + \pgfplots@command@to@string\pgfplots@addplotimpl@expression@zEXPR\pgfplots@loc@TMPa + \pgfplots@LUA@plotexpression@log@deactivation{z expression '\pgfplots@loc@TMPa' contains a TeX macro}% + }{% + }% + \fi + \fi +}% + +\def\pgfplots@LUA@plotexpression@log@deactivation#1{% + \pgfplots@log{\pgfplots@LUA@loglevel@info}{Deactivating LUA version of plot expression for plot \the\pgfplots@numplots\space (type '\pgfplotsplothandlername'): #1.}% + \pgfplots@LUA@backend@failed +} +\def\pgfplots@parse@domain#1:#2\relax#3{% + \pgfmathparse{#1}% + \expandafter\let\csname #3@min\endcsname=\pgfmathresult% + \pgfmathparse{#2}% + \expandafter\let\csname #3@max\endcsname=\pgfmathresult% +}% +\def\pgfplots@addplotimpl@expression@streamall{% + % create a backup of the 'x' and 'y' math expressions which + % have been defined in \pgfplots@coord@stream@start: + \let\pgfplots@addplotimpl@expression@pseudoconst@old@x=\pgfmathx@ + \let\pgfplots@addplotimpl@expression@pseudoconst@old@y=\pgfmathy@ + % + % Prepare 'x' and 'y' as pseudo constants in expressions: + \gdef\pgfplots@noy@error{% + \pgfplots@error{Sorry, you can't use 'y' in this context. PGFPlots expected to sample a line, not a mesh. Please use the [mesh] option combined with [samples y>0] and [domain y!=0:0] to indicate a twodimensional input domain}% + \global\let\pgfplots@noy@error=\relax + }% + % Define a "function" x which sets \pgfmathresult := \x : + \pgfplotsmathdeclarepseudoconstant{\pgfplots@plot@var@nonmacro}{\edef\pgfmathresult{\tikz@plot@var}}% + \if0\b@pgfplots@should@sample@LINE + % surface: + \pgfplotsmathdeclarepseudoconstant{\pgfplots@plot@var@y@nonmacro}{\edef\pgfmathresult{\pgfplots@plot@var@y}}% + \else + \pgfplotsmathdeclarepseudoconstant{\pgfplots@plot@var@y@nonmacro}{\pgfplots@noy@error\def\pgfmathresult{0.0}}% + \fi + % remember them here: + \let\pgfplots@addplotimpl@expression@pseudoconst@x=\pgfmathx@ + \let\pgfplots@addplotimpl@expression@pseudoconst@y=\pgfmathy@ + % +% \if n\pgfplots@meshmode + % mesh=false : ignore patch type sampling. +% \else + \ifpgfplotsplothandlermesh@patch@type@sampling + \pgfplots@plot@expression@prepare@patch@type@sampling + \fi +% \fi + % + % Warning for use fpu=false: evaluation '\x^3' might be different from 'x^3' for + % negative arguments: + % \x^3 ---> -0.2^3 but x^3 = (-0.2)^3 . + % This does not happen for use fpu=true. + % + \pgfplots@plot@data{% + \let\pgfmathx@=\pgfplots@addplotimpl@expression@pseudoconst@x + \let\pgfmathy@=\pgfplots@addplotimpl@expression@pseudoconst@y + % eval expressions: + \pgfplots@addplotimpl@expression@prepare@x% + \pgfplots@addplotimpl@expression@prepare@y% + \ifpgfplots@curplot@threedim + \pgfmathparse{\pgfplots@addplotimpl@expression@zEXPR}% + \let\pgfplots@current@point@z=\pgfmathresult + \fi + % restore 'x' and 'y': + \let\pgfmathx@=\pgfplots@addplotimpl@expression@pseudoconst@old@x + \let\pgfmathy@=\pgfplots@addplotimpl@expression@pseudoconst@old@y + % + %\pgfplots@expression@normalize@floats + % + % process coords as usual: + \pgfplots@coord@stream@coord + }% +} + +% Typically, the FPU will generate stuff like '1Y1.0e5'. Since such +% internal representations will be available to API users (especially +% 'x filter' and its variants, we want to simplify its output - by +% normalizing it. +% +% This routine will convert any floats to scientific format, i.e. +% 1.0e5 instead of 1Y1.0e5 (1Y means 'positive float', compare +% pgfmathfloat.code.tex). +\def\pgfplots@expression@normalize@floats{% + \pgflibraryfpuifactive{% + \ifx\pgfplots@current@point@x\pgfutil@empty\else + \pgfmathfloattosci{\pgfplots@current@point@x}\let\pgfplots@current@point@x=\pgfmathresult + \fi% + \ifx\pgfplots@current@point@y\pgfutil@empty\else + \pgfmathfloattosci{\pgfplots@current@point@y}\let\pgfplots@current@point@y=\pgfmathresult + \fi% + \ifx\pgfplots@current@point@z\pgfutil@empty\else + \pgfmathfloattosci{\pgfplots@current@point@z}\let\pgfplots@current@point@z=\pgfmathresult + \fi% + }{% + }% +}% + +% \addplot[#1] [#2] {#3} #4; +\long\def\pgfplots@addplotimpl@expression@curly#1#2#3#4;{\pgfplots@addplotimpl@expression@curly@{#1}{#2}{#3}{#4}}% +\long\def\pgfplots@addplotimpl@expression@curly@#1#2#3#4{% + \pgfplots@addplotimpl@expression@set@options{#1}{#2}% + \ifpgfplots@curplot@threedim + \t@pgfplots@toka={,#3}% + % the \pgfplots@plot@var@y will expand to the current value of + % '/pgfplots/variable y'. + % Keep it this way, \pgfplots@addplotimpl@expression@ checks + % for that special string. + \edef\pgfplots@loc@TMPb{% + {\expandafter\noexpand\tikz@plot@var}% + {\expandafter\noexpand\pgfplots@plot@var@y\the\t@pgfplots@toka}% + }% + \expandafter\pgfplots@addplotimpl@expression@@\pgfplots@loc@TMPb{#4}% + \else + \expandafter\pgfplots@addplotimpl@expression@@\expandafter{\tikz@plot@var}{#3}{#4}% + \fi +}% +% \addplot[#1] [#2] expression[#3] {#4} #5; +\def\pgfplots@addplotimpl@expression@e#1#2expression{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@expression@e@{#1}{#2}% + }{% + \pgfplots@addplotimpl@expression@e@{#1}{#2}[]% + }% +}% +\def\pgfplots@addplotimpl@expression@e@#1#2[#3]{% + \pgfplots@addplotimpl@expression@curly{#1}{#2,#3}% +}% + + +% This prepares the implementation for 'patch type sampling': +\def\pgfplots@plot@expression@prepare@patch@type@sampling{% + \pgfplotssurveyphaseaddoptionsbeforesurveybegins{ + mesh input=patches,% + }% + % + \pgfkeysgetvalue{/pgfplots/patch type}\pgfplotsplothandlermesh@patchclass + % + \let\pgfplots@plot@data@@=\pgfplots@plot@data + \let\pgfplots@plot@data@curx=\pgfutil@empty + \let\pgfplots@plot@data@cury=\pgfutil@empty + \let\pgfplots@plot@data@lastx=\pgfutil@empty + \let\pgfplots@plot@data@lasty=\pgfutil@empty + \let\pgfplots@plot@data@first@x=\pgfutil@empty + \let\pgfplots@plot@data@first@y=\pgfutil@empty + % + \def\pgfplots@plot@data@notify@next@x{% + \ifx\pgfplots@plot@data@first@x\pgfutil@empty + \edef\pgfplots@plot@data@first@x{\tikz@plot@var}% + \fi + \let\pgfplots@plot@data@lastx=\pgfplots@plot@data@curx + \edef\pgfplots@plot@data@curx{\tikz@plot@var}% + }% + \def\pgfplots@plot@data@notify@next@y{% + \ifx\pgfplots@plot@data@first@y\pgfutil@empty + \edef\pgfplots@plot@data@first@y{\pgfplots@plot@var@y}% + \fi + \let\pgfplots@plot@data@lasty=\pgfplots@plot@data@cury + \edef\pgfplots@plot@data@cury{\pgfplots@plot@var@y}% + }% + \def\pgfplots@plot@data##1{% + % + \pgfplots@plot@data@@{% + \let\tikz@plot@var@old=\tikz@plot@var + \let\pgfplots@plot@var@y@old=\pgfplots@plot@var@y + % + % + % + % boolean 'if is first row || is first cell': + \pgfplots@loc@tmpfalse + \ifx\pgfplots@plot@data@curx\pgfplots@plot@data@first@x + % ah - we have the first row. + \pgfplots@loc@tmptrue + \fi + \if0\b@pgfplots@should@sample@LINE + \ifx\pgfplots@plot@data@cury\pgfplots@plot@data@first@y + % ah - we have the first cell. + \pgfplots@loc@tmptrue + \fi + \fi + % + \ifpgfplots@loc@tmp + \else + \pgfmathparse{\pgfplots@plot@data@curx-\pgfplots@plot@data@lastx}% + \let\pgfplots@plot@data@hx=\pgfmathresult + % + \if0\b@pgfplots@should@sample@LINE + \pgfmathparse{\pgfplots@plot@data@cury-\pgfplots@plot@data@lasty}% + \let\pgfplots@plot@data@hy=\pgfmathresult + \fi + % + \def\pgfplotspatchready{\pgfplotsscanlinecomplete}% + \pgfplotspatchclass{\pgfplotsplothandlermesh@patchclass}{sample in unit cube}{% + \pgfmathparse{\pgfplots@plot@data@lastx + \pgfplotspatchclassx*\pgfplots@plot@data@hx}% + \let\tikz@plot@var=\pgfmathresult + % + \if0\b@pgfplots@should@sample@LINE + \pgfmathparse{\pgfplots@plot@data@lasty + \pgfplotspatchclassy*\pgfplots@plot@data@hy}% + \let\pgfplots@plot@var@y=\pgfmathresult + \fi + % + ##1% + % + \let\tikz@plot@var=\tikz@plot@var@old + \let\pgfplots@plot@var@y=\pgfplots@plot@var@y@old + }% + \fi + }% + }% +}% + +\let\pgfplots@backupof@pgfplotxyfile=\pgfplotxyfile + +% the following code +% results finally in +% +% set format "%.7e";; set samples <...>; plot ... +% +% The windows port of gnuplot doesn't run without the second semicolon +% - for whatever reason. +{ + \catcode`\%=12 + \catcode`\"=12 + \catcode`\;=12 + \xdef\pgfplots@gnuplot@format{set format "%.7e";} +} +\def\pgfplots@addplotimpl@g#1#2g{% + \pgfplotsutil@ifnextchar r{% + \pgfplots@addplotimpl@graphics{#1}{#2}% + }{% + \pgfplots@addplotimpl@gnuplot{#1}{#2}% + }% +}% + +% |\addplot gnuplot| is an alias to |\addplot function| +\def\pgfplots@addplotimpl@gnuplot#1#2nuplot{\pgfplots@addplotimpl@function{#1}{#2}unction}% + +% \addplot[#1] plot[#2] function[#3] {#4} #5; +\def\pgfplots@addplotimpl@function#1#2unction{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@function@opt{#1}{#2}% + }{% + \pgfplots@addplotimpl@function@opt{#1}{#2}[]% + }% +}% +\def\pgfplots@addplotimpl@function@opt#1#2[#3]#4#5;{\pgfplots@addplotimpl@function@opt@{#1}{#2}{#3}{#4}{#5}}% +% \addplot[#1] [#2] function[#3] {#4} #5; +\def\pgfplots@addplotimpl@function@opt@#1#2#3#4#5{% + % FIXME : what about the key search paths if the user changes + % them!? + \def\pgfplotssurveyphaseinputclass{gnuplot}% + \pgfplots@start@plot@with@behavioroptions{#1,/pgfplots/.cd,#2,/pgfplots/.cd,#3,/pgfplots/mesh/ordering/x varies}% + % + \pgfplots@gettikzinternal@keyval{prefix}{tikz@plot@prefix}{\jobname.}% + \pgfplots@gettikzinternal@keyval{id}{tikz@plot@id}{pgf-plot}% + \pgfplots@gettikzinternal@keyval{raw gnuplot}{iftikz@plot@raw@gnuplot}{\iffalse}% + \pgfplots@gettikzinternal@keyval{parametric}{iftikz@plot@parametric}{\iffalse}% + % + % determine dummy variables: + \iftikz@plot@parametric + \ifpgfplots@curplot@threedim + \pgfkeysgetvalue{/pgfplots/parametric/var 2d}\pgfplots@gnuplot@dummy% + \else + \pgfkeysgetvalue{/pgfplots/parametric/var 1d}\pgfplots@gnuplot@dummy% + \fi + \ifx\pgfplots@gnuplot@dummy\pgfutil@empty + \else + \expandafter\pgfutil@in@\expandafter,\expandafter{\pgfplots@gnuplot@dummy}% + \ifpgfutil@in@ + \def\pgfplots@loc@TMPa##1,##2\pgfeov{\pgfplotsset{variable={##1},variable y={##2}}}% + \else + \def\pgfplots@loc@TMPa##1\pgfeov{\pgfplotsset{variable={##1}}}% + \fi + \expandafter\pgfplots@loc@TMPa\pgfplots@gnuplot@dummy\pgfeov + \fi + \fi + % + % prepare domain and samples, normalize dummy variables: + \pgfplots@plot@expression@preparekeys + % + % FIXME: what with 'samples at'!? + \edef\pgfplots@plot@filename{\tikz@plot@prefix\tikz@plot@id}% + % + \def\pgfplots@addplotimpl@gnuplotresult@isthreedim@withtwocoords{0}% + % + \edef\pgfplots@gnuplotcode{#4}% + \ifpgfplots@translategnuplot + \def\pgfplots@loc@TMPa{\pgfplotsutilstrreplace{^}{**}}% + \expandafter\pgfplots@loc@TMPa\expandafter{\pgfplots@gnuplotcode}% + \let\pgfplots@gnuplotcode=\pgfplotsretval + \fi + % + % + \iftikz@plot@raw@gnuplot% + \def\pgfplots@plot@data{\pgfplotgnuplot[\pgfplots@plot@filename]{\pgfplots@gnuplot@format;\pgfplots@gnuplotcode}}% + \else% + % collect logs: + \def\pgfplots@gnuplot@logdirs{}% + \ifpgfplots@xislinear + \else + \pgfplots@identify@gnuplot@logbehavior x% + \expandafter\def\expandafter\pgfplots@gnuplot@logdirs\expandafter{\pgfplots@gnuplot@logdirs x}% + \fi + \ifpgfplots@yislinear + \else + \pgfplots@identify@gnuplot@logbehavior y% + \expandafter\def\expandafter\pgfplots@gnuplot@logdirs\expandafter{\pgfplots@gnuplot@logdirs y}% + \fi + \ifpgfplots@curplot@threedim + \ifpgfplots@zislinear + \else + \pgfplots@identify@gnuplot@logbehavior z% + \expandafter\def\expandafter\pgfplots@gnuplot@logdirs\expandafter{\pgfplots@gnuplot@logdirs z}% + \fi + \fi + % + \ifpgfplots@curplot@threedim + \if1\b@pgfplots@should@sample@LINE + \pgfplots@error{Sorry, I do not know how to sample 3D LINE plots with gnuplot... I only know 2D line and 3D mesh. You may want to help the author of pgfplots to improve this feature.}% + \fi + \fi + \def\pgfplots@gnuplot@x{\pgfplots@plot@var@nonmacro}% + \def\pgfplots@gnuplot@y{\pgfplots@plot@var@y@nonmacro}% + \def\pgfplots@plot@data{\pgfplotgnuplot[\pgfplots@plot@filename]{% + \pgfplots@gnuplot@format; + set samples \pgfkeysvalueof{/pgfplots/samples}\if0\b@pgfplots@should@sample@LINE, \pgfkeysvalueof{/pgfplots/samples y}\fi; + set dummy \pgfplots@gnuplot@x\if0\b@pgfplots@should@sample@LINE,\pgfplots@gnuplot@y\fi; + \ifx\pgfplots@gnuplot@logdirs\pgfutil@empty + \else + set logscale \pgfplots@gnuplot@logdirs\space 2.71828182845905; + \fi + \iftikz@plot@parametric set parametric;\fi + \ifpgfplots@curplot@threedim + \if0\b@pgfplots@should@sample@LINE + % Samples twodimensionally (a lattice): + % and the isosamples thing confuses me. + set isosamples \pgfkeysvalueof{/pgfplots/samples}\if0\b@pgfplots@should@sample@LINE, \pgfkeysvalueof{/pgfplots/samples y}\fi; + splot [\pgfplots@gnuplot@x=\pgfplots@plot@domain] [\pgfplots@gnuplot@y=\pgfplots@plot@ydomain] \pgfplots@gnuplotcode;% + \else + % *should* sample a line, but I don't know how. + splot [\pgfplots@gnuplot@x=\pgfplots@plot@domain] \pgfplots@gnuplotcode;% + \fi + \else + plot [\pgfplots@gnuplot@x=\pgfplots@plot@domain] \pgfplots@gnuplotcode;% + \fi + }}% + \fi% + \def\pgfplotxyfile{\pgfplots@addplotimpl@gnuplotresult{#5}}% + \pgfplots@plot@data + \let\pgfplotxyfile=\pgfplots@backupof@pgfplotxyfile +}% + +\def\pgfplots@identify@gnuplot@logbehavior#1{% + \pgfutil@ifundefined{pgfplots@gnuplot@logscale@writes@log}{% + \pgfplots@identify@gnuplot@logbehavior@checkversion% + }{}% + \if1\pgfplots@gnuplot@logscale@writes@log + \csname pgfplots@disablelogfilter@#1true\endcsname + \fi +}% +\def\pgfplots@identify@gnuplot@logbehavior@checkversion{% + \begingroup + \immediate\write18{gnuplot -V >\pgfplots@plot@filename.vrs}% + \openin\r@pgfplots@reada=\pgfplots@plot@filename.vrs\relax + \ifeof\r@pgfplots@reada + \pgfplotswarning{gnuplot -V impossible}\pgfeov + \gdef\pgfplots@gnuplot@logscale@writes@log{1}% something doesn't work. set it somehow. + \else + \read\r@pgfplots@reada to\pgfplots@loc@TMPa + \gdef\pgfplots@gnuplot@logscale@writes@log{1}% + \t@pgfplots@toka=\expandafter{\pgfplots@loc@TMPa}% + \immediate\write-1{Package pgfplots: checking gnuplot -V : `\the\t@pgfplots@toka' (if this fails, set `/pgfplots/gnuplot writes logscale=true|false')}% + \expandafter\pgfplots@identify@gnuplot@logbehavior@checkversion@\pgfplots@loc@TMPa 0 0.0 0\relax + \if0\pgfplots@gnuplot@logscale@writes@log + \immediate\write-1{Package pgfplots: I found gnuplot version >= 4.4. This one doesn't write log() coordinates. I will apply log() manually.}% + \else + \immediate\write-1{Package pgfplots: I found gnuplot version < 4.4. This one writes log() coordinates. I'll handle it accordingly.}% + \fi + \closein\r@pgfplots@reada + \fi + \endgroup +}% +\long\def\pgfplots@identify@gnuplot@logbehavior@checkversion@{% + \pgfutil@ifnextchar\par{% + \pgfplotswarning{gnuplot -V format unknown}\pgfeov% + \gdef\pgfplots@gnuplot@logscale@writes@log{1}% + \pgfplots@identify@gnuplot@logbehavior@checkversion@@@ + }{% + \pgfplots@identify@gnuplot@logbehavior@checkversion@@ + }% +}% +\long\def\pgfplots@identify@gnuplot@logbehavior@checkversion@@@#1\relax{% +}% +\long\def\pgfplots@identify@gnuplot@logbehavior@checkversion@@#1 #2.#3 #4\relax{% + % starting with gnuplot 4.4, output files are no longer in + % logarithmic scale for log plots. + \ifnum#2<4 + % version 3.X + \gdef\pgfplots@gnuplot@logscale@writes@log{1}% + \else + \ifnum#2>4 + % version 5.X + \gdef\pgfplots@gnuplot@logscale@writes@log{0}% + \else + \ifnum#3<4 + % version 4.2 : + \gdef\pgfplots@gnuplot@logscale@writes@log{1}% + \else + % version 4.4 or later : + \gdef\pgfplots@gnuplot@logscale@writes@log{0}% + \fi + \fi + \fi +}% + +\def\pgfplots@addplotimpl@gnuplotresult#1#2{% + \begingroup + \openin\r@pgfplots@reada=#2 + \ifeof\r@pgfplots@reada + \pgfplots@error{Sorry, the gnuplot-result file '#2' could not be found. Maybe you need to enable the shell-escape feature? For pdflatex, this is '>> pdflatex -shell-escape'. You can also invoke '>> gnuplot <file>.gnuplot' manually on the respective gnuplot file.}% + \aftergroup\pgfplots@loop@CONTINUEfalse + \else + \aftergroup\pgfplots@loop@CONTINUEtrue + \fi + \closein\r@pgfplots@reada + \endgroup + \ifpgfplots@loop@CONTINUE + % Now, invoke 'plot file'. + % + % I invoke the private '@opt@' method because the semicolon ';' + % character may cause problems due to catcode mismatches. + % *sigh*. + \pgfplots@addplotimpl@file@opt@@{}{}{#2}{#1}% this does not invoke the \pgfplots@start@plot@with@behavioroptions method. + \else + \expandafter\pgfplots@end@plot + \fi +} + +% \addplot[#1] plot[#2] shell[#3] {#4} #5; +\def\pgfplots@addplotimpl@shell#1#2shell{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@shell@opt{#1}{#2}% + }{% + \pgfplots@addplotimpl@shell@opt{#1}{#2}[]% + }% +}% +\def\pgfplots@addplotimpl@shell@opt#1#2[#3]#4#5;{\pgfplots@addplotimpl@shell@opt@{#1}{#2}{#3}{#4}{#5}}% +% \addplot[#1] [#2] shell[#3] {#4} #5; +\def\pgfplots@addplotimpl@shell@opt@#1#2#3#4#5{% + \def\pgfplotssurveyphaseinputclass{shell}% + \pgfplots@start@plot@with@behavioroptions{#1,/pgfplots/.cd,#2,/pgfplots/.cd,#3}% + \pgfplots@gettikzinternal@keyval{prefix}{tikz@plot@prefix}{\jobname.}% + \pgfplots@gettikzinternal@keyval{id}{tikz@plot@id}{pgf-shell}% + % + \def\pgfplots@plot@filename{\tikz@plot@prefix\tikz@plot@id}% + \def\pgfplots@plot@data{\pgfshell[\pgfplots@plot@filename]{#4}\pgfplotxyfile{\pgfplots@plot@filename.out}}% + \def\pgfplotxyfile{\pgfplots@addplotimpl@shellresult{#5}}% + \pgfplots@plot@data + \let\pgfplotxyfile=\pgfplots@backupof@pgfplotxyfile +}% + +\def\pgfplots@addplotimpl@shellresult#1#2{% + \begingroup + \openin\r@pgfplots@reada=#2 + \ifeof\r@pgfplots@reada + \pgfplots@error{Sorry, the shell-result file '#2' could not be found. Maybe you need to enable the shell-escape feature? For pdflatex, this is '>> pdflatex -shell-escape'. You can also invoke '>> sh <file>.sh > <file>.out' manually on the respective shell file.}% + \aftergroup\pgfplots@loop@CONTINUEfalse + \else + \aftergroup\pgfplots@loop@CONTINUEtrue + \fi + \closein\r@pgfplots@reada + \endgroup + \ifpgfplots@loop@CONTINUE + % Now, invoke 'plot file'. + % + % I invoke the private '@opt@' method because the semicolon ';' + % character may cause problems due to catcode mismatches. + % *sigh*. + \pgfplots@addplotimpl@file@opt@@{}{}{#2}{#1}% + \else + \expandafter\pgfplots@end@plot + \fi +} + +% \addplot[#1] [#2] file{#3} #4; +\def\pgfplots@addplotimpl@file#1#2e{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@file@opt{#1}{#2}% + }{% + \pgfplots@addplotimpl@file@opt{#1}{#2}[]% + }% +} + +% \addplot[#1] [#2] file[#3] {#4} #5; +\def\pgfplots@addplotimpl@file@opt#1#2[#3]#4#5;{\pgfplots@addplotimpl@file@opt@{#1}{#2}{#3}{#4}{#5}}% +\def\pgfplots@addplotimpl@file@opt@#1#2#3#4#5{% + % invoke this here - allows to share the 'plot file' impl with + % 'plot gnuplot'. + \def\pgfplotssurveyphaseinputclass{file}% + \pgfplots@start@plot@with@behavioroptions{#1,/pgfplots/.cd,#2}% + \pgfplots@addplotimpl@file@opt@@{#1,#2}{#3}{#4}{#5}% +} +\def\pgfplots@addplotimpl@file@opt@@#1#2#3#4{% + \begingroup + \def\pgfplots@loc@TMPa{#2}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \pgfqkeys{/pgfplots/plot file}{#2}% + \fi + \pgfplots@PREPARE@COORD@STREAM{#4}% + \pgfplots@addplotimpl@file@streamit{#3}% + \endgroup +}% +% #1: the file name +\def\pgfplots@addplotimpl@file@streamit#1{% + \pgfplots@coord@stream@start + \pgfplotsscanlinelengthinitzero + \openin\r@pgfplots@reada=#1 + \ifeof\r@pgfplots@reada + \pgfplots@error{sorry, plot file{#1} could not be opened}% + \else + \pgfplots@logfileopen{#1}% + \let\pgfplots@current@point@error@x@plus=\pgfutil@empty + \let\pgfplots@current@point@error@x@minus=\pgfutil@empty + \let\pgfplots@current@point@error@y@plus=\pgfutil@empty + \let\pgfplots@current@point@error@y@minus=\pgfutil@empty + \let\pgfplots@current@point@error@z@plus=\pgfutil@empty + \let\pgfplots@current@point@error@z@minus=\pgfutil@empty + \let\pgfplots@current@point@meta=\pgfutil@empty + \ifpgfplots@curplot@threedim + \let\pgfplots@addplotimpl@file@parsesingle=\pgfplots@addplotimpl@file@parsesingle@threedim + \if1\csname pgfpmeta@\pgfplotspointmetainputhandler @explicitinput\endcsname + \let\pgfplots@addplotimpl@file@parsesingle=\pgfplots@addplotimpl@file@parsesingle@threedim@andmeta + \fi + \else + \let\pgfplots@addplotimpl@file@parsesingle=\pgfplots@addplotimpl@file@parsesingle@twodim + \if1\csname pgfpmeta@\pgfplotspointmetainputhandler @explicitinput\endcsname + \let\pgfplots@addplotimpl@file@parsesingle=\pgfplots@addplotimpl@file@parsesingle@twodim@andmeta + \fi + \fi + \pgfplotstableinstallignorechars% + \pgfplots@addplotimpl@file@readall + \fi + \pgfplotsscanlinelengthcleanup + \pgfplots@coord@stream@end +}% +\def\pgfplots@addplotimpl@file@readall{% + \read\r@pgfplots@reada to\pgfplots@file@LINE + \expandafter\pgfplotstableread@checkspecial@line\pgfplots@file@LINE\pgfplotstable@EOI + \ifpgfplotstableread@skipline + \else + \ifpgfplots@plot@file@skipfirst + % Silently skip first data row, assuming it is a header. + \pgfplots@plot@file@skipfirstfalse + \else + \pgfplotsscanlinelengthincrease + \expandafter\pgfplots@addplotimpl@file@parsesingle\pgfplots@file@LINE 0 0 0 0 0\pgfplots@EOI + \fi + \fi + \ifeof\r@pgfplots@reada + \else + \expandafter + \pgfplots@addplotimpl@file@readall + \fi +}% + +\def\pgfplots@addplotimpl@file@parsesingle@threedim#1 #2 #3 #4\pgfplots@EOI{% + \def\pgfplots@current@point@x{#1}% + \def\pgfplots@current@point@y{#2}% + \def\pgfplots@current@point@z{#3}% + \pgfplots@coord@stream@coord% +}% +\def\pgfplots@addplotimpl@file@parsesingle@twodim#1 #2 #3\pgfplots@EOI{% + \def\pgfplots@current@point@x{#1}% + \def\pgfplots@current@point@y{#2}% + \pgfplots@coord@stream@coord% +}% +\def\pgfplots@addplotimpl@file@parsesingle@threedim@andmeta#1 #2 #3 #4 #5\pgfplots@EOI{% + \def\pgfplots@current@point@x{#1}% + \def\pgfplots@current@point@y{#2}% + \def\pgfplots@current@point@z{#3}% + \def\pgfplots@current@point@meta{#4}% + \pgfplots@coord@stream@coord% +}% +\def\pgfplots@addplotimpl@file@parsesingle@twodim@andmeta#1 #2 #3 #4\pgfplots@EOI{% + \def\pgfplots@current@point@x{#1}% + \def\pgfplots@current@point@y{#2}% + \def\pgfplots@current@point@meta{#3}% + \pgfplots@coord@stream@coord% +}% + + +\def\pgfplots@addplotimpl@graphics#1#2raphics{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@graphics@{#1}{#2}% + }{% + \pgfplots@addplotimpl@graphics@{#1}{#2}[]% + }% +}% +% \addplot[#1] plot[#2] graphics[#3] {#4} #5; +\long\def\pgfplots@addplotimpl@graphics@#1#2[#3]#4#5;{\pgfplots@addplotimpl@graphics@@{#1}{#2}{#3}{#4}{#5}}% +\long\def\pgfplots@addplotimpl@graphics@@#1#2#3#4#5{% + \def\pgfplotssurveyphaseinputclass{graphics}% + \pgfplots@start@plot@with@behavioroptions{% + /pgfplots/filter discard warning=false, + /pgfplots/mesh/rows=2,% allow \addplot[surf] graphics ... --> yields a good legend. + /pgfplots/mesh/cols=2, + /pgfplots/mesh/check=false, + #1,/pgfplots/.cd,#2,% + /pgfplots/plot graphics/@prepare legend, + /pgfplots/plot graphics,% + /pgfplots/plot graphics/.cd,% + #3,% + /pgfplots/plot graphics/src={#4},% + /tikz/mark=}% + \pgfplots@PREPARE@COORD@STREAM{#5}% + \pgfplots@coord@stream@start + % + \pgfkeysgetvalue{/pgfplots/plot graphics/points}{\pgfplots@current@point@points}% + \ifx\pgfplots@current@point@points\pgfutil@empty + \else + \let\pgfplotsplothandlergraphicspointmappoint=\pgfplotsplothandlergraphics@survey@pointmappoint + \expandafter\pgfplots@plot@handler@graphics@parsepointmap\expandafter{\pgfplots@current@point@points}% + \ifpgfplots@plot@graphics@autoadjustaxis + \pgfplotsplothandlergraphicspointmapcomputerequiredview + \ifx\pgfplotsretval\pgfutil@empty + \else + \expandafter\pgfplotssetlateoptions\expandafter{\pgfplotsretval}% + \fi + \fi + % + \def\pgfplots@addplotimpl@graphics@@error##1{}% + \fi + % + \pgfkeysgetvalue{/pgfplots/plot graphics/xmin}{\pgfplots@current@point@x}% + \pgfkeysgetvalue{/pgfplots/plot graphics/ymin}{\pgfplots@current@point@y}% + % + % these sanity checks do nothing of the 'plot graphics/points' feature has been used: + \ifx\pgfplots@current@point@x\pgfutil@empty\pgfplots@addplotimpl@graphics@@error{xmin}\fi + \ifx\pgfplots@current@point@y\pgfutil@empty\pgfplots@addplotimpl@graphics@@error{ymin}\fi + \ifpgfplots@curplot@threedim + \pgfkeysgetvalue{/pgfplots/plot graphics/zmin}{\pgfplots@current@point@z}% + \ifx\pgfplots@current@point@z\pgfutil@empty\pgfplots@addplotimpl@graphics@@error{zmin}\fi + \fi + \pgfplots@coord@stream@coord + % + \pgfkeysgetvalue{/pgfplots/plot graphics/xmax}{\pgfplots@current@point@x}% + \pgfkeysgetvalue{/pgfplots/plot graphics/ymax}{\pgfplots@current@point@y}% + \ifx\pgfplots@current@point@x\pgfutil@empty\pgfplots@addplotimpl@graphics@@error{xmax}\fi + \ifx\pgfplots@current@point@y\pgfutil@empty\pgfplots@addplotimpl@graphics@@error{ymax}\fi + \ifpgfplots@curplot@threedim + \pgfkeysgetvalue{/pgfplots/plot graphics/zmax}{\pgfplots@current@point@z}% + \ifx\pgfplots@current@point@z\pgfutil@empty\pgfplots@addplotimpl@graphics@@error{zmax}\fi + \fi + \pgfplots@coord@stream@coord + % + \pgfplots@coord@stream@end +}% +\def\pgfplots@addplotimpl@graphics@@error#1{% + \begingroup + \pgfplots@error{Sorry, but 'plot graphics' can't determine where to place the graphics file - (at least) the key '#1' is missing. Please verify that you provided all required limits, for example 'plot graphics[xmin=0,xmax=1,ymin=0,ymax=1] {<graphics>}'.}% + \endgroup +}% + + + + +% \addplot[#1] table[#2] [from] {<\macro>} #4; +% or +% \addplot[#1] table[#2] {<filename>} #4; +% +% The distinction between <\macro> and <filename> is done +% automatically. +% +% Input options can be provided in '#2' using +% - column names, +% for example '/pgfplots/table/x=firstcol' or just 'x=firstcol' +% +% - column indices, +% for example '/pgfplots/table/x index=3' or just 'x index=3' +% +% - expressions involving any of the table's data cells in the +% currently processed cell, +% for example '/pgfplots/table/x expr={\columnx * \columny + \thisrow{columnxxx}/2}' +% During expr, the following (non-exhaustive) list of macros is +% available: +% - \columnx, \columny, \columnz, \columnmeta, \columnerrorx, +% \columnerrory, \columnerrorz +% Provide access to the cell content which would be used without +% 'expr'. +% The first three access the input coordinate columns, \meta the meta column +% (if any) and the last three the error data (if any). +% +% That means it is allowed to provide both, 'x' and 'x expr': +% 'x expr' can use the (old) value stored in 'x'. the final x +% coordinate will be that returned of 'x expr'. +% +% - \coordindex +% +% - \lineno (physical line numbers including comments etc) +% +% - \thisrow{<colname>} +% allows access to any columns. +% +% - \getthisrow{<colname>}{<\macro>} +% this is a fragile command! Don't use it directly inside of +% a math expression, prefer \thisrow. +% +% The FPU will be used to evaluate any expressions. +% +% @REMARKS the implementation for '* expr' differs for the '<\macro>' +% and '<filename>' input types: +% - for '{<filename>}', only the current row is available. +% - for '{<\macro>}', the `create on use' framework of the table +% package is used - with all its features, including comfortable +% access to the previous and next row and accumulation features. +\def\pgfplots@addplotimpl@table#1table{% + \pgfplotsutil@ifnextchar[{% + \pgfplots@addplotimpl@table@getopts{#1}% + }{% + \pgfplots@addplotimpl@table@getopts{#1}[]% + }% +}% + +\def\pgfplots@addplotimpl@table@getopts#1[#2]{% + % set options outside of the following group. + % They may contain behavior options. + \pgfplots@addplotimpl@table@installkeypath + \pgfplotstableset{#2}% + % + \pgfplotsutil@ifnextchar s{% + \pgfplots@addplotimpl@table@fromshell{#1}{#2}% + }{% + \pgfplotsutil@ifnextchar f{% + \pgfplots@addplotimpl@table@fromstructure@gobble@space{#1}{#2}% + }{% + \pgfplots@addplotimpl@table@fromfile@gobble@space{#1}{#2}% + }% + }% +} + +% this macro simply invokes the "correct" table processing routine. +% The distinction between 'table from {<\macro>}' and 'table +% {<filename>}' is deprecated; it is done automatically now. +% +% \addplot[#1] table[#2] [from] {#3} #4; +\def\pgfplots@addplotimpl@table@startprocessing#1#2#3#4{% + \pgfplotstable@isloadedtable{#3}{% + \pgfplots@addplotimpl@table@fromstructure@{#1}{#2}{#3}{#4}% + }{% + \pgfplots@addplotimpl@table@fromfile@{#1}{#2}{#3}{#4}% + }% +}% + +% \addplot[#1] table[#2] from {#3} #4; +% +% #1: arguments to \addplot[...] +% #2: arguments to table[...] (already processed!) +% #3: the argument of plot table{...} +% #4: trailing path arguments after plot table{...}#4; +\long\def\pgfplots@addplotimpl@table@fromstructure@gobble@space#1#2from{% + \pgfplotstablecollectoneargwithpreparecatcodes{% + \pgfplots@addplotimpl@table@fromstructure{#1}{#2}from% + }% +}% + +\def\pgfplots@addplot@table@fromstructure@preparecolname#1#2#3#4{% + \pgfkeysgetvalue{/pgfplots/table/#1}{\pgfplots@loc@TMPa}% + % + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \pgfkeysgetvalue{/pgfplots/table/#1 index}{\pgfplots@loc@TMPa}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \pgfplotstablegetcolumnnamebyindex\pgfplots@loc@TMPa\of#2\to\pgfplots@loc@TMPa + \fi + \fi + \let#3=\pgfplots@loc@TMPa + % + % modify \pgfplots@plot@tbl@{x,y,z,meta} if there are + % corresponding '#1 expr' statements: + \pgfplots@addplotimpl@table@fromstructure@prepareexpr@for{#1}{#3}{#4}% +} + +% Invokes `#1' if the command is invoked within +% \addplot table {<\macro>}; +% and `#2' if not. +\def\pgfplotsifinaddplottablestruct#1#2{% + \pgfutil@ifundefined{pgfplots@plot@tbl@meta}{#2}{#1}% +}% + +\long\def\pgfplots@addplotimpl@table@fromstructure#1#2from#3#4;{\pgfplots@addplotimpl@table@startprocessing{#1}{#2}{#3}{#4}}% +% \addplot[#1] table[#2] from {#3} #4 ; +\long\def\pgfplots@addplotimpl@table@fromstructure@#1#2#3#4{% + \begingroup + \def\pgfplotstablename{#3}% store the name of the currently processed table. + \pgfplotstablegetscanlinelength{#3}{\pgfplotsscanlinelength}% + % FIXME : this thing here has runtime O(N^2) ! + % I fear it is faster to simply reload the data .... !? + % + % well, for a lot of columns which are used in different contexts + % and few rows, this here IS more efficient. + % + \pgfplots@addplot@table@fromstructure@preparecolname{x}{#3}\pgfplots@plot@tbl@x\columnx + \pgfplots@addplot@table@fromstructure@preparecolname{y}{#3}\pgfplots@plot@tbl@y\columny + \ifpgfplots@curplot@threedim + \pgfplots@addplot@table@fromstructure@preparecolname{z}{#3}\pgfplots@plot@tbl@z\columnz + \fi + \pgfplots@addplot@table@fromstructure@preparecolname{meta}{#3}\pgfplots@plot@tbl@meta\columnmeta + % + % + % high level user interface functions: + \let\pgfplotstable@coordindex@old=\coordindex + \def\coordindex{\pgfplotstablerow}% + \def\lineno{\coordindex}% is the same here + % These macros are-unfortunately- not accessable here. And the + % worst is: error messages are impossible either because they are + % not executed... try to provide useful hints: + \def\thisrow##1{thisrow_unavailable_load_table_directly}% + \def\thisrowno##1{thisrowno_unavailable_load_table_directly}% + % this should work. + \def\getthisrow##1##2{\pgfplotstablegetelem{\coordindex}{##1}\of{#3}{##2}}% + \def\getthisrowno##1##2{\pgfplotstablegetelem{\coordindex}{[index]##1}\of{#3}{##2}}% + % + \expandafter\pgfplotstablegetcolumnbyname\expandafter{\pgfplots@plot@tbl@x}\of#3\to\addplot@tbl@x + \expandafter\pgfplotstablegetcolumnbyname\expandafter{\pgfplots@plot@tbl@y}\of#3\to\addplot@tbl@y + \ifpgfplots@curplot@threedim + \expandafter\pgfplotstablegetcolumnbyname\expandafter{\pgfplots@plot@tbl@z}\of#3\to\addplot@tbl@z + \fi + % + \let\addplot@tbl@meta=\pgfutil@empty + \ifx\pgfplots@plot@tbl@meta\pgfutil@empty + \else + \expandafter\pgfplotstablegetcolumnbyname\expandafter{\pgfplots@plot@tbl@meta}\of#3\to\addplot@tbl@meta + \fi + % + % + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@init x{#3}{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@init x{#3}{minus}% + % + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@init y{#3}{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@init y{#3}{minus}% + % + \ifpgfplots@curplot@threedim + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@init z{#3}{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@init z{#3}{minus}% + \fi + % + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@load x{#3}{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@load x{#3}{minus}% + % + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@load y{#3}{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@load y{#3}{minus}% + \ifpgfplots@curplot@threedim + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@load z{#3}{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@load z{#3}{minus}% + \fi + % + \let\coordindex=\pgfplotstable@coordindex@old + % + \pgfplots@PREPARE@COORD@STREAM{#4}% + \pgfplots@coord@stream@start + \pgfutil@loop + \pgfplotslistcheckempty\addplot@tbl@x + \ifpgfplotslistempty + \pgfplots@loop@CONTINUEfalse + \else + % This here is just for sanity checking: if the 'y' column is + % - for whatever reasons - invalid; provide good error + % recovery. + \pgfplotslistcheckempty\addplot@tbl@y + \ifpgfplotslistempty + \pgfplots@loop@CONTINUEfalse + \else + \pgfplots@loop@CONTINUEtrue + \fi + \fi + \ifpgfplots@loop@CONTINUE + \pgfplotslistpopfront\addplot@tbl@x\to\pgfplots@current@point@x + \pgfplotslistpopfront\addplot@tbl@y\to\pgfplots@current@point@y + \ifpgfplots@curplot@threedim + \pgfplotslistpopfront\addplot@tbl@z\to\pgfplots@current@point@z + \fi + \ifx\addplot@tbl@meta\pgfutil@empty + \else + \pgfplotslistpopfront\addplot@tbl@meta\to\pgfplots@current@point@meta + \fi + \ifpgfplots@errorbars@enabled + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@getnext x{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@getnext x{minus}% + % + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@getnext y{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@getnext y{minus}% + % + \ifpgfplots@curplot@threedim + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@getnext z{plus}% + \pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@getnext z{minus}% + \fi + \fi + \pgfplots@coord@stream@coord + \pgfutil@repeat + \pgfplots@coord@stream@end + \pgfmath@smuggleone\pgfplotsscanlinelength + \endgroup +} + +% #1: x, y, or z +% #2: the table name +% #3: either "plus" or "minus" +\def\pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@init#1#2#3{% + \expandafter\let\csname addplot@tbl@error@#1@#3\endcsname=\pgfutil@empty + \expandafter\let\csname pgfplots@current@point@error@#1@#3\endcsname=\pgfutil@empty + \ifpgfplots@errorbars@enabled + % prepare with suitable expansion: + \def\pgfplots@loc@TMPa{% + \pgfplots@addplot@table@fromstructure@preparecolname{#1 error #3}{#2}}% + \edef\pgfplots@loc@TMPb{% + \expandafter\noexpand\csname pgfplots@plot@tbl@error@#1@#3\endcsname + % FIXME : these macros are UNDOCUMENTED! I suppose they are dead code... + \expandafter\noexpand\csname columnerror#1\endcsname + }% + % execute prepared statement: + % = \pgfplots@addplot@table@fromstructure@preparecolname + % {x error plus}{#2}{\pgfplots@plot@tbl@error@x@plus}{\columnerrorx} + \expandafter\pgfplots@loc@TMPa\pgfplots@loc@TMPb + % + \fi +}% + +% #1: x, y, or z +% #2: the table name +% #3: either "plus" or "minus" +\def\pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@load#1#2#3{% + \ifpgfplots@errorbars@enabled + \expandafter\ifx\csname pgfplots@plot@tbl@error@#1@#3\endcsname\pgfutil@empty + % ok, we do not have this error kind. + \else + % assemble the statement + % \expandafter\pgfplotstablegetcolumnbyname\expandafter{\pgfplots@plot@tbl@error@x@plus}\of#2\to\addplot@tbl@error@x@plus + % -> but with suitable expansion restrictions. + \edef\pgfplots@loc@TMPa{\expandafter\noexpand\csname pgfplots@plot@tbl@error@#1@#3\endcsname}% + % + \def\pgfplots@loc@TMPb{% + \expandafter\pgfplotstablegetcolumnbyname\expandafter{\pgfplots@loc@TMPa}\of#2\to + }% + \expandafter\pgfplots@loc@TMPb\csname addplot@tbl@error@#1@#3\endcsname + \fi + \fi +}% + +% #1: x, y, or z +% #2: either "plus" or "minus" +\def\pgfplots@addplotimpl@table@fromstructure@prepare@errorbar@getnext#1#2{% + \expandafter\ifx\csname addplot@tbl@error@#1@#2\endcsname\pgfutil@empty + \expandafter\let\csname pgfplots@current@point@error@#1@#2\endcsname=\pgfutil@empty + \else + \expandafter\pgfplotslistpopfront\csname addplot@tbl@error@#1@#2\endcsname\to\pgfplots@loc@TMPa + \expandafter\let\csname pgfplots@current@point@error@#1@#2\endcsname=\pgfplots@loc@TMPa + \fi +}% + +% A private helper macro which initialises the '#1 expr' keys for plot +% table from structure. +% +% PRECONDITION: +% \pgfplots@plot@tbl@#1 contains the column name which would be used +% if '#1 expr' is empty. +% +% POSTCONDITION: +% \pgfplots@plot@tbl@#1 will be CHANGED to use the 'expr' column (a +% temporary name). +% The old value of \pgfplots@plot@tbl@#1 is available as column +% alias. +% the high level user interface command '#3' will be set correctly. +% +% #1: the key name of the current entity, for example 'x' for +% '/pgfplots/table/x' +% #2: the low level column name representing the data which is already +% defined somehow +% #3: a high level user interface command +\def\pgfplots@addplotimpl@table@fromstructure@prepareexpr@for#1#2#3{% + % get old column name into a register: + \t@pgfplots@tokb=\expandafter{#2}% + % + % high level user interface command: + \edef#3{\noexpand\thisrow{\the\t@pgfplots@tokb}}% + % + \pgfkeysgetvalue{/pgfplots/table/#1 expr}{\pgfplots@loc@TMPa}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + % get expression into register: + \t@pgfplots@toka=\expandafter{\pgfplots@loc@TMPa}% + % + % + % assemble pgfkeys statement which expands the names above + % just one time: + \edef\pgfplots@loc@TMPa{% + /pgfplots/table/create on use/#1expr@tempcol/.style={% + /pgfplots/table/create col/expr={\the\t@pgfplots@toka}% + },% + /pgfplots/table/alias/#1/.initial={\the\t@pgfplots@tokb}% + }% + \expandafter\pgfkeysalso\expandafter{\pgfplots@loc@TMPa}% + % + % tell `plot table' which column should be used for '#1': the + % temporary column. + \def#2{#1expr@tempcol}% + \fi +}% + + +% \addplot[#1] table[#2] {#3} #4; +% +% This here is the (probably) faster input method from tables. +% +% It has linear complexity in the number of rows (as long as the +% number of rows is less than about 110000). +% +% #1: arguments to \addplot[...] +% #2: arguments to table[...] (already processed!) +% #3: the argument of plot table{...} +% #4: trailing path arguments after plot table{...}#4; +% +\long\def\pgfplots@addplotimpl@table@fromfile@gobble@space#1#2{% + \pgfplotstablecollectoneargwithpreparecatcodes{% + \pgfplots@addplotimpl@table@fromfile{#1}{#2}% + }% +}% +\long\def\pgfplots@addplotimpl@table@fromfile#1#2#3#4;{\pgfplots@addplotimpl@table@startprocessing{#1}{#2}{#3}{#4}}% +% \addplot[#1] table[#2] {#3} {#4}; +\long\def\pgfplots@addplotimpl@table@fromfile@#1#2#3#4{% + \if1\pgfplots@addplotimpl@readcompletely@auto + \pgfplots@addplotimpl@table@check@createonuse@for{x}% + \pgfplots@addplotimpl@table@check@createonuse@for{y}% + \ifpgfplots@curplot@threedim + \pgfplots@addplotimpl@table@check@createonuse@for{z}% + \fi + \pgfplots@addplotimpl@table@check@createonuse@for{x error plus}% + \pgfplots@addplotimpl@table@check@createonuse@for{x error minus}% + \pgfplots@addplotimpl@table@check@createonuse@for{y error plus}% + \pgfplots@addplotimpl@table@check@createonuse@for{y error minus}% + \ifpgfplots@curplot@threedim + \pgfplots@addplotimpl@table@check@createonuse@for{z error plus}% + \pgfplots@addplotimpl@table@check@createonuse@for{z error minus}% + \fi + \pgfplots@addplotimpl@table@check@createonuse@for{meta}% + \fi + % + \ifpgfplots@addplotimpl@readcompletely + \pgfplotstableread{#3}\pgfplots@table + \pgfplots@addplotimpl@table@fromstructure@{#1}{}{\pgfplots@table}{#4}% + \else + \pgfplotsapplistXXglobalnewempty + % + % these data pointers will be prepared to allow fast access + % into the current row while we read rows succesively from + % disk. + % Note: their initialisation must be postponed until + % \pgfplotstableread is running - otherwise, we can't query + % pointers into the table. See below. + \let\pgfplots@table@PTR@x=\pgfutil@empty + \let\pgfplots@table@PTR@y=\pgfutil@empty + \let\pgfplots@table@PTR@z=\pgfutil@empty + \let\pgfplots@table@PTR@meta=\pgfutil@empty + % + % + \let\pgfplots@current@point@meta=\pgfutil@empty + \let\pgfplots@current@point@z=\pgfutil@empty + % + % high level user interface functions: + \def\lineno{\pgfplotstablelineno}% + \def\columnx{\pgfplotstablereadvalueofptr{\pgfplots@table@PTR@x}}% + \def\columny{\pgfplotstablereadvalueofptr{\pgfplots@table@PTR@y}}% + \def\columnz{\pgfplotstablereadvalueofptr{\pgfplots@table@PTR@z}}% + \def\columnmeta{\pgfplotstablereadvalueofptr{\pgfplots@table@PTR@meta}}% + % + \pgfplots@PREPARE@COORD@STREAM{#4}% + \pgfplots@coord@stream@start + \ifpgfplots@errorbars@enabled + % more fast-access pointers for error data: + \let\pgfplots@table@ERRPTR@x=\pgfutil@empty + \let\pgfplots@table@ERRPTR@y=\pgfutil@empty + \let\pgfplots@table@ERRPTR@z=\pgfutil@empty + % + % prepare: + \let\pgfplots@current@point@error@x@plus=\pgfutil@empty + \let\pgfplots@current@point@error@x@minus=\pgfutil@empty + \let\pgfplots@current@point@error@y@plus=\pgfutil@empty + \let\pgfplots@current@point@error@y@minus=\pgfutil@empty + \let\pgfplots@current@point@error@z@plus=\pgfutil@empty + \let\pgfplots@current@point@error@z@minus=\pgfutil@empty + % + % high level user interface functions: + % FIXME : these macros are UNDOCUMENTED! I suppose they are dead code... + \def\columnerrorx{\pgfplotstablereadvalueofptr{\pgfplots@table@ERRPTR@x}}% + \def\columnerrory{\pgfplotstablereadvalueofptr{\pgfplots@table@ERRPTR@y}}% + \def\columnerrorz{\pgfplotstablereadvalueofptr{\pgfplots@table@ERRPTR@z}}% + % + \pgfplotstableread*{#3} to listener\pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL + \else + \pgfplotstableread*{#3} to listener\pgfplots@addplotimpl@table@fromfile@listener@COLLECTNORMALIZED + \fi + \pgfplots@coord@stream@end + \fi +} +\def\pgfplots@addplotimpl@table@check@createonuse@for#1{% + \pgfkeysgetvalue{/pgfplots/table/#1}\pgfplots@addplotimpl@table@check@createonuse@for@ + \expandafter\pgfplotstableifiscreateonuse\expandafter{\pgfplots@addplotimpl@table@check@createonuse@for@}{% + \pgfplots@addplotimpl@readcompletelytrue + }{% + }% +}% +\def\pgfplots@addplotimpl@table@fromfile@listener@COLLECTNORMALIZED{% + \pgfplots@addplotimpl@table@fromfile@listener@ + \pgfplots@coord@stream@coord +} +\def\pgfplots@addplotimpl@table@fromfile@listener@PREPARE{% + % this here is only evaluated ONCE. + \pgfkeysgetvalue{/pgfplots/table/x}{\pgfplots@plot@tbl@x}% + \pgfkeysgetvalue{/pgfplots/table/x index}{\pgfplots@plot@tbl@xindex}% + \pgfkeysgetvalue{/pgfplots/table/y}{\pgfplots@plot@tbl@y}% + \pgfkeysgetvalue{/pgfplots/table/y index}{\pgfplots@plot@tbl@yindex}% + \pgfkeysgetvalue{/pgfplots/table/z}{\pgfplots@plot@tbl@z}% + \pgfkeysgetvalue{/pgfplots/table/z index}{\pgfplots@plot@tbl@zindex}% + \pgfkeysgetvalue{/pgfplots/table/meta}{\pgfplots@plot@tbl@meta}% + \pgfkeysgetvalue{/pgfplots/table/meta index}{\pgfplots@plot@tbl@metaindex}% + % + \pgfkeysgetvalue{/pgfplots/table/x expr}{\pgfplots@loc@TMPa}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \def\pgfplots@dereferencepointer@and@ASSIGN@x{% + \pgfplotstablereadevalptr\pgfplots@table@PTR@x\pgfplots@current@point@x + }% + \else + \def\pgfplots@dereferencepointer@and@ASSIGN@x{% + \pgfmathparse{\pgfkeysvalueof{/pgfplots/table/x expr}}% + \let\pgfplots@current@point@x=\pgfmathresult + }% + \fi + % + \pgfkeysgetvalue{/pgfplots/table/y expr}{\pgfplots@loc@TMPa}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \def\pgfplots@dereferencepointer@and@ASSIGN@y{% + \pgfplotstablereadevalptr\pgfplots@table@PTR@y\pgfplots@current@point@y + }% + \else + \def\pgfplots@dereferencepointer@and@ASSIGN@y{% + \pgfmathparse{\pgfkeysvalueof{/pgfplots/table/y expr}}% + \let\pgfplots@current@point@y=\pgfmathresult + }% + \fi + % + \ifx\pgfplots@plot@tbl@x\pgfutil@empty + \pgfplotstablereadgetptrtocolindex{\pgfplots@plot@tbl@xindex}{\pgfplots@table@PTR@x}% + \else + \pgfplotstablereadgetptrtocolname{\pgfplots@plot@tbl@x}{\pgfplots@table@PTR@x}% + \fi + \ifx\pgfplots@plot@tbl@y\pgfutil@empty + \pgfplotstablereadgetptrtocolindex{\pgfplots@plot@tbl@yindex}{\pgfplots@table@PTR@y}% + \else + \pgfplotstablereadgetptrtocolname{\pgfplots@plot@tbl@y}{\pgfplots@table@PTR@y}% + \fi + \ifpgfplots@curplot@threedim + % + \pgfkeysgetvalue{/pgfplots/table/z expr}{\pgfplots@loc@TMPa}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \def\pgfplots@dereferencepointer@and@ASSIGN@z{% + \pgfplotstablereadevalptr\pgfplots@table@PTR@z\pgfplots@current@point@z + }% + \else + \def\pgfplots@dereferencepointer@and@ASSIGN@z{% + \pgfmathparse{\pgfkeysvalueof{/pgfplots/table/z expr}}% + \let\pgfplots@current@point@z=\pgfmathresult + }% + \fi + \ifx\pgfplots@plot@tbl@z\pgfutil@empty + \pgfplotstablereadgetptrtocolindex{\pgfplots@plot@tbl@zindex}{\pgfplots@table@PTR@z}% + \else + \pgfplotstablereadgetptrtocolname{\pgfplots@plot@tbl@z}{\pgfplots@table@PTR@z}% + \fi + \else + \let\pgfplots@dereferencepointer@and@ASSIGN@z=\relax + \fi + % + % + \def\pgfplots@dereferencepointer@and@ASSIGN@meta{% + \pgfplotstablereadevalptr\pgfplots@table@PTR@meta\pgfplots@current@point@meta + }% + \ifx\pgfplots@plot@tbl@meta\pgfutil@empty + \ifx\pgfplots@plot@tbl@metaindex\pgfutil@empty + \let\pgfplots@dereferencepointer@and@ASSIGN@meta=\relax + \else + \pgfplotstablereadgetptrtocolindex{\pgfplots@plot@tbl@metaindex}{\pgfplots@table@PTR@meta}% + \fi + \else + \pgfplotstablereadgetptrtocolname{\pgfplots@plot@tbl@meta}{\pgfplots@table@PTR@meta}% + \fi + \pgfkeysgetvalue{/pgfplots/table/meta expr}{\pgfplots@loc@TMPa}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \def\pgfplots@dereferencepointer@and@ASSIGN@meta{% + \pgfmathparse{\pgfkeysvalueof{/pgfplots/table/meta expr}}% + \let\pgfplots@current@point@meta=\pgfmathresult + }% + \fi + \let\pgfplots@addplotimpl@table@fromfile@listener@PREPARE=\relax +}% +\def\pgfplots@addplotimpl@table@fromfile@listener@{% + \pgfplots@addplotimpl@table@fromfile@listener@PREPARE + \pgfplots@dereferencepointer@and@ASSIGN@x + \pgfplots@dereferencepointer@and@ASSIGN@y + \pgfplots@dereferencepointer@and@ASSIGN@z + \pgfplots@dereferencepointer@and@ASSIGN@meta +}% + +% #1: x, y, or z +% #2: either "plus" or "minus" +\def\pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare@#1#2{% + \pgfkeysgetvalue{/pgfplots/table/#1 error #2 index}\pgfplots@plot@tbl@error@index + \pgfkeysgetvalue{/pgfplots/table/#1 error #2}\pgfplots@plot@tbl@error + % + \expandafter\def\csname pgfplots@table@ERRPTR@#1@#2\endcsname{#1 error #2}% + % + \expandafter\def\csname pgfplots@dereferencepointer@and@ASSIGN@error@#1@#2\endcsname{% + \expandafter\pgfplotstablereadevalptr\csname pgfplots@table@ERRPTR@#1@#2\endcsname\pgfmathresult + \expandafter\let\csname pgfplots@current@point@error@#1@#2\endcsname=\pgfmathresult + }% + % + \ifx\pgfplots@plot@tbl@error\pgfutil@empty + \ifx\pgfplots@plot@tbl@error@index\pgfutil@empty + \let\pgfplotsretval=\relax + \expandafter\let\csname pgfplots@dereferencepointer@and@ASSIGN@error@#1@#2\endcsname=\relax + \else + \pgfplotstablereadgetptrtocolindex{\pgfplots@plot@tbl@error@index}{\pgfplotsretval}% + \fi + \else + \pgfplotstablereadgetptrtocolname{\pgfplots@plot@tbl@error}{\pgfplotsretval}% + \fi + \expandafter\let\csname pgfplots@table@ERRPTR@#1@#2\endcsname=\pgfplotsretval + % + \pgfkeysgetvalue{/pgfplots/table/#1 error #2 expr}{\pgfplots@loc@TMPa}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \expandafter\def\csname pgfplots@dereferencepointer@and@ASSIGN@error@#1@#2\endcsname{% + \pgfmathparse{\pgfkeysvalueof{/pgfplots/table/#1 error #2 expr}}% + \expandafter\let\csname pgfplots@current@point@error@#1@#2\endcsname=\pgfmathresult + }% + \fi +}% + +\def\pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare{% + % this here is only evaluated ONCE. + \pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare@ x{plus}% + \pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare@ x{minus}% + \pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare@ y{plus}% + \pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare@ y{minus}% + % + \ifpgfplots@curplot@threedim + \pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare@ z{plus}% + \pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare@ z{minus}% + \else + \let\pgfplots@dereferencepointer@and@ASSIGN@error@z@plus=\relax + \let\pgfplots@dereferencepointer@and@ASSIGN@error@z@minus=\relax + \fi + \let\pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare=\relax +} +\def\pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL{% + \pgfplots@addplotimpl@table@fromfile@listener@ + \pgfplots@addplotimpl@table@fromfile@listener@witherrors@COLLECTHIGHLEVEL@prepare + % + \pgfplots@dereferencepointer@and@ASSIGN@error@x@plus + \pgfplots@dereferencepointer@and@ASSIGN@error@x@minus + % + \pgfplots@dereferencepointer@and@ASSIGN@error@y@plus + \pgfplots@dereferencepointer@and@ASSIGN@error@y@minus + % + \ifpgfplots@curplot@threedim + \pgfplots@dereferencepointer@and@ASSIGN@error@z@plus + \pgfplots@dereferencepointer@and@ASSIGN@error@z@minus + \fi + \pgfplots@coord@stream@coord +}% +\def\pgfplots@addplotimpl@table@installkeypath{% + \pgfkeysdef{/pgfplots/table/.unknown}{% + \let\pgfplots@table@curkeyname=\pgfkeyscurrentname + \pgfqkeys{/pgfplots}{\pgfplots@table@curkeyname=##1}% + }% +}% + +% \addplot[#1] table[#2] shell{#3} #4; +% +% #1: arguments to \addplot[...] +% #2: arguments to table[...] +% #3: the argument of plot table shell{...} +% #4: trailing path arguments after plot table shell{...}#4; +\long\def\pgfplots@addplotimpl@table@fromshell#1#2shell#3#4;{% + \pgfplots@gettikzinternal@keyval{prefix}{tikz@plot@prefix}{\jobname.}% + \pgfplots@gettikzinternal@keyval{id}{tikz@plot@id}{pgf-shell}% + % + \def\pgfplots@plot@filename{\tikz@plot@prefix\tikz@plot@id}% + \pgfshell[\pgfplots@plot@filename]{#3}\pgfplots@addplotimpl@table@fromfile{#1}{#2}{\pgfplots@plot@filename.out}#4;% +}% + +% This is a backwards-compatibility method to ensure that +% \axis[ybar] +% and +% \addplot[ybar] +% work as documented. +% +% The problem: earlier versions used /pgfplots/ybar for the global +% setting and /tikz/ybar for the local one. Now, both contexts yield +% /pgfplots/ybar in contradiction to the manual. +% +% So, this macro install special handlers to restore the old setting. +\def\pgfplots@install@local@bar@handlers{% + \pgfkeysgetvalue{/pgfplots/xbar/.@cmd}\pgfplotskeys@orig@xbar + \pgfkeysgetvalue{/pgfplots/ybar/.@cmd}\pgfplotskeys@orig@ybar + \pgfkeysgetvalue{/pgfplots/xbar interval/.@cmd}\pgfplotskeys@orig@xbari + \pgfkeysgetvalue{/pgfplots/ybar interval/.@cmd}\pgfplotskeys@orig@ybari + \pgfkeysdef{/pgfplots/xbar}{% + \ifpgfkeysaddeddefaultpath + \pgfkeysalso{/tikz/xbar}% + \else + \pgfplotskeys@orig@xbar##1\pgfeov + \fi + }% + \pgfkeysdef{/pgfplots/ybar}{% + \ifpgfkeysaddeddefaultpath + \pgfkeysalso{/tikz/ybar}% + \else + \pgfplotskeys@orig@ybar##1\pgfeov + \fi + }% + \pgfkeysdef{/pgfplots/xbar interval}{% + \ifpgfkeysaddeddefaultpath + \pgfkeysalso{/tikz/xbar interval}% + \else + \pgfplotskeys@orig@xbari##1\pgfeov + \fi + }% + \pgfkeysdef{/pgfplots/ybar interval}{% + \ifpgfkeysaddeddefaultpath + \pgfkeysalso{/tikz/ybar interval}% + \else + \pgfplotskeys@orig@ybari##1\pgfeov + \fi + }% +}% + +\def\pgfplots@end@plot{% + \ifpgfplots@curplot@isirrelevant + \else + \pgfplots@countplots@advance + \fi + \pgfkeysvalueof{/pgfplots/execute at end plot@@}% + \pgfkeysvalueof{/pgfplots/execute at end plot}% + \endgroup%<-- close the \begingroup of \pgfplots@addplotimpl@plot@withoptions +} + +% \numplotsofactualtype +% Expands to the number of plots which have been seen in the current +% axis and which have the same type as the actual plot handler. +% +% See also \plotnumofactualtype +\def\pgfplots@numplotsofactualtype{% + \pgfutil@ifundefined{pgfplotssurveyphase@setactiveplothandlers@\pgfplotsplothandlername}{% + 0% + }{% + \csname c@pgfplots@numplotsofactualtype@\pgfplotsplothandlername\endcsname + }% +}% +% use this only inside of \addplot or during the visualization phase +% of a plot. +\def\pgfplots@numplotsofactualtype@duringplot{% + \pgfutil@ifundefined{pgfplotssurveyphase@setactiveplothandlers@\pgfplotsplothandlername@actual}{% + 0% + }{% + \csname c@pgfplots@numplotsofactualtype@\pgfplotsplothandlername@actual\endcsname + }% +}% +% +% +\def\pgfplots@countplots@init{% +% + % + \pgfplotssurveyphase@setactiveplothandlers + % + \let\numplotsofactualtype=\pgfplots@numplotsofactualtype@duringplot + % + % Store this name during the \addplot command. Thus, even if the + % plot handler changes, we will keep this one. + \edef\pgfplotsplothandlername@actual{\pgfplotsplothandlername}% + % + \pgfutil@ifundefined{pgfplotssurveyphase@setactiveplothandlers@\pgfplotsplothandlername@actual}{% + % oh. This is the first time \pgfplotsplothandlername was used + % in this axis. Set its counter to 0 and remember that it has + % been initialised. + \expandafter\xdef\csname c@pgfplots@numplotsofactualtype@\pgfplotsplothandlername@actual\endcsname{0}% + \t@pgfplots@toka=\expandafter{\pgfplotssurveyphase@setactiveplothandlers}% + \t@pgfplots@tokb=\expandafter{\pgfplotsplothandlername@actual}% + \xdef\pgfplotssurveyphase@setactiveplothandlers{% + \the\t@pgfplots@toka + \noexpand\expandafter\noexpand\def\noexpand\csname pgfplotssurveyphase@setactiveplothandlers@\the\t@pgfplots@tokb\noexpand\endcsname{1}% + }% + \expandafter\def\csname pgfplotssurveyphase@setactiveplothandlers@\the\t@pgfplots@tokb\endcsname{1}% + }{% + % ok. do nothing. + }% + % +}% +\def\pgfplots@countplots@advance{% + \global\advance\pgfplots@numplots by1\relax% + % + \expandafter\pgfplotsutil@advancestringcounter@global\csname c@pgfplots@numplotsofactualtype@\pgfplotsplothandlername@actual\endcsname +}% + +% \addplot[#1] [#2] {#3} #4; +\long\def\pgfplots@addplotimpl@coordinates#1#2plot coordinates#3#4;{\pgfplots@addplotimpl@coordinates@{#1}{#2}{#3}{#4}}% +% \addplot[#1] [#2] coordinates {#3} #4; +\long\def\pgfplots@addplotimpl@coordinates@#1#2#3#4{% + \def\pgfplotssurveyphaseinputclass{coordinates}% + \pgfplots@start@plot@with@behavioroptions{#1,/pgfplots/.cd,#2}% + \pgfplots@PREPARE@COORD@STREAM{#4}% + \ifpgfplots@curplot@threedim + \pgfplots@coord@stream@foreach@threedim{#3}% + \else + \pgfplots@coord@stream@foreach{#3}% + \fi +}% + +{ + % A block which handles active semicolons. + % + % ATTENTION: this block does only work if + % \pgfplots@addplotimpl.... changes are reflected here! + % + \catcode`\;=\active + \globaldefs=1 + % 'AS' == 'active semicolon' + % 'IS' == 'inactive semicolon' + \let\pgfplots@gobble@until@semicolon@IS=\pgfplots@gobble@until@semicolon + \let\pgfplots@addplotimpl@expression@IS=\pgfplots@addplotimpl@expression + \let\pgfplots@addplotimpl@expression@curly@IS=\pgfplots@addplotimpl@expression@curly + \let\pgfplots@addplotimpl@function@opt@IS=\pgfplots@addplotimpl@function@opt + \let\pgfplots@addplotimpl@file@opt@IS=\pgfplots@addplotimpl@file@opt + \let\pgfplots@addplotimpl@fillbetween@opt@IS=\pgfplots@addplotimpl@fillbetween@opt + \let\pgfplots@addplotimpl@table@fromstructure@IS=\pgfplots@addplotimpl@table@fromstructure + \let\pgfplots@addplotimpl@table@fromfile@IS=\pgfplots@addplotimpl@table@fromfile + \let\pgfplots@addplotimpl@graphics@IS=\pgfplots@addplotimpl@graphics@ + \let\pgfplots@addplotimpl@coordinates@IS=\pgfplots@addplotimpl@coordinates + % + \def\pgfplots@gobble@until@semicolon@AS#1;{} + \long\def\pgfplots@addplotimpl@expression@AS#1#2(#3,#4)#5;{\pgfplots@addplotimpl@expression@{#1}{#2}{#3}{#4}{#5}}% + \long\def\pgfplots@addplotimpl@expression@curly@AS#1#2#3#4;{\pgfplots@addplotimpl@expression@curly@{#1}{#2}{#3}{#4}}% + \def\pgfplots@addplotimpl@function@opt@AS#1#2[#3]#4#5;{\pgfplots@addplotimpl@function@opt@{#1}{#2}{#3}{#4}{#5}}% + \def\pgfplots@addplotimpl@file@opt@AS#1#2[#3]#4#5;{\pgfplots@addplotimpl@file@opt@{#1}{#2}{#3}{#4}{#5}}% + \long\def\pgfplots@addplotimpl@fillbetween@opt@AS#1#2[#3]#4;{\pgfplots@addplotimpl@fillbetween@opt@{#1}{#2}{#3}{#4}}% + \long\def\pgfplots@addplotimpl@table@fromstructure@AS#1#2from#3#4;{\pgfplots@addplotimpl@table@startprocessing{#1}{#2}{#3}{#4}}% + \long\def\pgfplots@addplotimpl@table@fromfile@AS#1#2#3#4;{\pgfplots@addplotimpl@table@startprocessing{#1}{#2}{#3}{#4}}% + \long\def\pgfplots@addplotimpl@coordinates@AS#1#2plot coordinates#3#4;{\pgfplots@addplotimpl@coordinates@{#1}{#2}{#3}{#4}}% + \long\def\pgfplots@addplotimpl@graphics@AS#1#2[#3]#4#5;{\pgfplots@addplotimpl@graphics@@{#1}{#2}{#3}{#4}{#5}}% + % + % Checks whether ';' is an active character and, if that is the + % case, modifies all public macros for it. + \pgfplots@appendto@activesemicolon@switcher{% + \let\pgfplots@gobble@until@semicolon=\pgfplots@gobble@until@semicolon@AS + \let\pgfplots@addplotimpl@expression=\pgfplots@addplotimpl@expression@AS + \let\pgfplots@addplotimpl@expression@curly=\pgfplots@addplotimpl@expression@curly@AS + \let\pgfplots@addplotimpl@function@opt=\pgfplots@addplotimpl@function@opt@AS + \let\pgfplots@addplotimpl@file@opt=\pgfplots@addplotimpl@file@opt@AS + \let\pgfplots@addplotimpl@fillbetween@opt=\pgfplots@addplotimpl@file@opt@AS + \let\pgfplots@addplotimpl@table@fromstructure=\pgfplots@addplotimpl@table@fromstructure@AS + \let\pgfplots@addplotimpl@table@fromfile=\pgfplots@addplotimpl@table@fromfile@AS + \let\pgfplots@addplotimpl@coordinates=\pgfplots@addplotimpl@coordinates@AS + \let\pgfplots@addplotimpl@graphics@=\pgfplots@addplotimpl@graphics@AS + }% +} + +\newif\ifpgfplots@update@limits@for@one@point@ISCLIPPED +\def\pgfplots@math@ONE{1.0}% + +\def\pgfplots@invoke@prefilter{% + \pgfkeysvalueof{/pgfplots/pre filter/.@cmd}\pgfeov% +}% +\def\pgfplots@invoke@filter#1#2{% + \pgfkeysvalueof{/pgfplots/#2 filter/.@cmd}#1\pgfeov% +}% +\def\pgfplots@invoke@filter@xyz{% + \pgfkeysgetvalue{/pgfplots/filter point/.@cmd}\pgfplots@loc@TMPa + \ifx\pgfplots@loc@TMPa\pgfplots@empty@command@key + \else + \pgfkeyslet{/data point/x}\pgfplots@current@point@x + \pgfkeyslet{/data point/y}\pgfplots@current@point@y + \pgfkeyslet{/data point/z}\pgfplots@current@point@z + \pgfplots@loc@TMPa\pgfeov% + \pgfkeysgetvalue{/data point/x}\pgfplots@current@point@x + \pgfkeysgetvalue{/data point/y}\pgfplots@current@point@y + \pgfkeysgetvalue{/data point/z}\pgfplots@current@point@z + \fi% +}% + +% #1 the target which will contain the filter +% #2 a math expression. +\def\pgfplots@install@filter@expression#1#2{% + \pgfkeysdef{/pgfplots/#1}{\pgfplots@filter@expression{#1}}% + \pgfkeyssetvalue{/pgfplots/#1/@expressionvalue}{#2}% +}% + +% Executes #2 if the filter key was defined by +% \pgfplots@install@filter@expression. +% +% #1 the target which will contain the filter (like 'x filter') +% #2: true code +% #3: false code +\def\pgfplots@ifisfilterexpression#1#2#3{% + \pgfkeysgetvalue{/pgfplots/#1/.@cmd}\pgfplots@loc@TMPc + \long\def\pgfplots@loc@TMPd##1\pgfeov{\pgfplots@filter@expression{#1}}% + \ifx\pgfplots@loc@TMPc\pgfplots@loc@TMPd + #2\relax + \else + #3\relax + \fi +}% + +% the key name (example: 'x filter') +\def\pgfplots@filter@expression#1{% + \begingroup + \pgfkeys{/pgf/fpu=true}% + \pgfkeysgetvalue{/pgfplots/#1/@expressionvalue}\pgfplots@loc@TMPa + \pgfmathparse{\pgfplots@loc@TMPa}% + \pgfmath@smuggleone\pgfmathresult + \endgroup +}% + +% this is a convenience macro to save storage in the long coordinate +% lists. +\def\pgfplots@stream#1#2{\pgfplotstreampoint{\pgfqpoint{#1}{#2}}} +\def\pgfplots@stream@#1#2#3{\def\pgfplots@current@point@coordindex{#1}\pgfplots@stream{#2}{#3}} +\def\pgfplots@stream@withmeta#1#2#3{\def\pgfplots@current@point@meta{#3}\pgfplotstreampoint{\pgfqpoint{#1}{#2}}} +\def\pgfplots@stream@withmeta@#1#2#3#4{\def\pgfplots@current@point@coordindex{#1}\pgfplots@stream@withmeta{#2}{#3}{#4}} + +\def\pgfplots@stream@decode@and@apply#1#2#3#4{% + \def\pgfplots@current@point@coordindex{#1}% + \pgfplotsaxisdeserializedatapointfrom@private{#2}% + \pgfplotstreampoint{\pgfqpoint{#3}{#4}}% +} + +% Takes a sequence of PREPARED coordinates which are given in floating +% point representation and applies the data scaling trafo (if +% necessary). +% +% Any coordinate will be plotted with the selected PGF plot handler. +% +% This stream is designed to be done at the end of an axis. +% See \pgfplots@coord@stream@finalize@storedcoords@START +% +\def\pgfplots@coord@stream@INIT@finalize@storedcoords{% + % + % Init the plot handlers: + \pgfplots@getcurrent@plothandler\pgfplots@basiclevel@plothandler + \pgfplots@gettikzinternal@keyval{mark}{tikz@plot@mark}{}% + % + \ifpgfplots@threedim + \pgfplots@apply@zbuffer + \fi + % + \pgfplots@perpointmeta@preparetrafo + % + \ifpgfplots@stackedmode + \pgfplots@stacked@visphase@beginplot + \fi + \ifpgfplots@errorbars@enabled + \pgfplots@errorbars@visphase@begin + \fi + \pgfplots@prepare@visualization@dependencies + % + \def\pgfplots@loc@TMPa{0}% <-- if (collectmark positions) + \ifpgfplots@scatterplotenabled + \def\pgfplots@loc@TMPa{1}% collect mark positions even if 'mark=none'! scatter might not even use markers. + \fi + \ifx\tikz@plot@mark\pgfutil@empty + \else + \def\pgfplots@loc@TMPa{1}% + \fi + % + % OK, initialize the plot handler. + \pgfplotsresetplothandler + \pgfplots@basiclevel@plothandler + \expandafter\pgfplotsplothandlerdeserializestatefrom\expandafter{\pgfplots@serialized@state@plothandler}% + % + \pgfplots@LUA@visualization@of@current@plot + % + \pgfplotstreamstart + % + % Now, set up coordinate streams. + \def\pgfplots@coord@stream@start@{% + \let\pgfplots@data@scaletrafo@result=\pgfutil@empty + \c@pgfplots@coordindex=0 + }% + \def\pgfplots@coord@stream@end@{% + \ifpgfplots@stackedmode + \pgfplots@stacked@visphase@endplot + \fi + \ifpgfplots@errorbars@enabled + \pgfplots@errorbars@visphase@end + \fi + \pgfplots@addplot@get@named@startendpoints@command\pgfplots@loc@TMPa + \pgfplots@loc@TMPa + \pgfplotstreamend + }% + \begingroup + \let\E=\noexpand + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \pgfplots@coord@stream@INIT@finalize@storedcoords@prepare@scaletrafomacro + % + % Will be inserted in one of two possible places below (to collect + % marker positions) + % This finalize command maps the logical coordinate into PGF's + % point space. Furthermore, it collects marker coordinates + % (properly clipped by position) if markers are required (see + % above). + % + % It is prepared here to eliminate if's. + \gdef\pgfplots@coord@stream@finalize@currentpt{% + % + % NOTE: this here INVALIDATES \pgfplotlastpoint. However, we assign a correct value + % for that macro after all coordinates have been assigned - and we do it in a way + % which respects the special coordinates of 'patch plots'. + % + \pgfplotstreampoint{}% it will simply take \pgf@x and \pgf@y! + % + \advance\c@pgfplots@coordindex by1 + }% + %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \endgroup +% +%\message{Prepared macro \string \pgfplotsaxisvisphasetransformcoordinate {\meaning\pgfplotsaxisvisphasetransformcoordinate}}% +%\message{Prepared macro \string \pgfplots@coord@stream@finalize@currentpt {\meaning\pgfplots@coord@stream@finalize@currentpt}}% + \if1\b@pgfplots@LUA@visualization@enabled + \def\pgfplots@coord@stream@coord@{% + \ifx\pgfplots@current@point@x\pgfutil@empty% this implements `unbounded coords=jump', for example + \pgfplotsplothandlervisualizejump + \else + \pgfplotscoordmath{x}{tofixed}{\pgfplots@current@point@x}\let\pgfplots@current@point@x=\pgfmathresult + \pgfplotscoordmath{y}{tofixed}{\pgfplots@current@point@y}\let\pgfplots@current@point@y=\pgfmathresult + \ifpgfplots@curplot@threedim + \pgfplotscoordmath{z}{tofixed}{\pgfplots@current@point@z}\let\pgfplots@current@point@z=\pgfmathresult + \fi + % no need to call this here -- we got them from LUA: + % \pgfplotsaxis@toPGF@coords + \pgfplots@coord@stream@finalize@currentpt + \fi + }% + \else + \def\pgfplots@coord@stream@coord@{% + \ifpgfplots@stackedmode + \pgfplots@stacked@visphase@stream@coord@ + \fi + \ifx\pgfplots@current@point@x\pgfutil@empty% this implements `unbounded coords=jump', for example + \pgfplotsplothandlervisualizejump + \else + \pgfplotsaxisvisphasegetpoint + \pgfplots@coord@stream@finalize@currentpt + \fi + }% + \fi +} + +\def\pgfplots@LUA@visualization@init{% + \ifpgfplots@LUA@backend@supported + \edef\pgfplots@loc@TMPa{% + \directlua{pgfplots.texVisualizationInit(\plotnum, \ifpgfplots@curplot@threedim true\else false\fi)}% + }% + \if1\pgfplots@loc@TMPa + \pgfplots@log{\pgfplots@LUA@loglevel@debug}{lua backend=true: Activating partial LUA backend for visualization of plot \plotnum.}% + \else + \pgfplots@LUA@backend@supportedfalse + \fi + \fi +}% + +% Takes the current point (defined by a set of macros) as input and defines \pgf@x and \pgf@y +% as the output point. It also defines +% \pgfplots@current@point@x and its variants to contain the +% transformed canvas coords (those which can be given to +% \pgfplotsqpointxyz). +% +\def\pgfplotsaxisvisphasegetpoint{% + \pgfplotsaxisvisphasetransformcoordinate\pgfplots@current@point@x\pgfplots@current@point@y\pgfplots@current@point@z% + \pgfplotsaxisvisphasepreparedatapoint + \pgfplotsaxis@toPGF@coords +}% + +\def\pgfplotsaxis@toPGF@coords{% + \ifpgfplots@curplot@threedim + \pgfplotsqpointxyz{\pgfplots@current@point@x}{\pgfplots@current@point@y}{\pgfplots@current@point@z}% + \else + \pgfplotsqpointxy{\pgfplots@current@point@x}{\pgfplots@current@point@y}% + \fi +}% + +% Returns the current points into the keys +% /data point/x +% /data point/y +% /data point/z +% /data point/meta +\def\pgfplotspointgetcoordinates{% + \pgfplotspointgetnormalizedcoordinates + \pgfplotspointgetcoordinatesfromnormalized +}% + +% PRECONDITION: \pgfplots@current@point@x and its variants is given in +% TRANSFORMED format, i.e. we assume that we are in the visualization +% phase after the coordinates have been prepared. +% POSTCONDITION: the untransformed #1 coordinate is assigned to +% \pgfplotsretval +\def\pgfplotspointgetnormalizedcoordinates@#1{% + % XXX : this is slower than it used to be - in 1.11, I simply + % remembered 'x untransformed'! I switched it to this lazy + % computation due to the LUA backend in which case remembering it + % leads to extensive (=expensive?) communication between lua and + % TeX. Does it hurt here? Scatter plots compute this stuff... + \expandafter\let\expandafter\pgfplotsretval\csname pgfplots@current@point@#1\endcsname + \ifx\pgfplotsretval\pgfutil@empty + \else + \pgfplots@if{pgfplots@apply@datatrafo@#1}{% + \pgfplotscoordmath{#1}{datascaletrafo inverse}{\pgfplotsretval}% + \let\pgfplotsretval=\pgfmathresult + }{}% + \fi +}% + +% Same as \pgfplotspointgetcoordinates, but the resulting values are +% for use in 'normalized axis cs'. +\def\pgfplotspointgetnormalizedcoordinates{% + \pgfplotspointgetnormalizedcoordinates@ x% + \pgfkeyslet{/data point/x}\pgfplotsretval + % + \pgfplotspointgetnormalizedcoordinates@ y% + \pgfkeyslet{/data point/y}\pgfplotsretval + % + \ifpgfplots@curplot@threedim + \pgfplotspointgetnormalizedcoordinates@ z% + \pgfkeyslet{/data point/z}\pgfplotsretval + \else + \pgfkeyslet{/data point/z}\pgfutil@empty + \fi + % + \pgfkeyslet{/data point/meta}\pgfplots@current@point@meta + \edef\pgfplots@loc@TMPa{\pgfplots@current@point@coordindex}% + \pgfkeyslet{/data point/index}\pgfplots@loc@TMPa +}% + +% Assumes that we are given normalized coordinates (i.e. those for use +% in 'normalized axis cs') and transforms them into those which are +% for use in 'axis cs'. +% +% Accepts an optional argument in square brackets, namely one or more +% options in the /pgfplots/coords key path (see below). +\def\pgfplotspointgetcoordinatesfromnormalized{% + \pgfutil@ifnextchar[{\pgfplotspointgetcoordinatesfromnormalized@opt}{\pgfplotspointgetcoordinatesfromnormalized@opt[]}% +}% + +% Defines where to expect INPUT coordinates +% \pgfplotspointgetcoordinatesfromnormalized[path=/data point/ +% would expect input coordinates +% /data point/x +% /data point/y +% /data point/z +\pgfkeyssetvalue{/pgfplots/coords/path}{/data point} + +% \pgfplotspointgetcoordinatesfromnormalized[target path=/data point/zero/ +% would write output coordinates +% /data point/zero/x +% /data point/zero/y +% /data point/zero/z +\pgfkeyssetvalue{/pgfplots/coords/target path}{\pgfkeysvalueof{/pgfplots/coords/path}} + +\def\pgfplotspointgetcoordinatesfromnormalized@opt[#1]{% + \begingroup + \pgfqkeys{/pgfplots/coords}{#1}% + \pgfkeysgetvalue{/pgfplots/coords/path}\pgfplots@path + \pgfkeysgetvalue{/pgfplots/coords/target path}\pgfplots@path@trg + \pgfkeysifdefined{\pgfplots@path/x}{}{% + \pgfplots@error{Illegal argument: '\pgfplots@path' is no valid data point path (\pgfplots@path/x does not exist)}% + }% + \pgfkeysgetvalue{\pgfplots@path/x}\pgfplots@loc@x + \pgfkeysgetvalue{\pgfplots@path/y}\pgfplots@loc@y + \pgfkeysgetvalue{\pgfplots@path/z}\pgfplots@loc@z + % + \pgfplotspointgetcoordinatesfromnormalized@transform x\pgfplots@loc@x% + \pgfplotspointgetcoordinatesfromnormalized@transform y\pgfplots@loc@y% + \ifpgfplots@threedim + \pgfplotspointgetcoordinatesfromnormalized@transform z\pgfplots@loc@z% + \fi + \xdef\pgfplots@glob@TMPa{% + \noexpand\pgfkeyssetvalue{\pgfplots@path@trg/x}{\pgfplots@loc@x}% + \noexpand\pgfkeyssetvalue{\pgfplots@path@trg/y}{\pgfplots@loc@y}% + \noexpand\pgfkeyssetvalue{\pgfplots@path@trg/z}{\pgfplots@loc@z}% + }% + \endgroup + \pgfplots@glob@TMPa +}% +\def\pgfplotspointgetcoordinatesfromnormalized@transform#1#2{% + \pgfplots@if{pgfplots@#1islinear}{% + \pgfplotscoordmath{#1}{tofixed}{#2}% + }{% + \pgfplotscoordmath{#1}{exp}{#2}% + }% + \let#2=\pgfmathresult + \pgfplots@coord@inv@trafo@apply{#1}{#2}% + \let#2=\pgfmathresult +}% + +% Defines an optimized and matching \pgfplotsaxisvisphasetransformcoordinate +% during the coordinate finalization step in \end{axis}. +\def\pgfplots@coord@stream@INIT@finalize@storedcoords@prepare@scaletrafomacro{% + \begingroup + \let\E=\noexpand + % + % \pgfplotsaxisvisphasetransformcoordinate + % Maps a point to the low level xyz coordinate system by applying + % data scaling transformations. + % + % This method should be invoked for every coordinate before it can + % be drawn. + % + % It is prepared here to eliminate if's. + % + % Arguments: + % #1 : a MACRO containing the x value + % #2 : a MACRO containing the y value + % #3 : a MACRO containing the z value + % + % PRECONDITION: + % - the visualization phase is running. + % - #1,#2,#3 are defined and contain + % values resulting from the survey phase. + % + % POSTCONDITION + % - #1,#2,#3 will be redefined to contain data which is + % readily usable by low level pgf plot handlers for + % visualization. + % + % @see \pgfplotsaxisvisphasepreparedatapoint + \xdef\pgfplotsaxisvisphasetransformcoordinate##1##2##3{% + \ifpgfplots@apply@datatrafo@x + \E\pgfplotscoordmath{x}{datascaletrafo}{##1}% + \E\let##1=\E\pgfmathresult + \fi + \ifpgfplots@apply@datatrafo@y + \E\pgfplotscoordmath{y}{datascaletrafo}{##2}% + \E\let##2=\E\pgfmathresult + \fi + \ifpgfplots@curplot@threedim + \ifpgfplots@apply@datatrafo@z + \E\pgfplotscoordmath{z}{datascaletrafo}{##3}% + \E\let##3=\E\pgfmathresult + \fi + \fi + % \t@pgfplots@tokc=\expandafter{\pgfplots@data@scaletrafo@result}% + % \edef\pgfplots@data@scaletrafo@result{\the\t@pgfplots@tokc(\pgfplots@current@point@x,\pgfplots@current@point@y)}% + }% + % + % Just before the visualization phase can call the low level + % interface, this method is called to handle final changes. + % It is currently only used by the stacked plot interface. + \xdef\pgfplotsaxisvisphasepreparedatapoint{% + \ifpgfplots@stackedmode + % all these calls work with pgfmath; no more floating point + % arithmetics are applied. + \E\pgfplots@stacked@visphasepreparedatapoint% + \fi + }% + % + \endgroup +} + +% Defines \pgfmathresult to contain the transformed coordinate entry +% #1: one of x,y ,or z +% #2: the input value +\def\pgfplotsaxisvisphasetransformcoordinateentry#1#2{% + \pgfplots@if{pgfplots@apply@datatrafo@#1}{% + \pgfplotscoordmath{#1}{datascaletrafo}{#2}% + }{% + \edef\pgfmathresult{#2}% + }% +}% + +\def\pgfplots@addplot@get@named@startendpoints@command#1{% + \ifx\pgfplots@currentplot@firstcoord@x\pgfutil@empty + % empty plot. + \def#1{% + \pgfcoordinate{current plot begin}{\pgfplotspointaxisorigin}% + \pgfcoordinate{current plot end}{\pgfplotspointaxisorigin}% + }% + \else + \ifpgfplots@curplot@threedim + \edef#1{% + \noexpand\pgfcoordinate{current plot begin}{\noexpand\pgfplotsqpointxyz{\pgfplots@currentplot@firstcoord@x}{\pgfplots@currentplot@firstcoord@y}{\pgfplots@currentplot@firstcoord@z}}% + \noexpand\pgfcoordinate{current plot end}{\noexpand\pgfplotsqpointxyz{\pgfplots@currentplot@lastcoord@x}{\pgfplots@currentplot@lastcoord@y}{\pgfplots@currentplot@lastcoord@z}}% + }% + \else + \edef#1{% + \noexpand\pgfcoordinate{current plot begin}{\noexpand\pgfplotsqpointxy{\pgfplots@currentplot@firstcoord@x}{\pgfplots@currentplot@firstcoord@y}}% + \noexpand\pgfcoordinate{current plot end}{\noexpand\pgfplotsqpointxy{\pgfplots@currentplot@lastcoord@x}{\pgfplots@currentplot@lastcoord@y}}% + }% + \fi + \fi +}% + +% This is the pgfplots implementation for 'node[pos=<fraction>]'. +% Besides modifications of the transformation matrix, it also defines the COORDINATES of the point to +% /data point/x +% /data point/y +% /data point/z +% (or more keys which depend on the plot handler). +\def\pgfplots@plot@timer{% + \pgfplotstransformplotattime{\tikz@time}% +} + +% Installs a transformation matrix such that (0,0) is the point of the +% current plot with fraction #1. +% +% This does actually nothing more than using +% \pgfplotspointplotattime{#1} as shift and using the slope of the +% curve at that point to set up the 'sloped' rotation (if enabled). +\def\pgfplotstransformplotattime#1{% + \pgftransformshift{\pgfplotspointplotattime{#1}}% + \ifpgfresetnontranslationattime% + \pgftransformresetnontranslations% + \fi% + \ifpgfslopedattime% + \pgfplotsplothandlertransformslopedattime{#1}{\pgfplotspointplotattimefirst}{\pgfplotspointplotattimesecond}% + \fi% +} + +\def\pgfplotspointplotattimeclearcache{% + \global\let\pgfplotspointplotattime@cache=\pgfutil@empty + \gdef\pgfplotspointplotattime@cachesize{0}% +}% +\pgfplotspointplotattimeclearcache +\def\pgfplotspointplotattime@cachesize@max{20} + +% Checks if the cache for \pgfplotspointplotattime has a cached entry for '#1'. +% POSTCONDITION: +% if \ifpgfplots@loc@tmp is true, the value(s) from the cache have been retrieved successfully. +% if \ifpgfplots@loc@tmp is false, there is not hit. +\def\pgfplotspointplotattimegetfromcache#1{% + \pgf@xa=#1pt % + \pgfplotspointplotattime@cache + \pgfkeysifdefined{/data point/@pos \the\pgf@xa/segment \pgfkeysvalueof{/tikz/pos segment}}{% + \pgfkeysvalueof{/data point/@pos \the\pgf@xa/segment \pgfkeysvalueof{/tikz/pos segment}}% + \pgfplots@loc@tmptrue + }{% + \pgfplots@loc@tmpfalse + }% +}% +\def\pgfplotspointplotattimeaddtocache#1{% + \pgfplotsutil@advancestringcounter@global\pgfplotspointplotattime@cachesize + \ifnum\pgfplotspointplotattime@cachesize=\pgfplotspointplotattime@cachesize@max + \pgfplotspointplotattimeclearcache + \fi + \pgf@xa=#1pt % + \edef\pgfplots@loc@TMPa{% + \noexpand\gdef\noexpand\pgfplotspointplotattimefirst{\pgfplotspointplotattimefirst}% + \noexpand\gdef\noexpand\pgfplotspointplotattimesecond{\pgfplotspointplotattimesecond}% + \noexpand\gdef\noexpand\pgfplotspointplotattimecoords{\pgfplotspointplotattimecoords}% + }% + \t@pgfplots@toka=\expandafter{\pgfplotspointplotattime@cache}% + \t@pgfplots@tokb=\expandafter{\pgfplots@loc@TMPa}% + \xdef\pgfplotspointplotattime@cache{% + \the\t@pgfplots@toka + \noexpand\pgfkeyssetvalue{/data point/@pos \the\pgf@xa/segment \pgfkeysvalueof{/tikz/pos segment}}{\the\t@pgfplots@tokb}% + }% +} + +% Sets (\pgf@x,\pgf@y) to the point of the current plot with fraction #1. +% For #1 = 0, this is the first point. +% For #1 = 1, this is the last point. +% For #1 = 0.5, it is the middle of the plot. +% The argument '#1' is optional: if you leave it away, the current value of the 'pos' key will be used. +% This method will work for most plot handlers, although some of them might be unsupported. +% +% As a side-effect, it defines the (global) macros +% - \pgfplotspointplotattimefirst the start coordinate of the line segment containing #1 +% - \pgfplotspointplotattimesecond the end coordinate of the line segment containing #1 +% - \pgfplotspointplotattimecoords the coordinates of #1 +% The first two are interesting in order to allow the computation of gradients. +% \pgfplotsplothandlerpointtokeys{/data point}% +% for the \pgfplotspointplotattimecoords point +% +% Any of these macros can be decoded using +% \pgfplotsplothandlerdeserializepointfrom\pgfplotspointplotattimesecond +% \pgfplotsaxisvisphasegetpoint +% +% @see \pgfplotsplothandlerpointtokeys +\def\pgfplotspointplotattime{% + \pgfutil@ifnextchar\bgroup{\pgfplotspointplotattime@}{\pgfplotspointplotattime@{\tikz@time}}% +} +\def\pgfplotspointplotattime@#1{% + \edef\pgfplots@loc@TMPa{#1}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \pgfplots@error{Sorry, the provided fraction of the plot is empty (maybe the argument of 'pos' has been cleared by the tikz node processing). Please provide a valid 'pos' argument}% + \else + \pgfplotspointplotattimegetfromcache{#1}% + \ifpgfplots@loc@tmp + % CACHE HIT! +%\message{CACHE HIT for \string\pgfplotspointplotattime{#1}^^J}% + \else +%\message{NO cache hit for \string\pgfplotspointplotattime{#1}^^J}% + \begingroup + % + \if1\b@pgfplots@LUA@visualization@enabled + \ifx\pgfplots@plot@timer@args\relax + \expandafter\gdef\expandafter\pgfplots@plot@timer@args\expandafter{% + \directlua{pgfplots.texGetSurveyedCoordsToPgfplots()}% + }% + \fi + \let\pgfplotsaxisdeserializedatapointfrom@private=\pgfplotsaxisdeserializedatapointfrom@private@nonLUA + \else + \global\let\pgfplots@plot@timer@args=\pgfplots@stored@current@data + \fi + % + % + \edef\pgfplots@time{#1}% + \pgfplotscoordmathparsemacro{default}{\pgfplots@time}% + \pgfkeysgetvalue{/tikz/pos segment}\pgfplots@pos@segment + % +\iffalse + % this here is a simple experiment which finds x or y + % values. IMPLEMENT IT! + \def\pgfplotspointattime@do@set@current@value{% + \pgfplotscoordmath{default}{parsenumber}{\pgfplots@current@point@y}% + \let\pgfplotspointattime@value@current=\pgfmathresult + }% + \def\pgfplotspointattime@do@set@target@value{% + \let\pgfplotspointattime@value@target=\pgfplots@time + }% + \def\pgfplots@ifpointattime@do@set@current@value@accumulates##1##2{##2}% +\fi + % + \let\pgfplotspointattime@do=\relax + \let\pgfplots@coord@stream@start@=\pgfplots@coord@stream@start@plot@at@time + \let\pgfplots@coord@stream@coord@=\pgfplots@coord@stream@coord@plot@at@time + \def\pgfplots@coord@stream@end@{}% + \pgfplots@ifpointattime@do@set@current@value@accumulates{% + % 1. compute the total length of the plot (by integrating along a linear spline) + % + % we need to compute the TOTAL length in order to set the + % target values. + \expandafter\pgfplots@coord@stream@foreach@NORMALIZED\expandafter{\pgfplots@plot@timer@args}% + }{}% + % + \pgfplotspointattime@do@set@target@value + % + \pgfplotscoordmath{default}{zero}% + \let\pgfplots@len@last=\pgfmathresult + \let\pgfplots@len@last@last=\pgfplots@len@last +%\message{plot at time (#1, segment \pgfplots@pos@segment): total length=\pgfplotspointattime@value@current; target len \pgfplotspointattime@value@target\space (#1)^^J}% + % + \def\pgfplots@HIT{0}% + \let\pgfplots@last@last=\pgfutil@empty + \let\pgfplots@coord@stream@coord@=\pgfplots@coord@stream@coord@plot@at@time + \let\pgfplotspointattime@do=\pgfplotspointattime@do@find@target@value + \expandafter\pgfplots@coord@stream@foreach@NORMALIZED\expandafter{\pgfplots@plot@timer@args}% + \if\pgfplots@HIT0% + \let\pgfplots@last@processed=\pgfplots@last@last + \let\pgfplots@len@last=\pgfplots@len@last@last + \pgfplotspointattime@pointbetween@two + \fi + \endgroup + \pgfplotspointplotattimeaddtocache{#1}% + \fi + \pgfplotsplothandlerdeserializepointfrom\pgfplotspointplotattimecoords + \pgfplotscoordmath{x}{tofixed}{\pgfplots@current@point@x}% + \pgfplots@coord@inv@trafo@apply{x}{\pgfmathresult}% + \let\pgfplots@current@point@x=\pgfmathresult + \pgfplotscoordmath{y}{tofixed}{\pgfplots@current@point@y}% + \pgfplots@coord@inv@trafo@apply{y}{\pgfmathresult}% + \let\pgfplots@current@point@y=\pgfmathresult + \ifpgfplots@curplot@threedim + \pgfplotscoordmath{z}{tofixed}{\pgfplots@current@point@z}% + \pgfplots@coord@inv@trafo@apply{z}{\pgfmathresult}% + \let\pgfplots@current@point@z=\pgfmathresult + \fi + \pgfplotsplothandlerpointtokeys{/data point}% + \fi +} + +% coordinate streaming method for use in +% \pgfplotspointplotattime +\def\pgfplots@coord@stream@start@plot@at@time{% + \ifx\pgfplots@pos@segment\pgfutil@empty + \let\c@pgfplots@segments=\pgfutil@empty + \else + \def\c@pgfplots@segments{0}% + \c@pgf@countd=\pgfplots@pos@segment\relax + \edef\pgfplots@pos@segment{\the\c@pgf@countd}% + \fi + \pgfplotscoordmath{default}{zero}% + \let\pgfplotspointattime@value@current=\pgfmathresult + \let\pgfplots@last@processed=\pgfutil@empty + \def\pgfplots@last@was@empty{1}% +}% + + +% coordinate streaming method for use in +% \pgfplotspointplotattime +% +% It invokes \pgfplotspointattime@do{} whenever is has found a line +% segment. +\def\pgfplots@coord@stream@coord@plot@at@time{% +%\message{plot at time (#1, segment \pgfplots@pos@segment): processing (\pgfplots@current@point@x,\pgfplots@current@point@y,\pgfplots@current@point@z)^^J}% + \ifx\pgfplots@current@point@x\pgfutil@empty + \if1\pgfplots@last@was@empty + \else + % oh. a jump... start new length segment + \ifx\c@pgfplots@segments\pgfutil@empty + \else + \ifx\pgfplots@pos@segment\c@pgfplots@segments + \let\pgfplots@coord@stream@coord@=\relax + \fi + \pgfplotsutil@advancestringcounter\c@pgfplots@segments + \fi + \fi + \let\pgfplots@last@processed=\pgfutil@empty + \def\pgfplots@last@was@empty{1}% + \else + \ifx\pgfplots@pos@segment\c@pgfplots@segments + \pgfplotsplothandlerserializepointto{\pgfplots@cur}% + \pgfplotspointattime@do@set@current@value + % + \ifx\pgfplots@last@processed\pgfutil@empty + \else + \pgfplotspointattime@do + \fi + % + \let\pgfplots@len@last@last=\pgfplots@len@last + \let\pgfplots@len@last=\pgfplotspointattime@value@current + \let\pgfplots@last@last=\pgfplots@last@processed + \let\pgfplots@last@processed=\pgfplots@cur + \fi + \def\pgfplots@last@was@empty{0}% + \fi +}% + +% A macro which is invoked whenever \pgfplotspointplotattime found a +% line segment. +% +% INPUT: +% - \pgfplots@cur : serialized current point. This current point's +% properties are available in the macros +% \pgfplots@current@point@[xyz] etc. +% - \pgfplots@last@processed : serialized last point +% - \pgfplotspointattime@value@current : the accumulated length so far +% +\def\pgfplotspointattime@do{} + +% \pgfplots@ifpointattime@do@set@current@value@accumulates{<true code>}{<false code>} +% +% is invokes to test if \pgfplotspointattime@do@set@current@value +% accumulates stuff. If so, it will invoke <true code>. If it does NOT +% accumulate stuff, it will invoke <false code> +\def\pgfplots@ifpointattime@do@set@current@value@accumulates#1#2{% + % the default "time fraction" implementation accumulates: + #1\relax +} + +\def\pgfplotspointattime@do@set@current@value{% + \ifx\pgfplots@last@processed\pgfutil@empty + \else + \pgfplotsplothandlersurveydifflen{\pgfplots@last@processed}{\pgfplots@cur}% + \pgfplotscoordmath{default}{op}{add}{{\pgfmathresult}{\pgfplotspointattime@value@current}}% + \let\pgfplotspointattime@value@current=\pgfmathresult + \fi +%\message{plot at time (#1, segment \pgfplots@pos@segment): length \pgfplotspointattime@value@current^^J}% +}% + +% Needs to define \pgfplotspointattime@value@target . +% +% This value is the search target: once the loop realizes that it +% passed \pgfplotspointattime@value@target, it will report a hit in the current +% interval. +\def\pgfplotspointattime@do@set@target@value{% + \pgfplotscoordmath{default}{op}{multiply}{{\pgfplots@time}{\pgfplotspointattime@value@current}}% + \let\pgfplotspointattime@value@target=\pgfmathresult +}% + +\def\pgfplotspointattime@do@find@target@value{% + % compare \pgfplotspointattime@value@target and \pgfplotspointattime@value@current to see if + % we passed the target interval: + \pgfplotscoordmath{default}{if less than} + {\pgfplotspointattime@value@target} + {\pgfplotspointattime@value@current} + {% HIT! + \def\pgfplots@HIT{1}% + \pgfplotspointattime@pointbetween@two + % + % we cannot stop the loop; what we can turn it into no-op: + \let\pgfplots@coord@stream@coord@=\relax + }{% + }% +}% + +\def\pgfplotspointattime@pointbetween@two{% + \pgfplotscoordmath{default}{op}{subtract}{{\pgfplotspointattime@value@target}{\pgfplots@len@last}}% + \let\pgfplots@tmp=\pgfmathresult + \pgfplotscoordmath{default}{op}{subtract}{{\pgfplotspointattime@value@current}{\pgfplots@len@last}}% + \pgfplotscoordmath{default}{op}{divide}{{\pgfplots@tmp}{\pgfmathresult}}% + \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}% + \let\pgfplots@time@between@two=\pgfmathresult +%\message{HIT of \pgfplotspointattime@value@target\space between \pgfplots@len@last\space and \pgfplotspointattime@value@current\space (\pgfplots@time@between@two)^^J}% + \ifx\pgfplots@last@processed\pgfutil@empty + \pgfplotsplothandlerserializepointto{\pgfplots@cur}% + \else + \pgfplotsplothandlersurveypointattime{\pgfplots@time@between@two}{\pgfplots@last@processed}{\pgfplots@cur}% + \fi + \pgfplotsplothandlerserializepointto\pgfplots@loc@TMPa + \global\let\pgfplotspointplotattimecoords=\pgfplots@loc@TMPa + \pgfplotsaxisvisphasegetpoint + \global\let\pgfplotspointplotattimefirst=\pgfplots@last@processed + \global\let\pgfplotspointplotattimesecond=\pgfplots@cur +}% + + +% #1 : either x,y, or z +% #2 : the argument on which the inv trafo shall be applied. It has to +% be a fixed point number. +\def\pgfplots@coord@inv@trafo@apply#1#2{% + \edef\pgfmathresult{#2}% + \pgfkeysgetvalue{/pgfplots/#1 coord inv trafo/.@cmd}\pgfplots@loc@TMPa + \ifx\pgfplots@loc@TMPa\pgfplots@empty@command@key + \else + \expandafter\pgfplots@loc@TMPa\expandafter{\pgfmathresult}\pgfeov + \fi +}% + +% INPUT: +% either floating point or fixed point coordinates (depending on the +% state of the \ifpgfplots@apply@datatrafo boolean) +% +\long\def\pgfplots@coord@stream@finalize@storedcoords@START{% + % de-activate the FPU here! I fear its number + % format may cause errors when used in low-level + % routines. + \pgfkeys{/pgf/fpu=false}% + % + \pgfplots@assert@tikzinternal@exists{tikz@make@last@position}% + % + \ifpgfplots@clip + \else + % "clip marker paths=true" actually doesn't checks anything -- + % it leaves the checks to the clip path. But since there is no + % clip path, it is adequate to use it here: + \pgfplots@clip@marker@pathstrue + \fi + % + \pgfplots@stored@current@cmd%[current plot style] <--- options are already set + \pgfextra + % + \tikzset{every plot/.try}% + \pgfplots@coord@stream@INIT@finalize@storedcoords% + % + \iffalse + %\ifx\pgfplots@basiclevel@plothandler\pgfplothandlerdiscard + % discard!? Well, no need to loop through the elements. + % But there may be a good reason that we entered the phase! + % keep it. + % FIXME : this does not work, although it might be desirable. + % It fails because we need the named start/end points. + \pgfplots@coord@stream@start + \pgfplots@coord@stream@end + \else + \expandafter\pgfplots@coord@stream@foreach@NORMALIZED\expandafter{\pgfplots@stored@current@data}% + \fi + % + % This here ensures that the LAST position of the path is the last plotted point. + % However, the "last plotted point" is not necessarily the LAST in the sequence. + % This here is the last plotted point: + \xdef\pgfplotlastpoint{\noexpand\pgfpointanchor{current plot end}{center}}% + \tikz@make@last@position{\pgfplotlastpoint}% + % + % the coordinate stream will be assigned as soon as it is needed: + \global\let\pgfplots@plot@timer@args=\relax + \pgfplotspointplotattimeclearcache + \let\tikz@timer=\pgfplots@plot@timer% + \pgfplotsaxisvisphase@get@afterpath% + \expandafter + \endpgfextra + \pgfplotsretval + ;% + % + \pgfplotspointplotattimeclearcache + \global\let\pgfplots@plot@timer@args=\relax + % +}% + +% Defines \pgfplotsretval to contain the "after path", i.e. the +% standard tikz instructions which are to be carried out after the +% plot path. This depends on the current visualization phase and the +% available visualization phases. +\def\pgfplotsaxisvisphase@get@afterpath{% + \ifx\pgfplots@visphase@name\pgfplotsaxis@visphase@name@default + % ah - we have the standard visualization phase. Draw them + % here. + % + % Note that the existance of (nontrivial) after path + % instructions ALWAYS implies the existance of a standard + % visualization phase (compare \pgfplotssurveyphase@set@visphase@names) + \let\pgfplotsretval=\pgfplots@serialized@afterpath% + \else + \let\pgfplotsretval=\pgfutil@empty + \fi +}% + + +% This routine is called at the begin of every plot. +% It initialises a zero level stream. +% +% The default is to use '0' as zero level streams. +% +% This method is called as "precommand"; before any Tikz drawing +% commands have been started. +\def\pgfplots@initzerolevelhandler{% + \ifpgfplots@stackedmode + % ATTENTION: this thing here says: + % "draw zero level coordinates from list XYZ." + % But at the time of this initialisation, the list will be EMPTY! + % + % It will be filled later. That's ok, because + % \pgfplots@initzerolevelhandler will be + % used as 'precommand', that means before Tikz sees any + % coordinates. + \pgfplots@stacked@initzerolevelhandler + \else + \ifpgfplots@threedim + \def\pgfplotxzerolevelstreamstart{}% + \def\pgfplotxzerolevelstreamend{}% + \def\pgfplotxzerolevelstreamnext{% + \begingroup + \pgf@xa=\pgf@y + \pgfplotsqpointxyz{\pgfplots@logical@ZERO@x}{\pgfplots@current@point@y}{\ifpgfplots@curplot@threedim\pgfplots@current@point@z\else\pgfplots@logical@ZERO@z\fi}% + \global\pgf@x=\pgf@x + \global\pgf@y=\pgf@xa + \endgroup + }% + % + \def\pgfplotyzerolevelstreamstart{}% + \def\pgfplotyzerolevelstreamend{}% + \def\pgfplotyzerolevelstreamnext{% + \begingroup + \pgf@xa=\pgf@y + \pgfplotsqpointxyz{\pgfplots@current@point@x}{\pgfplots@current@point@y}{\pgfplots@logical@ZERO@z}% + \global\pgf@x=\pgf@y + \global\pgf@y=\pgf@xa + \endgroup + }% + \else + \pgfplotspointaxisorigin + \expandafter\pgfplotxzerolevelstreamconstant\expandafter{\the\pgf@x}% + \expandafter\pgfplotyzerolevelstreamconstant\expandafter{\the\pgf@y}% + \fi + \fi +} + +% This code is mainly interesting for bar plots. +% +% It precomputes x = 0 and y = 0 - which is not necessarily +% trivial in case of data scaling. Furthermore, it applies +% coordinate clipping to the resulting values and multiplies them +% with x- and y scale vectors. +\def\pgfplots@prepare@ZERO@coordinates{% + \ifpgfplots@xislinear + \ifpgfplots@apply@datatrafo@x + \pgfplotscoordmath{x}{parsenumber}{0}% + \pgfplotscoordmath{x}{datascaletrafo}{\pgfmathresult}% + \global\let\pgfplots@logical@ZERO@x=\pgfmathresult + \else + \gdef\pgfplots@logical@ZERO@x{0}% + \fi + % this works in standard fixed pt math: + \pgfplotsmathmax{\pgfplots@logical@ZERO@x}{\pgfplots@xmin}% + \global\let\pgfplots@logical@ZERO@x=\pgfmathresult + \pgfplotsmathmin{\pgfplots@logical@ZERO@x}{\pgfplots@xmax}% + \global\let\pgfplots@logical@ZERO@x=\pgfmathresult + \else + \if\pgfplots@log@origin@choice@x0% + \global\let\pgfplots@logical@ZERO@x=\pgfplots@xmin% + \else + \gdef\pgfplots@logical@ZERO@x{0}% + \fi + \fi + % + \ifpgfplots@yislinear + \ifpgfplots@apply@datatrafo@y + \pgfplotscoordmath{y}{parsenumber}{0}% + \pgfplotscoordmath{y}{datascaletrafo}{\pgfmathresult}% + \global\let\pgfplots@logical@ZERO@y=\pgfmathresult + \else + \gdef\pgfplots@logical@ZERO@y{0}% + \fi + \pgfplotsmathmax{\pgfplots@logical@ZERO@y}{\pgfplots@ymin}% + \global\let\pgfplots@logical@ZERO@y=\pgfmathresult + \pgfplotsmathmin{\pgfplots@logical@ZERO@y}{\pgfplots@ymax}% + \global\let\pgfplots@logical@ZERO@y=\pgfmathresult + \else + \if\pgfplots@log@origin@choice@y0% + \global\let\pgfplots@logical@ZERO@y=\pgfplots@ymin% + \else + \gdef\pgfplots@logical@ZERO@y{0}% + \fi + \fi + % + \ifpgfplots@threedim + \ifpgfplots@zislinear + \ifpgfplots@apply@datatrafo@z + \pgfplotscoordmath{z}{parsenumber}{0}% + \pgfplotscoordmath{z}{datascaletrafo}{\pgfmathresult}% + \global\let\pgfplots@logical@ZERO@z=\pgfmathresult + \else + \gdef\pgfplots@logical@ZERO@z{0}% + \fi + \pgfplotsmathmax{\pgfplots@logical@ZERO@z}{\pgfplots@zmin}% + \global\let\pgfplots@logical@ZERO@z=\pgfmathresult + \pgfplotsmathmin{\pgfplots@logical@ZERO@z}{\pgfplots@zmax}% + \global\let\pgfplots@logical@ZERO@z=\pgfmathresult + \else + \if\pgfplots@log@origin@choice@z0% + \global\let\pgfplots@logical@ZERO@z=\pgfplots@zmin% + \else + \gdef\pgfplots@logical@ZERO@z{0}% + \fi + \fi + \fi + % + % + \ifpgfplots@threedim + \pgfplotsqpointxyz{\pgfplots@logical@ZERO@x}{\pgfplots@logical@ZERO@y}{\pgfplots@logical@ZERO@z}% + \else + \pgfplotsqpointxy{\pgfplots@logical@ZERO@x}{\pgfplots@logical@ZERO@y}% + \fi + \xdef\pgfplots@ZERO@x{\the\pgf@x}% + \xdef\pgfplots@ZERO@y{\the\pgf@y}% + \xdef\pgfplotspointaxisorigin{\noexpand\global\pgf@x=\pgfplots@ZERO@x\space\noexpand\global\pgf@y=\pgfplots@ZERO@y\space}% + % + % + %-------------------------------------------------- + % \pgfkeyslet{/pgfplots/axis/zero/x}\pgfplots@logical@ZERO@x + % \pgfkeyslet{/pgfplots/axis/zero/y}\pgfplots@logical@ZERO@y + % \ifpgfplots@threedim + % \pgfkeyslet{/pgfplots/axis/zero/z}\pgfplots@logical@ZERO@z + % \fi + %-------------------------------------------------- +}% + + + +% the low-level Tikz command which implements 'plot graphics'. +% +% It's current state is described by some pgfkeys options and two +% coordinates. +\def\pgfplotsplothandlergraphics{% + \def\pgf@plotstreamstart{% + \gdef\pgfplots@plot@handler@graphics@bb@first{\pgf@x=16000pt \pgf@y=16000pt }% + \gdef\pgfplots@plot@handler@graphics@bb@second{\pgf@x=-16000pt \pgf@y=-16000pt }% + \global\let\pgf@plotstreampoint=\pgfplots@plot@handler@graphics@collectbb% + \global\let\pgf@plotstreamspecial=\pgfutil@gobble% + \global\let\pgf@plotstreamend=\pgfplots@plot@handler@graphics@finish% + \def\pgfplotsplothandlervisualizejump{% + \pgfplots@error{Sorry, plot graphics does not support 'unbounded coords=jump'.}% + }% + }% + \def\pgfplotsplothandlername{graphics}% +}% +\def\pgfplots@plot@handler@graphics@collectbb#1{% + \pgf@process{#1}% + \pgf@xa=\pgf@x + \pgf@ya=\pgf@y + \pgfplots@plot@handler@graphics@bb@first + \ifdim\pgf@xa<\pgf@x \pgf@x=\pgf@xa\fi + \ifdim\pgf@ya<\pgf@y \pgf@y=\pgf@ya\fi + \xdef\pgfplots@plot@handler@graphics@bb@first{\pgf@x=\the\pgf@x\space\pgf@y=\the\pgf@y\space}% + % + \pgfplots@plot@handler@graphics@bb@second + \ifdim\pgf@xa>\pgf@x \pgf@x=\pgf@xa\fi + \ifdim\pgf@ya>\pgf@y \pgf@y=\pgf@ya\fi + \xdef\pgfplots@plot@handler@graphics@bb@second{\pgf@x=\the\pgf@x\space\pgf@y=\the\pgf@y\space}% + % +}% +\def\pgfplots@plot@handler@graphics@finish{% + \let\pgfplots@plot@handler@graphics@pointmap@B@canvas\pgfutil@empty + % + % check if we have a pointmap. If so, the pointmap should be used + % to place the graphics. + \pgfkeysgetvalue{/pgfplots/plot graphics/points}\pgfplots@plot@handler@graphics@pointmap + \ifx\pgfplots@plot@handler@graphics@pointmap\pgfutil@empty + \else + \let\pgfplots@plot@handler@graphics@parsepointmap@error=\relax + \expandafter\pgfplots@plot@handler@graphics@parsepointmap\expandafter{\pgfplots@plot@handler@graphics@pointmap}% + \fi + % + % + \ifx\pgfplots@plot@handler@graphics@pointmap@B@canvas\pgfutil@empty + % no pointmap. Good; then squeze graphics into the bounding + % box: + \pgfplots@plot@handler@graphics@usebb + \else + % oh, a pointmap! Process it. + \pgfplots@plot@handler@graphics@process@pointmap + \fi +}% + +% Parses the argument of '/pgfplots/plot graphics/points'. +% +% #1: the argument of the key above. +\def\pgfplots@plot@handler@graphics@parsepointmap#1{% + \let\pgfplots@plot@handler@graphics@pointmap@A@canvas\pgfutil@empty + \let\pgfplots@plot@handler@graphics@pointmap@A@img\pgfutil@empty + \let\pgfplots@plot@handler@graphics@pointmap@B@canvas\pgfutil@empty + \let\pgfplots@plot@handler@graphics@pointmap@B@img\pgfutil@empty + \let\pgfplots@plot@handler@graphics@pointmap@C@canvas\pgfutil@empty + \let\pgfplots@plot@handler@graphics@pointmap@C@img\pgfutil@empty + \let\pgfplots@plot@handler@graphics@pointmap@D@canvas\pgfutil@empty + \let\pgfplots@plot@handler@graphics@pointmap@D@img\pgfutil@empty + \pgfplots@plot@handler@graphics@parsepointmap@loop#1\pgfplots@EOI + \ifpgfplots@plot@graphics@autoadjustaxis + \ifx\pgfplots@plot@handler@graphics@pointmap@A@img\pgfutil@empty + \else + \ifx\pgfplots@plot@handler@graphics@pointmap@D@img\pgfutil@empty + \def\pgfplots@loc@TMPa{#1}% + \pgfplots@plot@handler@graphics@parsepointmap@error + \fi + \fi + \fi +}% +\def\pgfplots@plot@handler@graphics@parsepointmap@error{% + \pgfplots@error{plot graphics/points={\pgfplots@loc@TMPa} cannot be processed: I need at least *four* inner anchor points to automatically adjust the axis, i.e. 4 points of the form (x,y,z) => (imgx,imgy). Use 'plot graphics/auto adjust axis=false' to disable this feature}% +}% +\def\pgfplots@plot@handler@graphics@parsepointmap@loop{% + \pgfutil@ifnextchar\pgfplots@EOI{% + \pgfplots@gobble@until@EOI + }{% + \pgfplots@plot@handler@graphics@parsepointmap@loop@ + }% +}% +\def\pgfplots@plot@handler@graphics@parsepointmap@loop@(#1,#2){% + \pgfutil@ifnextchar={% + \pgfplots@plot@handler@graphics@parsepointmap@loop@@(#1,#2)% + }{% + \pgfplots@plot@handler@graphics@parsepointmap@loop@@(#1,#2)=>(,)% + }% +}% +\def\pgfplots@plot@handler@graphics@parsepointmap@loop@@(#1,#2)=>{% + \pgfutil@ifnextchar({% + \pgfplots@plot@handler@graphics@parsepointmap@loop@@@(#1,#2)% + }{% + \pgfplots@error{Syntax error for plot graphics/pointmap: expected '(#1,#2) => (...,...)'}% + \pgfplots@gobble@until@EOI + }% +} +\def\pgfplots@plot@handler@graphics@parsepointmap@loop@@@(#1,#2)(#3,#4){% + \def\pgfplotsplothandlergraphicspointmappointindex{}% + \def\pgfplots@loc@TMPc{#4}% + \ifx\pgfplots@loc@TMPc\pgfutil@empty + \else + \ifx\pgfplots@plot@handler@graphics@pointmap@A@img\pgfutil@empty + \def\pgfplotsplothandlergraphicspointmappointindex{A}% + \else + \ifx\pgfplots@plot@handler@graphics@pointmap@B@img\pgfutil@empty + \def\pgfplotsplothandlergraphicspointmappointindex{B}% + \else + \ifx\pgfplots@plot@handler@graphics@pointmap@C@img\pgfutil@empty + \def\pgfplotsplothandlergraphicspointmappointindex{C}% + \else + \ifx\pgfplots@plot@handler@graphics@pointmap@D@img\pgfutil@empty + \def\pgfplotsplothandlergraphicspointmappointindex{D}% + \else + \def\pgfplotsplothandlergraphicspointmappointindex{*}% + %\pgfplots@error{Sorry, the argument '(#1,#2) => (#3,#4)' of plot graphics/pointmap is superfluos; ignoring it.}% + \fi + \fi + \fi + \fi + \pgfmathparse{#3}% + \let\pgfplots@loc@TMPb=\pgfmathresult + % + \pgfmathparse{#4}% + \expandafter\edef\csname pgfplots@plot@handler@graphics@pointmap@\pgfplotsplothandlergraphicspointmappointindex @img\endcsname{{\pgfplots@loc@TMPb}{\pgfmathresult}}% + \fi + % + % + \pgfutil@in@,{#2}% + \ifpgfutil@in@ + \def\pgfplots@loc@TMPa##1,##2\relax{% + \expandafter\edef\csname pgfplots@plot@handler@graphics@pointmap@\pgfplotsplothandlergraphicspointmappointindex @logical\endcsname{{#1}{##1}{##2}}% + % + \pgfplotsplothandlergraphicspointmappoint(#1,##1,##2)(#3,#4) + }% + \pgfplots@loc@TMPa#2\relax + \else + \expandafter\edef\csname pgfplots@plot@handler@graphics@pointmap@\pgfplotsplothandlergraphicspointmappointindex @logical\endcsname{{#1}{#2}{}}% + \pgfplotsplothandlergraphicspointmappoint(#1,#2,)(#3,#4) + \fi + \pgfplots@plot@handler@graphics@parsepointmap@loop +} + +\def\pgfplotsplothandlergraphics@survey@pointmappoint(#1,#2,#3)(#4,#5){% + \def\pgfplots@current@point@x{#1}% + \def\pgfplots@current@point@y{#2}% + \def\pgfplots@current@point@z{#3}% + \pgfplots@coord@stream@coord +}% + +% PRECONDITION: +% \pgfplotsplothandlergraphicspointmappointindex is +% empty if and only if (#4,#5) is empty +% or it is an index among all points with non--empty (#4,#5) image +% coordinates. +\def\pgfplotsplothandlergraphicspointmappoint(#1,#2,#3)(#4,#5){% + \ifx\pgfplotsplothandlergraphicspointmappointindex\pgfutil@empty + \else + \def\pgfplots@loc@TMPc{#3}% + \ifx\pgfplots@loc@TMPc\pgfutil@empty + \pgfplotspointaxisxy{#1}{#2}% + \else + \pgfplotspointaxisxyz{#1}{#2}{#3}% + \fi + \expandafter\edef\csname pgfplots@plot@handler@graphics@pointmap@\pgfplotsplothandlergraphicspointmappointindex @canvas\endcsname{\pgf@x=\the\pgf@x\space\pgf@y=\the\pgf@y\space}% + \fi +}% + +% Computes view-related keys which should be communicated to the axis +% in order to render the plot graphics correctly. +% +% @POSTCONDITION: \pgfplotsretval contains any required keys. +\def\pgfplotsplothandlergraphicspointmapcomputerequiredview{% + \begingroup + \let\pgfplotsretval=\pgfutil@empty + \ifx\pgfplots@plot@handler@graphics@pointmap@D@img\pgfutil@empty + \else + \pgfkeysgetvalue{/pgfplots/plot graphics/debug}\pgfplots@loc@TMPa + \def\pgfplots@loc@TMPb{false}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \let\pgfplots@loc@TMPa=\pgfplots@loc@TMPb + \fi + \ifx\pgfplots@loc@TMPa\pgfplots@loc@TMPb + \def\pgfplotsplothandlergraphicspointmapcomputerequiredview@debug{0}% + \else + \def\pgfplotsplothandlergraphicspointmapcomputerequiredview@debug{1}% + \fi + % The following implementation computes the 'unit vector + % ratio' of the IMAGE. + % + % It then tells PGFPlots to use the very same unit vector + % ratio for its axis. + % + % + % The actual implementation is dumb; it requires 4 (!) points for + % which BOTH, the 3D coordinates and the projected 2D + % coordinates relative to the image's lower left corner are + % available. + % + % Since the 2D projected coordinates are generated by the map + % + % T(x,y,z) = o + x e_x + y e_y + z e_z in R^2 + % with o,e_x,e_y,e_z in R^2, + % + % I have 8 degrees of freedom (two for each of the four + % involved vectors). Thus, a simple approach is to provide 4 + % linearly independend points to get 8 equations. + % + % Then, I solve for o,e_x,e_y,e_z + % + \pgfplotsmatrixnewempty\pgfplotsmatrix + \pgfplotsmatrixresize\pgfplotsmatrix88% + % + \pgfplotsarraynewempty\pgfplotsE + \pgfplotsarrayresize\pgfplotsE8% + % + \def\pgfplots@extractimg##1##2{% + \def\pgfplots@img@x{##1}% + \def\pgfplots@img@y{##2}% + }% + \def\pgfplots@extractlogical##1##2##3{% + \def\pgfplots@logical@x{##1}% + \def\pgfplots@logical@y{##2}% + \def\pgfplots@logical@z{##3}% + }% + % Assemble the linear system such that + % x = [ + % exx + % exy + % eyx + % eyy + % ezx + % ezy + % ox + % oy] + % are the degrees of freedom. + \c@pgfplots@coordindex=0 + \pgfplotsutilforeachcommasep{A,B,C,D}\as\pgfplots@loc@TMPa{% + \expandafter\expandafter\expandafter\pgfplots@extractimg\csname pgfplots@plot@handler@graphics@pointmap@\pgfplots@loc@TMPa @img\endcsname + \expandafter\expandafter\expandafter\pgfplots@extractlogical\csname pgfplots@plot@handler@graphics@pointmap@\pgfplots@loc@TMPa @logical\endcsname + \ifx\pgfplots@logical@z\pgfutil@empty + \else + % + \pgfplotsmatrixletentry \the\c@pgfplots@coordindex,0\of\pgfplotsmatrix=\pgfplots@logical@x% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,1\of\pgfplotsmatrix\to{0}% + \pgfplotsmatrixletentry \the\c@pgfplots@coordindex,2\of\pgfplotsmatrix=\pgfplots@logical@y% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,3\of\pgfplotsmatrix\to{0}% + \pgfplotsmatrixletentry \the\c@pgfplots@coordindex,4\of\pgfplotsmatrix=\pgfplots@logical@z% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,5\of\pgfplotsmatrix\to{0}% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,6\of\pgfplotsmatrix\to{1}% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,7\of\pgfplotsmatrix\to{0}% + % + \pgfplotsarrayletentry\c@pgfplots@coordindex\of\pgfplotsE=\pgfplots@img@x + % + \advance\c@pgfplots@coordindex by1 + \pgfplotsmatrixset \the\c@pgfplots@coordindex,0\of\pgfplotsmatrix\to{0}% + \pgfplotsmatrixletentry \the\c@pgfplots@coordindex,1\of\pgfplotsmatrix=\pgfplots@logical@x% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,2\of\pgfplotsmatrix\to{0}% + \pgfplotsmatrixletentry \the\c@pgfplots@coordindex,3\of\pgfplotsmatrix=\pgfplots@logical@y% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,4\of\pgfplotsmatrix\to{0}% + \pgfplotsmatrixletentry \the\c@pgfplots@coordindex,5\of\pgfplotsmatrix=\pgfplots@logical@z% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,6\of\pgfplotsmatrix\to{0}% + \pgfplotsmatrixset \the\c@pgfplots@coordindex,7\of\pgfplotsmatrix\to{1}% + % + \pgfplotsarrayletentry\c@pgfplots@coordindex\of\pgfplotsE=\pgfplots@img@y + % + \advance\c@pgfplots@coordindex by1 + \fi + }% + \ifx\pgfplots@logical@z\pgfutil@empty + \else + \if1\pgfplotsplothandlergraphicspointmapcomputerequiredview@debug + \pgfplotsplothandlergraphics@debug@matrix@to@string + \fi + % + % + \pgfplotsmatrixsolveLEQS\pgfplotsmatrix=\pgfplotsE + % + \edef\pgfmathresult{\pgfplotsarrayvalueofelem0\of\pgfplotsE}% + \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}% + \let\pgfplots@xx=\pgfmathresult + \edef\pgfmathresult{\pgfplotsarrayvalueofelem1\of\pgfplotsE}% + \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}% + \let\pgfplots@xy=\pgfmathresult + \if r\pgfkeysvalueof{/pgfplots/x dir/value}% + % they will be reversed again during the final + % processing: + \edef\pgfplots@xx{-\pgfplots@xx}% + \edef\pgfplots@xy{-\pgfplots@xy}% + \fi + % + \edef\pgfmathresult{\pgfplotsarrayvalueofelem2\of\pgfplotsE}% + \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}% + \let\pgfplots@yx=\pgfmathresult + \edef\pgfmathresult{\pgfplotsarrayvalueofelem3\of\pgfplotsE}% + \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}% + \let\pgfplots@yy=\pgfmathresult + \if r\pgfkeysvalueof{/pgfplots/y dir/value}% + % they will be reversed again during the final + % processing: + \edef\pgfplots@yx{-\pgfplots@yx}% + \edef\pgfplots@yy{-\pgfplots@yy}% + \fi + % + \edef\pgfmathresult{\pgfplotsarrayvalueofelem4\of\pgfplotsE}% + \pgfkeysgetvalue{/pgfplots/plot graphics/snap z}\pgfplots@loc@TMPa + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \let\pgfplots@zx=\pgfmathresult + \pgfplotscoordmath{default}{op}{veclen}{% + {\pgfplotsarrayvalueofelem4\of\pgfplotsE}% + {\pgfplotsarrayvalueofelem5\of\pgfplotsE}% + }% + \let\pgfplotszlen=\pgfmathresult + % + % compute 'snap z' relative to + % '\pgfplotszlen' + \pgfplotscoordmath{default}{parsenumber}{\pgfplots@loc@TMPa}% + \pgfplotscoordmath{default}{op}{multiply}{{\pgfmathresult}{\pgfplotszlen}}% + \let\pgfplots@loc@TMPa=\pgfmathresult + % + \pgfplotscoordmath{default}{op}{abs}{{\pgfplots@zx}}% + \pgfplotscoordmath{default}{if less than}{\pgfmathresult}{\pgfplots@loc@TMPa}{% + \pgfplotscoordmath{default}{zero}% + }{% + \let\pgfmathresult=\pgfplots@zx + }% + \fi + \pgfplotscoordmath{default}{tofixed}\pgfmathresult% + \let\pgfplots@zx=\pgfmathresult + % + \edef\pgfmathresult{\pgfplotsarrayvalueofelem5\of\pgfplotsE}% + \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}% + \let\pgfplots@zy=\pgfmathresult + \if r\pgfkeysvalueof{/pgfplots/z dir/value}% + % they will be reversed again during the final + % processing: + \edef\pgfplots@zx{-\pgfplots@zx}% + \edef\pgfplots@zy{-\pgfplots@zy}% + \fi + % + % + \if1\b@pgfplots@compat@plot@graphics@threedim + \pgfplotswarning{plot3 graphics compatibility mode}\pgfeov% + \else + \fi + % + \edef\pgfplotsretval{% + x={(\pgfplots@xx,\pgfplots@xy)},% + y={(\pgfplots@yx,\pgfplots@yy)},% + z={(\pgfplots@zx,\pgfplots@zy)},% + scale mode=scale uniformly,% + \if1\b@pgfplots@compat@plot@graphics@threedim + % this is the only strategy pre 1.6 + scale uniformly strategy=change vertical limits,% + \fi + }% + % + \if1\pgfplotsplothandlergraphicspointmapcomputerequiredview@debug + \pgfplotsplothandlergraphicspointmapcomputerequiredview@debug@output + \fi + % + \ifx\pgfplotsretval\pgfutil@empty + \pgfplots@error{plot graphics failed to perform the 'auto adjust axis' feature \csname on@line\endcsname\space\space (compare 'plot graphics[debug]). The graphics might be scaled incorrectly. Perhaps the provided 'points' are not linearly independent?}% + \else + \begingroup + \pgfkeysgetvalue{/pgfplots/plot graphics/src}\pgfplots@loc@TMPa + \t@pgfplots@tokc=\expandafter{\pgfplots@loc@TMPa}% + \immediate\write + \if1\pgfplotsplothandlergraphicspointmapcomputerequiredview@debug 16\else -1\fi + {PGFPlots plot graphics[auto adjust axis=true] {\the\t@pgfplots@tokc} \csname on@line\endcsname: determined options '\pgfplotsretval'. + \if1\pgfplotsplothandlergraphicspointmapcomputerequiredview@debug + See \the\t@pgfplots@tokc.dat for debug output. + \else + Use 'plot graphics[debug]' or 'plot graphics[debug=visual]' to generate debug output files. + \fi + ^^J}% + \endgroup + \fi + % + \fi + \fi + \pgfmath@smuggleone\pgfplotsretval + \endgroup +}% +\def\pgfplotsplothandlergraphics@debug@matrix@to@string{% + \pgfplotsmatrixtotext\pgfplotsmatrix + \let\pgfplotsmatrix@text=\pgfplotsretval + \pgfplotsarraytotext\pgfplotsE + \let\pgfplotsrhs@text=\pgfplotsretval +}% +\def\pgfplotsplothandlergraphicspointmapcomputerequiredview@debug@output{% + \begingroup + \immediate\openout\w@pgf@writea=\pgfkeysvalueof{/pgfplots/plot graphics/src}.dat + \pgfplotsarrayselect0\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotsarrayselect1\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPb=\pgfmathresult + \immediate\write\w@pgf@writea{img x unit=\pgfplots@loc@TMPa\space\pgfplots@loc@TMPb\if r\pgfkeysvalueof{/pgfplots/x dir/value}(reversed due to x dir=reverse)\fi,}% + \pgfplotsarrayselect2\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotsarrayselect3\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPb=\pgfmathresult + \immediate\write\w@pgf@writea{img y unit=\pgfplots@loc@TMPa\space\pgfplots@loc@TMPb\if r\pgfkeysvalueof{/pgfplots/y dir/value}(reversed due to y dir=reverse)\fi,}% + \pgfplotsarrayselect4\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotsarrayselect5\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPb=\pgfmathresult + \immediate\write\w@pgf@writea{img z unit=\pgfplots@loc@TMPa\space\pgfplots@loc@TMPb,}% + \pgfplotsarrayselect6\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPa=\pgfmathresult + \pgfplotsarrayselect7\of\pgfplotsE\to\pgfmathresult \pgfplotscoordmath{default}{tofixed}{\pgfmathresult}\let\pgfplots@loc@TMPb=\pgfmathresult + \immediate\write\w@pgf@writea{img origin=\pgfplots@loc@TMPa\space\pgfplots@loc@TMPb\if r\pgfkeysvalueof{/pgfplots/z dir/value}(reversed due to z dir=reverse)\fi,}% + \def\n{^^J}% + \def\t{^^I}% + \immediate\write\w@pgf@writea{canvasmapmatrix=[\pgfplotsmatrix@text];^^Jcanvasmaprhs = [\pgfplotsrhs@text];^^J}% + % + \immediate\write\w@pgf@writea{key configuration = \pgfplotsretval;^^J}% + \immediate\write\w@pgf@writea{use debug=visual to see the mapped keys.^^J}% + \immediate\closeout\w@pgf@writea + \endgroup +}% + +\def\pgfplots@plot@handler@graphics@process@pointmap{% + \begingroup + % determine natural size: + \pgfplots@invoke@pgfkeyscode{/pgfplots/plot graphics/lowlevel get natural size/.@cmd}{}% + \def\pgfplots@loc@TMPa##1##2{% + \global\pgf@x=##1 + \global\pgf@y=##2 + }% + \expandafter\pgfplots@loc@TMPa\pgfmathresult + \edef\pgfplots@W{\pgf@sys@tonumber\pgf@x}% natural WIDTH + \edef\pgfplots@H{\pgf@sys@tonumber\pgf@y}% natural HEIGHT + % + \def\pgfplots@extractimg##1##2{% + \def\pgfplots@img@x{##1}% + \def\pgfplots@img@y{##2}% + }% + \def\pgfplots@extractimgaspoint##1##2{% + \pgfqpoint{##1pt}{##2pt}% + }% + \expandafter\pgfplots@extractimg\pgfplots@plot@handler@graphics@pointmap@A@img% anchor 1 in image + \let\pgfplots@Ax=\pgfplots@img@x + \let\pgfplots@Ay=\pgfplots@img@y + % + \pgfplots@plot@handler@graphics@pointmap@A@canvas% the canvas coordinate corresponding to 'A' + \edef\pgfplots@ax{\pgf@sys@tonumber\pgf@x}% call it 'a' + \edef\pgfplots@ay{\pgf@sys@tonumber\pgf@y}% + % + % compute the CANVAS diagonal between the two anchors points a,b, + % dd := b-a + \pgfpointdiff + \pgfplots@plot@handler@graphics@pointmap@A@canvas + \pgfplots@plot@handler@graphics@pointmap@B@canvas + \edef\pgfplots@ddx{\pgf@sys@tonumber\pgf@x}% + \edef\pgfplots@ddy{\pgf@sys@tonumber\pgf@y}% + % + % compute the IMAGE diagonal between the two image anchor points A,B, + % DD := B - A + \pgfpointdiff + {\expandafter\pgfplots@extractimgaspoint\pgfplots@plot@handler@graphics@pointmap@A@img} + {\expandafter\pgfplots@extractimgaspoint\pgfplots@plot@handler@graphics@pointmap@B@img}% + \pgfplots@loop@CONTINUEtrue + \ifdim\pgf@x=0pt \pgfplots@loop@CONTINUEfalse \fi + \ifdim\pgf@y=0pt \pgfplots@loop@CONTINUEfalse \fi + \ifpgfplots@loop@CONTINUE + \else + \pgfplots@error{Sorry, the first two points with '=>' in plot graphics[points={}] are expected to have different image Y coordinates. Please reorder the sequence.}% + \fi + \edef\pgfplots@DDx{\pgf@sys@tonumber\pgf@x}% + \edef\pgfplots@DDy{\pgf@sys@tonumber\pgf@y}% + % + % What I need now is a shift and the CANVAS dimensions of the + % image. Both can be computed using the relative sizes dd/DD. + % + % The shift is needed to compute the lower left corner of the + % CANVAS image. thus, the lower left CANVAS image corresponds to + % the (0,0) coordinate in the IMAGE. + % + % Remember that 'A' is the anchor 1 in IMAGE coordinates. It is a + % vector from (0,0) --> (A_x,A_y) in IMAGE coordinates. + % + % Now, I want a vector (v_x,v_y) such that q + v = a in CANVAS + % coordinates. Here, 'q' is the lower left corner; it corresponds + % to the (0,0) in IMAGE coordinates. Thus, we have + % v = (a-q). Taking the relative sizes of dd and DD, we find + % + % DD_x / A_x = dd_x / v_x + % DD_y / A_y = dd_y / v_y + % + % and finally q = a-v is the lower left CANVAS coordinate. + \pgfmath@basic@divide@{\pgfplots@ddx}{\pgfplots@DDx}% + \let\pgfplots@x@rel=\pgfmathresult + % + \pgfmath@basic@divide@{\pgfplots@ddy}{\pgfplots@DDy}% + \let\pgfplots@y@rel=\pgfmathresult + % + \pgfmath@basic@multiply@{\pgfplots@Ax}{\pgfplots@x@rel}% + \let\pgfplots@vx=\pgfmathresult + % + \pgfmath@basic@multiply@{\pgfplots@Ay}{\pgfplots@y@rel}% + \let\pgfplots@vy=\pgfmathresult + % + % + % + % + % now, the canvas width. It is even simpler because it holds + % + % DD_x / dd_x = W / w + % DD_y / dd_y = H / h + % + % where (W,H) is the natural size (i.e. in IMAGE coordinates) of the picture and + % (w,h) is the size the picture will occupy in CANVAS coordinates. + % + \pgfmath@basic@multiply@{\pgfplots@x@rel}{\pgfplots@W}% + \let\pgfplots@w=\pgfmathresult + % + \pgfmath@basic@multiply@{\pgfplots@y@rel}{\pgfplots@H}% + \let\pgfplots@h=\pgfmathresult + % + \edef\pgfplots@plot@handler@graphics@DRAW@{% + \noexpand\pgfplots@invoke@pgfkeyscode{/pgfplots/plot graphics/lowlevel draw/.@cmd}{% + {\pgfplots@w pt}% width + {\pgfplots@h pt}% height + }% + }% + \pgfpointadd + {\pgfplots@plot@handler@graphics@pointmap@A@canvas}% the canvas coordinate corresponding to 'A' + {\pgfqpointscale{-1} + {\pgfqpoint{\pgfplots@vx pt}{\pgfplots@vy pt}}% + }% + \edef\pgfplots@plot@handler@graphics@pointmap@lowerleft@canvas{\pgf@x=\the\pgf@x\space\pgf@y=\the\pgf@y\space}% +% + % + % + \begingroup + \pgftransformshift{}% simply take \pgf@x and \pgf@y + % + \node[/pgfplots/plot graphics/node] {% + \pgfplots@plot@handler@graphics@DRAW@ + };% + \endgroup + % + % + \pgfkeysgetvalue{/pgfplots/plot graphics/debug}\pgfplots@loc@TMPa + \edef\pgfplots@loc@TMPb{visual}% + \ifx\pgfplots@loc@TMPb\pgfplots@loc@TMPa + % debug = visual: "sanitize" also triggers the visualization. + \pgfplots@plot@handler@graphics@pointmap@sanitize@scaling{A}% + \pgfplots@plot@handler@graphics@pointmap@sanitize@scaling{B}% + \fi + % + % + \ifx\pgfplots@plot@handler@graphics@pointmap@C@canvas\pgfutil@empty + \ifpgfplots@threedim + \pgfplotswarning{plot3 graphics too few inner anchors}\pgfeov% + \fi + \else + \pgfplots@plot@handler@graphics@pointmap@sanitize@scaling{C}% + \ifx\pgfplots@plot@handler@graphics@pointmap@D@canvas\pgfutil@empty + \else + \pgfplots@plot@handler@graphics@pointmap@sanitize@scaling{D}% + \fi + \fi + \endgroup +}% + +% Checks if the logical and canvas coordinates of the point identified +% by #1 are correct. +% +% #1: a character in {A,B,C...}. +% +\def\pgfplots@plot@handler@graphics@pointmap@sanitize@scaling#1{% + \begingroup + \expandafter\let\expandafter\pgfplots@point@img\csname pgfplots@plot@handler@graphics@pointmap@#1@img\endcsname + \expandafter\let\expandafter\pgfplots@point@canvas\csname pgfplots@plot@handler@graphics@pointmap@#1@canvas\endcsname + \expandafter\let\expandafter\pgfplots@point@logical\csname pgfplots@plot@handler@graphics@pointmap@#1@logical\endcsname + \expandafter\pgfplots@extractimgaspoint\pgfplots@point@img% anchor 3 in image + \edef\pgfplots@Cx{\pgf@sys@tonumber\pgf@x}% + \edef\pgfplots@Cy{\pgf@sys@tonumber\pgf@y}% + % + \pgfmath@basic@multiply@{\pgfplots@Cx}{\pgfplots@x@rel}% + \let\pgfplots@Cx=\pgfmathresult + % + \pgfmath@basic@multiply@{\pgfplots@Cy}{\pgfplots@y@rel}% + \let\pgfplots@Cy=\pgfmathresult + \pgfpointadd + {\pgfplots@plot@handler@graphics@pointmap@lowerleft@canvas}% + {\pgfpoint\pgfplots@Cx\pgfplots@Cy}% + \edef\pgfplots@point@canvas@check{\pgf@x=\the\pgf@x\space\pgf@y=\the\pgf@y\space}% + \pgfpointdiff + {\pgfplots@point@canvas@check}% + {\pgfplots@point@canvas}% + \ifdim\pgf@x<0pt \pgf@x=-\pgf@x\fi + \ifdim\pgf@y<0pt \pgf@y=-\pgf@y\fi + \def\pgfplots@is@the@same@point{1}% + \ifdim\pgf@x>\pgfkeysvalueof{/pgfplots/plot graphics/squeeze tol} + \def\pgfplots@is@the@same@point{0}% + \else + \ifdim\pgf@y>\pgfkeysvalueof{/pgfplots/plot graphics/squeeze tol} + \def\pgfplots@is@the@same@point{0}% + \fi + \fi + \if0\pgfplots@is@the@same@point + % + \begingroup + \pgfkeysgetvalue{/pgfplots/plot graphics/src}\pgfplots@loc@TMPa + \t@pgfplots@tokc=\expandafter{\pgfplots@loc@TMPa}% + \def\pgfplots@extractcoord##1##2##3{##1,##2,##3}% + \pgfplots@error{sorry, I can't fix the scaling of 'plot graphics {\the\t@pgfplots@tokc}'. + The points (\expandafter\pgfplots@extractcoord\pgfplots@plot@handler@graphics@pointmap@A@logical) and (\expandafter\pgfplots@extractcoord\pgfplots@plot@handler@graphics@pointmap@B@logical) are correct, but the point (\expandafter\pgfplots@extractcoord\pgfplots@point@logical) is wrong (its position vector has an error of (\the\pgf@x,\the\pgf@y) which is larger than 'squeeze tol=\pgfkeysvalueof{/pgfplots/plot graphics/squeeze tol}'). This is probably caused by improper relations between the axis' unit vectors because the view is incorrect.^^J + - Is the 'view' argument correct (matlab: [h,v] = view)? ^^J + - Does your image have a non-trivial 'plot box ratio' (matlab: ratio = pbaspect)?^^J + Please refer to the pgfplots manual for details. If you continue now, I'll show the points in the image}% + \endgroup + % + \pgfplots@plot@handler@graphics@pointmap@sanitize@scaling@draw + % + \fi + \pgfkeysgetvalue{/pgfplots/plot graphics/debug}\pgfplots@loc@TMPa + \edef\pgfplots@loc@TMPb{visual}% + \ifx\pgfplots@loc@TMPb\pgfplots@loc@TMPa + \pgfplots@plot@handler@graphics@pointmap@sanitize@scaling@draw + \fi + \endgroup +} + +\def\pgfplots@plot@handler@graphics@pointmap@sanitize@scaling@draw{% + \scope + \pgfsetstrokecolor{black}% + \pgfsetfillcolor{red}% + \pgfpathcircle{\pgfplots@point@canvas@check}{2pt}% + \pgfusepath{stroke,fill}% + \pgfsetfillcolor{green}% + \pgfpathcircle{\pgfplots@point@canvas}{2pt}% + \pgfusepath{stroke,fill}% + \draw[->,red] + \pgfextra{ + \pgfpathmoveto{\pgfplots@point@canvas@check}% + \pgfpathlineto{\pgfplots@point@canvas}}; + \endscope +}% + +\def\pgfplots@plot@handler@graphics@usebb{% + \pgfpointdiff{\pgfplots@plot@handler@graphics@bb@first}{\pgfplots@plot@handler@graphics@bb@second}% + \def\pgfplots@plot@handler@graphics@finish@ok{1}% + \ifdim\pgf@x=0pt + \def\pgfplots@plot@handler@graphics@finish@ok{0}% + \else + \ifdim\pgf@y=0pt + \def\pgfplots@plot@handler@graphics@finish@ok{0}% + \fi + \fi + \if0\pgfplots@plot@handler@graphics@finish@ok + \pgfplots@error{Error using 'plot graphics': I got too few coordinates! I expected the lower left and upper right corners!}% + \xdef\pgfplots@plot@handler@graphics@bb@first{\noexpand\pgfqpoint{0pt}{0pt}}% + \xdef\pgfplots@plot@handler@graphics@bb@first{\noexpand\pgfqpoint{0pt}{0pt}}% + + \fi + \begingroup + % determine the lower left / upper right corners. + \pgfplots@plot@handler@graphics@bb@first + \pgf@xa=\pgf@x + \pgf@ya=\pgf@y + \pgfplots@plot@handler@graphics@bb@second + \pgf@xb=\pgf@x + \pgf@yb=\pgf@y + % + % xc,yc = lower left corner + % x,y = upper right + \ifdim\pgf@xa<\pgf@xb + \pgf@xc=\pgf@xa + \pgf@x=\pgf@xb + \else + \pgf@xc=\pgf@xb + \pgf@x=\pgf@xa + \fi + \ifdim\pgf@ya<\pgf@yb + \pgf@yc=\pgf@ya + \pgf@y=\pgf@yb + \else + \pgf@yc=\pgf@yb + \pgf@y=\pgf@ya + \fi + \advance\pgf@x by-\pgf@xc + \advance\pgf@y by-\pgf@yc + \edef\pgfplots@plot@handler@graphics@DRAW@{% + \noexpand\pgfplots@invoke@pgfkeyscode{/pgfplots/plot graphics/lowlevel draw/.@cmd}{% + {\the\pgf@x}% width + {\the\pgf@y}% height + }% + }% + \pgf@x=\pgf@xc + \pgf@y=\pgf@yc + \pgftransformshift{}% + \node[/pgfplots/plot graphics/node] {% + \pgfplots@plot@handler@graphics@DRAW@ + };% + \endgroup +}% +% initial value for /pgfplots/plots graphics/lowlevel draw: +\def\pgfplots@plot@handler@graphics@DRAW#1#2{% + \pgfkeysgetvalue{/pgfplots/plot graphics/includegraphics}{\pgfplots@loc@TMPc}% + \pgfkeysgetvalue{/pgfplots/plot graphics/src}{\pgfplots@loc@TMPd}% + \ifx\pgfplots@loc@TMPd\pgfutil@empty + \pgfplots@error{Error using 'plot graphics': I don't have a graphics file name! Please set the '/pgfplots/plot graphics/src' key to the image file name. Skipping this plot.}% + \else + \begingroup + \t@pgfplots@toka=\expandafter{\pgfplots@loc@TMPc}% + % + \def\pgfplots@loc@TMPa{#1}% + \def\pgfplots@loc@TMPb{#2}% + % + \edef\pgfplots@loc@TMPc{% + \the\t@pgfplots@toka,% + \ifx\pgfplots@loc@TMPa\pgfutil@empty\else width=#1,\fi + \ifx\pgfplots@loc@TMPb\pgfutil@empty\else height=#2,\fi + }% + \pgfmath@smuggleone\pgfplots@loc@TMPc + \endgroup + % + \def\pgfplots@loc@TMPa{\pgfkeysvalueof{/pgfplots/plot graphics/includegraphics cmd}}% + \expandafter\pgfplots@loc@TMPa\expandafter[\pgfplots@loc@TMPc]{\pgfplots@loc@TMPd}% + \fi +}% + +\def\pgfplots@plot@handler@graphics@getnaturalsize{% + \begingroup + \setbox0=\hbox{% + \pgfplots@invoke@pgfkeyscode{/pgfplots/plot graphics/lowlevel draw/.@cmd}{{}{}}% + }% + \pgf@x=\wd0 + \pgf@y=\ht0 + \ifdim\dp0>0pt + \advance\pgf@y by\dp0 + \else + \ifdim\dp0<0pt + \advance\pgf@y by-\dp0 + \fi + \fi + \xdef\pgfplots@glob@TMPb{{\the\pgf@x}{\the\pgf@y}}% + \endgroup + \let\pgfmathresult=\pgfplots@glob@TMPb +}% + +% legends for plot graphics should not use 'plot graphics' themselfes +% (for obvious reasons). +% This key handles that. Furthermore, it remembers the plot mark for +% the legend -- although no plot mark is allowed for plot graphics as +% such. +\pgfkeysdef{/pgfplots/plot graphics/@prepare legend}{% + \pgfplots@gettikzinternal@keyval{mark}{tikz@plot@mark}{}% + % + \pgfplots@getcurrent@plothandler\pgfplots@basiclevel@plothandler + \t@pgfplots@tokc=\expandafter{\pgfplots@basiclevel@plothandler}% + % + \edef\pgfplots@loc@TMPa{% + \noexpand\pgfkeys{/pgfplots/every legend image post/.append code={% + \noexpand\def\noexpand\tikz@plot@handler{\the\t@pgfplots@tokc}% + \ifx\tikz@plot@mark\pgfutil@empty + \else + \noexpand\pgfkeysalso{/tikz/mark=\tikz@plot@mark}% + \fi + }% + }% + }% + \pgfplots@loc@TMPa +} + + + +% Input : \pgfplots@stored@current@data contains the coordinate stream +% Output: \pgfplots@stored@current@data contains the (modified) +% coordinate stream +\def\pgfplots@apply@zbuffer{% + \ifcase\pgfplotsplothandlermesh@zbuffer@choice\relax + % none. + \or + % reverse x seq: only for 'mesh' + \if\pgfplots@meshmode n% + \pgfplots@error{Sorry, `/pgfplots/z buffer=reverse x seq' can only be used for mesh/surf plots.}% + \else + \pgfplotsautocompletemeshkeys + \if\pgfplots@plot@mesh@ordering0% + % ordering = rowwise -> scanline is cols! + \pgfkeysgetvalue{/pgfplots/mesh/cols}\pgfplotsscanlinelength + \pgfplots@apply@zbuffer@reversescanline% + \else + % ordering = colwise: scanline is rows! + \pgfkeysgetvalue{/pgfplots/mesh/rows}\pgfplotsscanlinelength + \pgfplots@apply@zbuffer@reversetransposed% + \fi + \fi + \or + % reverse y seq: only for 'mesh' + \if\pgfplots@meshmode n% + \pgfplots@error{Sorry, `/pgfplots/z buffer=reverse y seq' can only be used for mesh/surf plots.}% + \else + \pgfplotsautocompletemeshkeys + \if\pgfplots@plot@mesh@ordering0% + % ordering = rowwise -> scanline is cols! + \pgfkeysgetvalue{/pgfplots/mesh/cols}\pgfplotsscanlinelength + \pgfplots@apply@zbuffer@reversetransposed% + \else + % ordering = colwise: scanline is rows! + \pgfkeysgetvalue{/pgfplots/mesh/rows}\pgfplotsscanlinelength + \pgfplots@apply@zbuffer@reversescanline% + \fi + \fi + \or + % reverse xy seq: + \ifpgfplots@LUA@backend@supported + \directlua{pgfplots.texApplyZBufferReverseStream()}% + \else + \begingroup + \def\pgfplots@coord@stream@start{% + \pgfplotsprependlistXnewempty{reversed}% + }% + \def\pgfplots@coord@stream@coord{% + \expandafter\pgfplotsprependlistXpushfront\expandafter{\pgfplots@coord@stream@foreach@NORMALIZED@curencoded@braced}\to{reversed}% + }% + \def\pgfplots@coord@stream@end{% + \pgfplotsprependlistXlet\pgfplots@loc@TMPa={reversed}% + \pgfplotsprependlistXnewempty{reversed}% clear it + \global\let\pgfplotsglobalretval=\pgfplots@loc@TMPa + }% + \expandafter\pgfplots@coord@stream@foreach@NORMALIZED\expandafter{\pgfplots@stored@current@data}% + \endgroup + \let\pgfplots@stored@current@data=\pgfplotsglobalretval + \global\let\pgfplotsglobalretval=\pgfutil@empty + \fi + \or + % sort. + \if\pgfplots@meshmode n% + \ifpgfplots@LUA@backend@supported + \directlua{pgfplots.texApplyZBufferSort()}% + \else + \pgfplots@apply@zbuffer@sort@coordinates + \fi + \else + % meshmode handles sort separately! + \fi + \or + % z buffer=auto + % + % I can decide for each axis if coordinate reversal is + % necessary. + % Idea: check if axis side planes are on foreground or not (a + % very simple task)! I + % only need to know whether [xy] coordinates are sorted + % ascending or descending. This information is already ready. + % + \if1\pgfplotsplothandlermesh@matrixinput + % mesh input=lattice + \begingroup + \if+\pgfkeysvalueof{/pgfplots/x coord sorting}% + \def\pgfplots@minmaxvalue@x{0}% + \else + \def\pgfplots@minmaxvalue@x{0}% + \fi + \if+\pgfkeysvalueof{/pgfplots/y coord sorting}% + \def\pgfplots@minmaxvalue@y{0}% + \else + \def\pgfplots@minmaxvalue@y{1}% + \fi + \pgfplotsifaxissurfaceisforeground{\pgfplots@minmaxvalue@x vv}{% + \def\pgfplots@reverse@x{1}% + }{% + \def\pgfplots@reverse@x{0}% + }% + \pgfplotsifaxissurfaceisforeground{v\pgfplots@minmaxvalue@y v}{% + \def\pgfplots@reverse@y{1}% + }{% + \def\pgfplots@reverse@y{0}% + }% + \if1\pgfplots@reverse@x + \if1\pgfplots@reverse@y + \pgfkeys{/pgfplots/z buffer=reverse xy seq}% + \else + \pgfkeys{/pgfplots/z buffer=reverse x seq}% + \fi + \else + \if1\pgfplots@reverse@y + \pgfkeys{/pgfplots/z buffer=reverse y seq}% + \else + \pgfkeys{/pgfplots/z buffer=none}% + \fi + \fi +%\message{z buffer=auto mode chose z buffer= \ifcase\pgfplotsplothandlermesh@zbuffer@choice NONE \or reverse x seq \or reverse y seq \or reverse xy seq \or sort\or default \fi. mesh ordering = \ifcase\pgfplots@plot@mesh@ordering x varies/rowwise\or y varies/colwise\fi}% + \pgfmath@smuggleone\pgfplotsplothandlermesh@zbuffer@choice + \endgroup + % 'z buffer' is no longer 'auto' now: + \pgfplots@apply@zbuffer + \else + % mesh input=patches + \ifpgfplots@threedim + \if\pgfplots@meshmode n% + \else + \pgfkeys{/pgfplots/z buffer=sort}% + \fi + \else + \pgfkeys{/pgfplots/z buffer=none}% + \fi + \fi + \or + % z buffer=default. + \if\pgfplots@meshmode n% + % mesh mode deactivated! + \else + % mesh=true + \pgfkeysalso{/pgfplots/z buffer=auto}% + \pgfplots@apply@zbuffer% + \fi + \fi +}% + +\def\pgfplots@apply@zbuffer@sort@coordinates{% + \begingroup + \def\pgfplots@coord@stream@start{% + \pgfplotsarraynewempty\pgfplots@zbuffer@local + \pgfplotsarrayresize\pgfplots@zbuffer@local{\numcoords}% + \c@pgfplots@scanlineindex=0 + \def\pgfplots@zbuffer@local@SETCUR####1{% + \expandafter\pgfplotsarrayset\c@pgfplots@scanlineindex\of\pgfplots@zbuffer@local\to{####1}% + }% + }% + \def\pgfplots@coord@stream@coord{% + \expandafter\pgfplots@zbuffer@local@SETCUR\expandafter{\pgfplots@coord@stream@foreach@NORMALIZED@curencoded}% + \advance\c@pgfplots@scanlineindex by1 + }% + \def\pgfplots@coord@stream@end{% + \ifnum\c@pgfplots@scanlineindex=\numcoords + \else + \pgfplotsarrayresize\pgfplots@zbuffer@local{\c@pgfplots@scanlineindex}% + \fi + \pgfkeyslet{/pgfplots/iflessthan/.@cmd}\pgfplots@apply@zbuffer@SORT@iflessthan + \pgfkeysdef{/pgfplots/array/unscope pre}{% + \pgfplotsapplistXnewempty{\pgfp@sortedlist}% + \pgfplotsarrayforeachungrouped\pgfplots@zbuffer@local\as\curelem{% + \expandafter\pgfplotsapplistXpushback\expandafter{\expandafter{\curelem}}\to{\pgfp@sortedlist}% + }% + \pgfplotsapplistXlet\pgfplots@loc@TMPa={\pgfp@sortedlist}% + \global\let\pgfplotsglobalretval=\pgfplots@loc@TMPa + }% + \pgfkeysdef{/pgfplots/array/unscope post}{}% + \pgfplotsarraysort\pgfplots@zbuffer@local + }% + \expandafter\pgfplots@coord@stream@foreach@NORMALIZED\expandafter{\pgfplots@stored@current@data}% + \endgroup + \let\pgfplots@stored@current@data=\pgfplotsglobalretval + \global\let\pgfplotsglobalretval=\pgfutil@empty +}% +% Defines \pgfplotsglobalretval (globally) to be a partial reversion of the +% (normalized) 2d coordinate sequence '#1'. +% +% In other words, the normalized coordinate sequence '#1' is visited +% linearly and while we go, each scanline is reversed. The result is +% collected into \pgfplotsglobalretval. +% +% This implements the 'z buffer=reverse x seq' feature for +% ordering=y varies. +% +% PRECONDITION: +% \pgfplotsscanlinelength contains the scanline length +% POSTCONDITION: +% \pgfplotsglobalretval contains the partial reversion. +\def\pgfplots@apply@zbuffer@reversescanline{% + \ifpgfplots@LUA@backend@supported + \directlua{pgfplots.texApplyZBufferReverseScanline(\pgfplotsscanlinelength)}% + \else + \begingroup + \def\pgfplots@coord@stream@start{% + \pgfplotsprependlistXnewempty{reversedscanline}% + \c@pgfplots@scanlineindex=0 + \pgfplotsapplistXnewempty{\resultlist}% + }% + \def\pgfplots@coord@stream@coord{% + \expandafter\pgfplotsprependlistXpushfront\expandafter{\pgfplots@coord@stream@foreach@NORMALIZED@curencoded@braced}\to{reversedscanline}% + \advance\c@pgfplots@scanlineindex by1 + \ifnum\c@pgfplots@scanlineindex=\pgfplotsscanlinelength\relax + \pgfplotsprependlistXlet\pgfplots@loc@TMPa={reversedscanline}% + \expandafter\pgfplotsapplistXpushback\expandafter{\pgfplots@loc@TMPa}\to\resultlist + \pgfplotsprependlistXnewempty{reversedscanline}% + \c@pgfplots@scanlineindex=0 + \fi + }% + \def\pgfplots@coord@stream@end{% + \pgfplotsprependlistXlet\pgfplots@loc@TMPa={reversedscanline}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \pgfplots@zbuffer@error + \fi + \pgfplotsapplistXlet\pgfplots@loc@TMPa={\resultlist}% + \global\let\pgfplotsglobalretval=\pgfplots@loc@TMPa + }% + \expandafter\pgfplots@coord@stream@foreach@NORMALIZED\expandafter{\pgfplots@stored@current@data}% + \endgroup + \let\pgfplots@stored@current@data=\pgfplotsglobalretval + \global\let\pgfplotsglobalretval=\pgfutil@empty + \fi +%\message{I have performed partial reversion of '#1' and got '\pgfplotsglobalretval'!}% +}% + +% A very similar method of \pgfplots@apply@zbuffer@reversescanline, +% but this one keeps everything inside of each scanline in the +% original ordering, and reverses the ordering in which whole +% scanlines occur. +\def\pgfplots@apply@zbuffer@reversetransposed{% + \ifpgfplots@LUA@backend@supported + \directlua{pgfplots.texApplyZBufferReverseTransposed(\pgfplotsscanlinelength)}% + \else + \begingroup + \def\pgfplots@coord@stream@start{% + \pgfplotsapplistXnewempty{\scanline}% + \c@pgfplots@scanlineindex=0 + \pgfplotsprependlistXnewempty{resultlist}% + }% + \def\pgfplots@coord@stream@coord{% + \expandafter\pgfplotsapplistXpushback\expandafter{\pgfplots@coord@stream@foreach@NORMALIZED@curencoded@braced}\to{\scanline}% + \advance\c@pgfplots@scanlineindex by1 + \ifnum\c@pgfplots@scanlineindex=\pgfplotsscanlinelength\relax + \pgfplotsapplistXlet\pgfplots@loc@TMPa={\scanline}% + \expandafter\pgfplotsprependlistXpushfront\expandafter{\pgfplots@loc@TMPa}\to{resultlist} + \pgfplotsapplistXnewempty{\scanline}% + \c@pgfplots@scanlineindex=0 + \fi + }% + \def\pgfplots@coord@stream@end{% + \pgfplotsapplistXlet\pgfplots@loc@TMPa={\scanline}% + \ifx\pgfplots@loc@TMPa\pgfutil@empty + \else + \pgfplots@zbuffer@error + \fi + \pgfplotsprependlistXlet\pgfplots@loc@TMPa={resultlist}% + \global\let\pgfplotsglobalretval=\pgfplots@loc@TMPa + }% + \expandafter\pgfplots@coord@stream@foreach@NORMALIZED\expandafter{\pgfplots@stored@current@data}% + \endgroup + \let\pgfplots@stored@current@data=\pgfplotsglobalretval + \global\let\pgfplotsglobalretval=\pgfutil@empty + \fi +%\message{I have performed partial reversion (reverse transposed) of '#1' and got '\pgfplotsglobalretval'!}% +}% +\def\pgfplots@zbuffer@error{% + \pgfplots@error{An internal error occured during z buffer reorderings: the rows/cols where not balanced! I have rows= \pgfkeysvalueof{/pgfplots/mesh/rows}, cols=\pgfkeysvalueof{/pgfplots/mesh/cols}. If this happens to be wrong, you might want to provide rows and cols manually.}% +} + +% A special '<' operation which returns true if the point coordinate +% '#1' is BEHIND #2 with respect to the current 3D view. +\def\pgfplots@apply@zbuffer@SORT@iflessthan#1#2#3#4\pgfeov{% + \pgfplotsaxisdeserializedatapointfrom{#1}% + \pgfplotsmathvectorfromstring{\pgfplots@current@point@x,\pgfplots@current@point@y,\pgfplots@current@point@z}{default}% + \pgfplotsmathvectorscalarproduct{\pgfplots@view@dir@threedim}{\pgfplotsretval}{default}% + \let\pgfplots@apply@zbuffer@SORT@iflessthan@a=\pgfplotsretval + % + \pgfplotsaxisdeserializedatapointfrom{#2}% + \pgfplotsmathvectorfromstring{\pgfplots@current@point@x,\pgfplots@current@point@y,\pgfplots@current@point@z}{default}% + \pgfplotsmathvectorscalarproduct{\pgfplots@view@dir@threedim}{\pgfplotsretval}{default}% + \let\pgfplots@apply@zbuffer@SORT@iflessthan@b=\pgfplotsretval + % + \pgfplotscoordmath{default}{if less than}{\pgfplots@apply@zbuffer@SORT@iflessthan@b}{\pgfplots@apply@zbuffer@SORT@iflessthan@a}{% + #3\relax + }{% + #4\relax + }% +}% + + +% Defines \pgfmathresult to be the view depth of a three component +% vector. The third component will be used if and only if the boolean +% \ifpgfplots@curplot@threedim is true. +% The return value will be assigned in floating point. +% +% The arguments need to be numbers (will be parsed with +% \pgfmathfloatparsenumber). +% @see \pgfplotsmathviewdepthxyz +% DEPRECATED use \pgfplotsmathvectorviewdepth instead! +\def\pgfplotsmathfloatviewdepthxyz#1#2#3{% + \begingroup + \pgfmathfloatparsenumber{#1}\let\pgfplots@loc@TMPa=\pgfmathresult + \pgfmathfloatparsenumber{#2}\let\pgfplots@loc@TMPb=\pgfmathresult + \pgfmathfloatparsenumber{#3}\let\pgfplots@loc@TMPc=\pgfmathresult + \edef\pgfplots@loc@TMPa{{\pgfplots@loc@TMPa}{\pgfplots@loc@TMPb}{\pgfplots@loc@TMPc}}% + \expandafter\pgfplotsmathfloatviewdepthxyz@\pgfplots@loc@TMPa + \pgfmath@smuggleone\pgfmathresult + \endgroup +}% + +% #1: a 3d vector of the form x,y,z in 'default' coordmath format +% defines \pgfplotsretval to the view depth +% of the point +% +% Use \pgfplotsmathvectorfromstring{x,y,z}{default} to transform a +% vector into the requested format. +% +% Use \pgfplotscoordmath{default}{tofixed}{\pgfplotsretval} to +% transform the result into fixed point representation. +\def\pgfplotsmathvectorviewdepth#1{% + \pgfplotsmathvectorscalarproduct{#1}{\pgfplots@view@dir@threedim}{default}% +}% + +\def\pgfplotsmathfloatviewdepthxyz@#1#2#3{% + \pgfplots@error{Sorry, you can't use \string\pgfplotsmathfloatviewdepthxyz\space in this context.}% +}% +\def\pgfplotsmathfloatviewdepthxyz@infigure#1#2#3{% + \pgfplotsmathvectorfromstring{\pgfplots@view@dir@threedim}{float}% + \pgfplotsmathvectorscalarproduct{#1,#2,#3}{\pgfplotsretval}{float}% FIXME : \pgfplots@view@dir@threedim might have a different math format! + \let\pgfmathresult=\pgfplotsretval +}% + +% Similar to \pgfplotsmathfloatviewdepthxyz, but this always relies on +% fixed point arithmetics. +% DEPRECATED use \pgfplotsmathvectorviewdepth instead +\def\pgfplotsmathviewdepthxyz#1#2#3{\pgfplotsmathviewdepthxyz@{#1}{#2}{#3}} +\def\pgfplotsmathviewdepthxyz@#1#2#3{% + \pgfplots@error{Sorry, you can't use \string\pgfplotsmathviewdepthxyz\space in this context.}% +} +\def\pgfplotsmathviewdepthxyz@infigure#1#2#3{% + \pgfplotsmathvectorfromstring{\pgfplots@view@dir@threedim@unitlength}{pgfbasic}% + \pgfplotsmathvectorscalarproduct{#1,#2,#3}{\pgfplotsretval}{pgfbasic}% FIXME : \pgfplots@view@dir@threedim might have a different math format! + \let\pgfmathresult=\pgfplotsretval +}% + + +% Evaluate shell commands. +% +% #1 = filename prefix for .sh and .out files (optional, +% default is \jobname) +% #2 = shell command text +% +% Description: +% +% This command will write the command text to a file called +% #1.sh. Then it calls sh (using the \write18 mechanism) to +% execute the file and redirect the output to a file called +% #1.out. +% In contrast to pgfplotgnuplot the result has to be read +% from #1.out later using \pgfplotxyfile. (This allows +% using the function from within the plot table functions +% as well.) +% +% Example: +% +% \pgfplothandlerlineto +% \pgfshell[\jobname]{cat table.dat} +% \pgfplotxyfile{\jobname.out} + +\pgfutil@IfUndefined{w@pgf@writea}{% + \csname newwrite\endcsname\pgf@shellwrite +}{% + \let\pgf@shellwrite=\w@pgf@writea +} +\newif\ifpgf@resample@shell + +\def\pgfshell{\pgfutil@ifnextchar[{\pgf@shell}{\pgf@shell[\jobname]}}%} +\def\pgf@shell[#1]#2{% + \pgf@resample@shelltrue% + % Check, whether it is up-to-date + \openin\pgfutil@inputcheck=#1.sh + \ifeof\pgfutil@inputcheck% + \else% + \read\pgfutil@inputcheck to\pgf@shell@line% + \edef\pgf@plot@code{#2\space}% + \ifx\pgf@plot@code\pgf@shell@line% + \openin\pgfutil@inputcheck=#1.out + \ifeof\pgfutil@inputcheck% + \else% + \pgf@resample@shellfalse + \fi% + \fi% + \fi + \ifpgf@resample@shell% + \immediate\openout\pgf@shellwrite=#1.sh + \immediate\write\pgf@shellwrite{#2}% + \immediate\closeout\pgf@shellwrite% + \immediate\write18{sh #1.sh > #1.out} + \fi% +} |