| Current File : //usr/share/texlive/texmf-dist/tex/generic/pgf/modules/pgfmoduledatavisualization.code.tex |
% Copyright 2019 by Till Tantau
%
% This file may be distributed and/or modified
%
% 1. under the LaTeX Project Public License and/or
% 2. under the GNU Public License.
%
% See the file doc/generic/pgf/licenses/LICENSE for more details.
\ProvidesFileRCS{pgfmoduledatavisualization.code.tex}
\usepgfmodule{oo,shapes}%
\usepgflibrary{fpu}%
% This module defines the basic framework for data visualization.
% In order to visualize data, you first need data. The format for this
% data is not specified, indeed, different formats are possible. A
% data point is created each time the command \pgfdatapoint is
% used. The "parameters" of the data point are just the current values
% of the keys or macros in the current scope.
%
% A set of data points created using the \pgfdata command.
% When a data point is created, a number of signals are emitted, see
% the description of \pgfdatapoint. To actually visualize something,
% objects should be created that listen to these signals and that
% handle them.
%
% The following class manages a data visualization
\pgfooclass{data visualization}
{%
% Class data visualization
%
% This class is used to "manage" a data visualization. It provides
% methods for hooking into the data visualization process and its
% constructor initializes the signals that are issued during a data
% visualization.
%
% When a data visualization object is created, a whole bunch of
% signal objects. You should then create objects that connect to
% these signals. They will be emitted when datapoints come
% available.
%
% It is permissible to have several data visualization objects
% active at the same time.
%
% To use a data visualization object, you should (possibly
% repeatedly) call the method add data() or the macro \pgfdata. You should also
% create transformation, mapping and visualization objects. Then,
% you should, first, call the method survey, which will "survey" the
% data, allowing the mapping and bounding objects to compute the
% correct ranges. You may then create further objects based on this
% data. Then, you should call the "visualize" method, which will
% invoke the visualization signals for the data points.
% These attribute store code that should be executed at certain
% points. The order is the following:
%
% 1. "before survey" code
% 2. "begin survey" phase signal
% 3. "at start survey" code
% 4. data points are processed
% 5. "at end survey" code
% 6. "end survey" phase signal
% 7. "after survey" code
%
% The first seven points will be repeated until the method "do
% another survey" is no longer called during a survey.
%
% 8. "before visualization" code
% 9. "begin visualization" phase signal
% 10. "at start visualization" code
% 11. data points are processed once more
% 12. "at end visualization" code
% 13. "end visualization" phase signal
% 14. "after visualization" code
\attribute before survey;%
\attribute at start survey;%
\attribute at end survey;%
\attribute after survey;%
\attribute before visualization;%
\attribute at start visualization;%
\attribute at end visualization;%
\attribute after visualization;%
%
% Survey counts and handling
%
\attribute survey count=1;%
% Each time a survey is done before the visualization is done, this
% count is incremented. Normally, there is only one survey, but
% objects may request another survey or even more surveys to be
% done, giving them a chance to setup further internal values. By
% accessing this count (via the get survey count method), you can
% find out which survey is currently being done.
\attribute number of surveys=1;%
% By increasing this count, you can request additional surveys to be
% done.
% Stores the to-be-visualized data
\attribute data;%
% Stores the signal objects
\attribute prepare datapoint signal;%
\attribute map datapoint signal;%
\attribute transform datapoint signal;%
\attribute visualize datapoint signal;%
\attribute finish datapoint signal;%
\attribute survey datapoint signal;%
\attribute phase signal;%
\attribute path signal;%
\attribute direction signal;%
\attribute style signal;%
% Constructor
%
% Inits the signals
\method data visualization() {
\pgfoonew{prepare datapoint signal}=new signal()%
\pgfoonew{map datapoint signal}=new signal()%
\pgfoonew{transform datapoint signal}=new signal()%
\pgfoonew{visualize datapoint signal}=new signal()%
\pgfoonew{finish datapoint signal}=new signal()%
\pgfoonew{survey datapoint signal}=new signal()%
\pgfoonew{phase signal}=new signal()%
\pgfoonew{path signal}=new signal()%
\pgfoonew{direction signal}=new signal()%
\pgfoonew{style signal}=new signal()%
%
% Store this object in a key
%
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeyslet{/pgf/data visualization/obj}\pgf@dv@me
}%
% The phase signal will emit the following constants:
\def\pgfdvbeforesurvey{1}%
\def\pgfdvbeginsurvey{2}%
\def\pgfdvendsurvey{3}%
\def\pgfdvaftersurvey{4}%
\def\pgfdvbeforevisualization{5}%
\def\pgfdvbeginvisualization{6}%
\def\pgfdvendvisualization{7}%
\def\pgfdvaftervisualization{8}%
% The path signale will meit the following constants:
\def\pgfdvpathmovetotoken{5}%
\def\pgfdvpathlinetotoken{6}%
\def\pgfdvdirectionfromtoken{7}%
\def\pgfdvdirectiontotoken{8}%
\def\pgfdvdirectionattoken{9}%
% Method
%
% Connect the object #1's slot "#2" to the signal named "#3"
\method connect(#1,#2,#3) {
\pgfoovalueof{#3}.connect(#1,#2)
}%
% Method
%
% Add data that is to be visualized. The code #1 should call the
% \pgfdatapoint macro for each data point it creates.
\method add data(#1) {
\pgf@dv@stripped@add#1\pgf@stop
}%
\def\pgf@dv@stripped@add#1\pgf@stop{%
\pgfooappend{data}{#1}%
}%
% Setters
\method before survey(#1) {
\pgfooappend{before survey}{#1}
}%
\method at start survey(#1) {
\pgfooappend{at start survey}{#1}
}%
\method before visualization(#1) {
\pgfooappend{before visualization}{#1}
}%
\method at start visualization(#1) {
\pgfooappend{at start visualization}{#1}
}%
% Method
\method at end survey(#1) {
\pgfooprefix{at end survey}{#1}
}%
\method after survey(#1) {
\pgfooprefix{after survey}{#1}
}%
\method at end visualization(#1) {
\pgfooprefix{at end visualization}{#1}
}%
\method after visualization(#1) {
\pgfooprefix{after visualization}{#1}
}%
% Method
%
% Copy the signals to macros. This is just for efficiency (ha!)
\method prepare signal macros() {
\pgfooget{prepare datapoint signal}\pgf@signalpreparedatapoint
\pgfooget{map datapoint signal}\pgf@signalmapdatapoint
\pgfooget{transform datapoint signal}\pgf@signaltransformdatapoint
\pgfooget{visualize datapoint signal}\pgf@signalvisualizedatapoint
\pgfooget{finish datapoint signal}\pgf@signalfinishdatapoint
\pgfooget{survey datapoint signal}\pgf@signalsurveydatapoint
\pgfooget{phase signal}\pgf@signalphase
\pgfooget{path signal}\pgf@signalpath
\pgfooget{direction signal}\pgf@signaldirection
\pgfooget{style signal}\pgf@signalstyle
}%
% Survey method
%
% Call this method to "survey" the data. This should be done before
% the "visualize" method is called.
\method survey() {
% Survey phase.
\let\pgfdatapoint=\pgfdatapoint@surveyphase%
\pgfoothis.prepare signal macros()
\pgfooset{survey count}{1}
\pgfutil@loop
\pgf@signalphase.emit(\pgfdvbeforesurvey)
\pgfoovalueof{before survey}%
\pgf@signalphase.emit(\pgfdvbeginsurvey)
\pgfoovalueof{at start survey}
\pgfoovalueof{data}%
\pgfoovalueof{at end survey}
\pgf@signalphase.emit(\pgfdvendsurvey)%
\pgfoovalueof{after survey}
\pgf@signalphase.emit(\pgfdvaftersurvey)
\c@pgf@counta=\pgfoovalueof{survey count}\relax
\c@pgf@countb=\pgfoovalueof{number of surveys}\relax
\ifnum\c@pgf@counta<\c@pgf@countb
\advance\c@pgf@counta by1\relax
\pgfooeset{survey count}{\the\c@pgf@counta}
\pgfutil@repeat
}%
% Getter
\method get survey count(#1) {
\pgfooget{survey count}{#1}
}%
% Request another survey to be done
\method do an additional survey() {
\c@pgf@counta=\pgfoovalueof{number of surveys}\relax
\advance\c@pgf@counta by1\relax
\pgfooeset{number of surveys}{\the\c@pgf@counta}
}%
% Visualize method
%
% This method will cause the actual visualization.
\method visualize() {
% Visualization phase.
\let\pgfdatapoint=\pgfdatapoint@visualizationphase%
\pgfoothis.prepare signal macros()
\pgf@signalphase.emit(\pgfdvbeforevisualization)%
\pgfoovalueof{before visualization}
\pgf@signalphase.emit(\pgfdvbeginvisualization)%
\pgfoovalueof{at start visualization}
\pgfoovalueof{data}%
\pgfoovalueof{at end visualization}
\pgf@signalphase.emit(\pgfdvendvisualization)%
\pgfoovalueof{after visualization}
\pgf@signalphase.emit(\pgfdvaftervisualization)%
}%
}%
%
% The data point keys
%
% Unlike other keys, the subkeys of /data point/ can simply be set
% directly. If the key has not been initialized, it will automatically
% be.
\pgfkeys{/data point/.unknown/.code={%
\pgfkeyssetvalue{/data point/\pgfkeyscurrentname}{#1}
},
}%
% Create and handle a data point
%
% Description:
%
% This command is called by the survey and the visualize methods
% whenever a complete data point has been produced. Depending on the
% current circumstances, different signals will be emitted.
%
% The data that is represented by the data point is not given as a
% parameter. Rather, it is stored in macros and keys, that is, the
% data point is conceptually given by the settings of all the keys and
% macros in the local scope.
%
% There are two phases to data processing: In the survey phase data
% points are produced and handled in order to find out things like
% their number or the minimum and maximum values of attributes, so
% that axes and picture sizes can be prepared correctly. In the
% visualization phase, data point are actually shown.
%
% During the survey phase, for each data point the signal
% "surveydatapoint" is emitted.
%
% During the visualization phase, more signals are emitted. A prepare
% signal is emitted first, giving all objects a
% chance to "prepare" for the data point. Note that it is permissible
% for an object to manipulate the data point here (and also
% in later on).
%
% Next, the command \pgfdvmapdatapointtocanvas is called. Mainly,
% the effect of this command is to setup the keys /data point/canvas x
% and /data point/canvas y, see the description of this command for
% more details.
%
% The next step consists of signaling "visualize data point". Objects
% listening to this will cause some form of visualization of the
% data point to occur.
%
% Before the visualization is started, it is checked whether the key
% /data point/name is set (to a non-empty value). If so,
% a coordinate is created with the given canvas x and y values and
% this key's value as name.
%
% Finally, finish data point allows objects to do any final processing
% of the data point.
\def\pgfdatapoint@surveyphase{%
\pgf@signalpreparedatapoint.emit()%
\pgf@signalmapdatapoint.emit()%
\pgf@signalsurveydatapoint.emit()%
}%
\def\pgfdatapoint@visualizationphase{%
\pgf@signalpreparedatapoint.emit()%
\pgfdvmapdatapointtocanvas%
\pgfkeysifdefined{/data point/name}
{%
\pgfcoordinate{\pgfkeysvalueof{/data point/name}}{\pgfpointdvdatapoint}%
}{}%
\pgf@signalvisualizedatapoint.emit()%
\pgf@signalfinishdatapoint.emit()%
}%
% Compute a position of a data point
%
% Description:
%
% This command uses a special signal to compute the position where a
% data point should be visualized on the canvas. In detail, the
% following happens:
%
% A local scope is created and the
% transformation matrix is reset. Then, two signals are emitted: First,
% "map data points" and then "transform data point". The first
% lets listening objects "map" the object by setting up
% attributes of the data point. The second asks objects
% listening to this signal to transform the current transformation
% matrix. After the signals, we compute where
% the origin lies inside this transformed coordinate system. Then the
% two keys /data point/canvas x and /data point/canvas y are set to
% the values of this position. The local scope ends (but the settings
% of the keys persist by a bit of magic), thus restoring the
% transformation matrix to its original value.
\def\pgfdvmapdatapointtocanvas{%
{%
\pgfpointdvlocaldatapoint
% Smuggle outside group
\expandafter%
}%
\edef\pgf@marshal{%
\noexpand\pgfkeyssetvalue{/data point/canvas x}{\the\pgf@x}
\noexpand\pgfkeyssetvalue{/data point/canvas y}{\the\pgf@y}
}%
\pgf@marshal%
}%
% Help functions for locating a canvas data point
%
% Description:
%
% The first function returns the data point computed by a
% canvasposition... call.
\def\pgfpointdvdatapoint{%
\pgfqpoint{\pgfkeysvalueof{/data point/canvas x}}{\pgfkeysvalueof{/data point/canvas y}}%
}%
\def\pgfpointdvlocaldatapoint{%
{%
% only returns the data point in \pgf@x and \pgf@y, does not set
% canvas x and canvas y
\pgf@signalmapdatapoint.emit()%
\pgftransformreset%
\pgf@signaltransformdatapoint.emit()%
\pgfpointtransformed{\pgfpointorigin}%
}%
}%
%
% Special path constructions commands
%
%
% The following commands are used to construct paths based on
% datapoints.
%
% Normally, all these methods need to do is to compute the current
% canvas position of the current data point and then do a moveto,
% lineto or some other operation to this position.
%
% However, when the coordinate system is weird, like with polar
% coordinates or spherical or log-polar coordinate or whatever, a
% straight line "along an attribute" is no longer a straight line.
% In this case, two actions can be taken:
%
% 1. The problem can be ignored, resulting in a wrong line.
% 2. Some clever algorithm kicks in an replaces the straight line by
% the correct replacement.
%
% As always, when a computer tries to be clever, things can go
% wrong... Nevertheless, some support for the second method is
% given. This works as follows: Objects can register to the data
% visualization path signal. This signal is emitted every time the
% lineto or moveto commands are executed. If an object reacts to such
% a command and handles it, it should set
% \pgfdvhandledtrue.
\newif\ifpgfdvhandled
\def\pgfdv@generic#1#2#3{%
{%
\pgfdvhandledfalse%
\pgf@signalmapdatapoint.emit()%
#1.emit(#2)%
\ifpgfdvhandled%
\else%
\pgf@process{%
\pgftransformreset%
\pgf@signaltransformdatapoint.emit()%
\pgfpointtransformed{\pgfpointorigin}%
}%
#3{}%
\fi%
}%
}%
% Handle a moveto
%
% This command has no parameters since the target of the moveto is
% given by the canvas position of the current local data point.
\def\pgfpathdvmoveto{%
\pgfdv@generic{\pgf@signalpath}{\pgfdvpathmovetotoken}{\pgfpathmoveto}
}%
% Handle a lineto
%
% This command has no parameters since the target of the moveto is
% given by the canvas position of the current local data point.
\def\pgfpathdvlineto{%
\pgfdv@generic{\pgf@signalpath}{\pgfdvpathlinetotoken}{\pgfpathlineto}
}%
% Compute a normalized vector at the current point pointing along a
% line from #1 to #2.
%
% #1 = code for setting the attributes of the first point
% #2 = code for setting the attributes of the second point
%
% The current point should be a point on a line from #1 to
% #2. Both points as well as the current point are
% localized on the canvas and a vector pointing from the first point
% to the second one is returned. However, for instance in polar
% coordinates the vector may actually "point along" the angle axis.
%
% Internally, this command first sets up the first data point and then
% emits a "direction" signal with the \pgfdvpathdirectionfromtoken set and
% then sets up the second point and emits the corresponding
% ...totoken. Finally, the \pgfdvpathdirectionattoken is emitted.
%
\def\pgfpointdvdirection#1#2{%
{
{
#1
\pgfdv@generic{\pgf@signaldirection}{\pgfdvdirectionfromtoken}{\xdef\pgf@dv@from{\noexpand\pgfqpoint{\the\pgf@x}{\the\pgf@y}}}
}
{
#2
\pgfdv@generic{\pgf@signaldirection}{\pgfdvdirectiontotoken}{\xdef\pgf@dv@to{\noexpand\pgfqpoint{\the\pgf@x}{\the\pgf@y}}}
}
{\pgfdv@generic{\pgf@signaldirection}{\pgfdvdirectionattoken}{%
\pgf@process{
\pgfpointnormalised{%
\pgfpointdiff{\pgf@dv@from}{\pgf@dv@to}
}
}}}
}
}%
%
%
% Data parsing and formatting
%
%
% Run the rendering pipeline on a dataset and/or save the dataset.
%
% #1 = options with path /pgf/data/
% #2 = optionally data given inline in curly braces.
%
% Description:
%
% This command is used to define a data set. For a single data
% visualization, multiple data sets can be defined, they will
% accumulate. Data can be in different formats, as specified by the
% "format" key, and you can define new formats.
%
% The settings of the following keys are important:
%
% /pgf/data visualization/obj
% contains a handle to the dv-object
%
% /pgf/data/format
% stores the format (see below)
%
% /pgf/data/read from file
% determines where the data is.
%
% /pgf/data/store in group
% when nonempty, the data is stored here instead of being fed to the
% rendering pipeline
%
% /pgf/data/use group
% when nonempty, data that has previously been stored here using
% |define group| is read from here and all other keys are ignored
%
% If "read from file" is empty, the data is stored in the argument that
% follows. Otherwise, the data is read from the specified source file.
% This data is stored in an internal variable, which is local to the
% current group.
%
% After the group, the key "/pgf/data/continue code" will be
% executed.
%
% When the data is actually used later on (during a survey or a
% visualization), independently of what source is used, a format
% handler is started for each data set. This works as follows: first,
% the handler's startup code is executed. Then for each line of the
% data file/the data given inline, the line handler function is
% called. Finally, the data format end handler is called.
%
% The format handler's job is to call \pgfdatapoint each time a
% complete data point has been produced.
%
% Example:
%
% \pgfoonew \dv=new data visualization()
% \pgfoonew \obj=new attribute mapper(...)
% ...
%
% \pgfkeys{/pgf/data/.cd,
% column 1=dax/low,
% column 2=dax/high,
% column 3=dax/entry,
% column 4=dax/exit}
%
% \pgfdata[format=space separated columns]
% {
% % today
% 2000 2300 2100 2200
% 2000 2350 2200 2500
% 2200 2300 2250 2260
% 1800 2260 2260 1900
% 2000 2300 2100 2200
% }
%
% \pgfdata[format=comma separated columns]
% {
% % yesterday
% 2000, 2350, 2200, 2250
% 2200, 2300, 2250, 2260
% }
%
% \pgfdata[read from file=data.csv,format=comma separated columns]
%
% \dv.survey()
% \dv.visualize()
\def\pgfdata{\pgfutil@ifnextchar[{\pgf@datagroup@data@opt}{\pgf@datagroup@data@opt[]}}%}%
\def\pgf@datagroup@data@opt[#1]{%
% Ok, add one data thing...
\begingroup%
\pgfkeys{/pgf/data/.cd,/pgf/every data/.try,#1}%
\pgfkeysgetvalue{/pgf/data/continue code}\pgf@dv@cont@code%
\global\let\pgf@dv@cont@code\pgf@dv@cont@code%
\pgfkeysgetvalue{/pgf/data/use group}\pgf@dv@use@group%
\ifx\pgf@dv@use@group\pgfutil@empty%
\pgf@dv@do@adddata{\pgfkeysvalueof{/pgf/data visualization/obj}.add data(\pgf@do@data{#1})}%
\expandafter\pgf@datagroup@data@opt@cont%
\else%
\expandafter\ifx\csname pgf@dv@group@@\pgf@dv@use@group\endcsname\relax%
\pgferror{Undefined data group '\pgf@dv@use@group'}%
\else%
{%
\pgfkeys{/pgf/data/define group/.code=}% no redefinitions during use
\csname pgf@dv@group@@\pgf@dv@use@group\endcsname%
}%
\fi%
\endgroup%
\expandafter\pgf@dv@cont@code%
\fi%
}%
\def\pgf@datagroup@data@opt@cont{%
\pgfkeysgetvalue{/pgf/data/format}\pgf@dv@format%
\expandafter\let\expandafter\pgf@dv@format@catcodes\csname pgfdv@format@\pgf@dv@format @catcodes\endcsname%
\ifx\pgf@dv@format@catcodes\relax
\pgferror{Unknown data format '\pgf@dv@format'}%
\else%
\pgfkeysgetvalue{/pgf/data/read from file}\pgf@dv@source%
\ifx\pgf@dv@source\pgfutil@empty%
\let\pgf@next\pgf@datagroup@grab@inline%
\else%
\let\pgf@next\pgf@datagroup@grab@external%
\fi%
\pgf@next%
}%
\def\pgf@datagroup@grab@inline{%
\pgfutil@ifnextchar\bgroup{%
\begingroup%
\catcode`\^^M=\active%
\pgf@dv@format@catcodes%
\pgf@datagroup@grab@@inline}%
{\pgferror{Opening brace expected}}%
}%
\def\pgf@datagroup@grab@external{%
\fi%
\endgroup%
\pgf@dv@do@adddata{\pgfkeysvalueof{/pgf/data visualization/obj}.add data({{{\pgf@datagroup@do@external}}})}%
\pgf@dv@cont@code%
}%
\def\pgf@dv@do@adddata#1{%
\pgfkeysgetvalue{/pgf/data/store in group}\pgf@dv@temp%
\ifx\pgf@dv@temp\pgfutil@empty%
#1%
\else%
\expandafter\pgfutil@g@addto@macro\csname pgf@dv@group@@\pgf@dv@temp\endcsname{#1}%
\fi%
}%
{\catcode`\^=7 \catcode`\^^M=13
\gdef\pgf@datagroup@grab@@inline#1{%
\endgroup%
\pgf@dv@do@adddata{\pgfkeysvalueof{/pgf/data visualization/obj}.add data({{{\pgf@datagroup@do@inline#1^^M\pgf@@eol}}})}%
\fi%
\endgroup%
\pgf@dv@cont@code%
}%
}%
\def\pgf@@eol{\pgf@eol}%
\def\pgf@do@data#1#2{%
\begingroup%
\pgfkeys{/pgf/data/.cd,/pgf/every data/.try,#1}%
\pgfkeysgetvalue{/pgf/data/format}\pgf@dv@format%
\expandafter\let\expandafter\pgf@dv@format@line\csname pgfdv@format@\pgf@dv@format @line\endcsname%
\expandafter\let\expandafter\pgf@dv@format@emptyline\csname pgfdv@format@\pgf@dv@format @empty\endcsname%
\csname pgfdv@format@\pgfkeysvalueof{/pgf/data/format}@startup\endcsname%
#2%
\csname pgfdv@format@\pgfkeysvalueof{/pgf/data/format}@end\endcsname%
\endgroup%
}%
%
% Read external file
%
\def\pgf@datagroup@do@external{%
\csname pgfdv@format@\pgfkeysvalueof{/pgf/data/format}@catcodes\endcsname%
\immediate\openin\r@pgf@reada=\pgfkeysvalueof{/pgf/data/read from file} %
\ifeof\r@pgf@reada\relax
\pgferror{Data file '\pgfkeysvalueof{/pgf/data/read from file}' not found}%
\else
\pgf@datagroup@readline%
\fi
\immediate\closein\r@pgf@reada%
}%
\def\pgf@partext{\par}%
\def\pgf@datagroup@readline{%
\immediate\read\r@pgf@reada to \pgf@temp%
\ifx\pgf@temp\pgf@partext%
\pgf@dv@format@emptyline%
\else%
\ifx\pgf@temp\pgfutil@empty%
\pgf@dv@format@emptyline%
\else%
\expandafter\pgf@dv@format@line\pgf@temp\pgfeol%
\fi%
\fi%
\ifeof\r@pgf@reada\else\expandafter\pgf@datagroup@readline\fi%
}%
%
% Read inline data
%
\def\pgf@datagroup@do@inline{%
\pgf@dv@handle@line%
}%
{\catcode`\^=7 \catcode`\^^M=13
\gdef\pgf@dv@handle@line{%
\pgfutil@ifnextchar^^M{\pgf@dv@format@emptyline\expandafter\pgf@dv@handle@line\pgfutil@gobble}%
{\pgfutil@ifnextchar\pgf@@eol{\pgfutil@gobble}{\pgf@dv@handle@nonemptyline}}%
}%
\gdef\pgf@dv@handle@nonemptyline#1^^M{%
\pgf@dv@format@line#1\pgfeol%
\pgf@dv@handle@line%
}%
}%
\pgfkeys{
/pgf/data/data visualization obj/.initial=\undefined,
/pgf/data/format/.initial=table,% the default format
/pgf/data/read from file/.initial=,
/pgf/data/inline/.style={read from file=},
/pgf/data/continue code/.initial=,
/pgf/data/store in group/.initial=,
/pgf/data/new group/.code={\expandafter\global\expandafter\let\csname pgf@dv@group@@#1\endcsname\pgfutil@empty},
/pgf/data/use group/.initial=,
}%
% Define a data format
%
% #1 = format name
% #2 = catcode code
% #3 = startup code
% #4 = line arguments
% #5 = line code
% #6 = empty line code
% #7 = end code
%
% Description:
%
% This command defines a new data format for data visualization. When
% a data set is visualized and the format is set to #1, this handler
% is used to parse the data.
%
% In detail, the \pgfdata command will select a source. Before this
% source is read, #2 will be executed to setup the
% catcodes. Additionally, each time the data is parsed, #3 will be
% called. Then, for each nonempty line of the source, the
% command #5 is executed, where the line will be matched against the
% argument pattern given in #4. For empty lines, #6 will be executed
% instead. At the end of the source, #7 will be executed.
\def\pgfdeclaredataformat#1#2#3#4#5#6#7{%
\expandafter\def\csname pgfdv@format@#1@catcodes\endcsname{#2}%
\expandafter\def\csname pgfdv@format@#1@startup\endcsname{#3}%
\expandafter\def\csname pgfdv@format@#1@line\endcsname#4\pgfeol{#5}%
\expandafter\def\csname pgfdv@format@#1@empty\endcsname{#6}%
\expandafter\def\csname pgfdv@format@#1@end\endcsname{#7}%
}%
%
% Predefined standard formats
%
% TeX code format
%
% Description:
%
% The lines of the data set are assumed to contain executable TeX
% code that will call \pgfdatapoint.
%
% Example:
%
% \pgfdatavisualizationrender[format=TeX code]
% \dataset{
% \pgfkeyssetvalue{/data point/x}{5}
% \pgfkeyssetvalue{/data point/y}{5}
% \pgfdatapoint
% \pgfkeyssetvalue{/data point/x}{6}
% \pgfkeyssetvalue{/data point/y}{6}
% \pgfdatapoint
% }
\pgfdeclaredataformat{TeX code}{}{}{#1}{#1 }{}{}%
% Key-value lines format
%
% Description:
%
% The lines of the data set are passed to \pgfkeys with the path set
% to /data point.
%
% Example:
%
% \data[format=named] {
% x=5, y=6, hi=9
% x=7, y=6, lo=10
% }
\pgfdeclaredataformat{named}{}{}{#1}{\pgf@dv@parse@named#1,\pgf@stop}{}{}%
\def\pgf@dv@parse@named{%
\pgfutil@ifnextchar\pgf@stop{\pgfdatapoint\pgfutil@gobble}{\pgf@dv@parse@named@}
}%
\def\pgf@dv@parse@named@#1=#2,#3\pgf@stop{%
\foreach \pgf@dv@temp in {#2} {%
\def\pgf@dv@tempb{/data point/#1=}%
\expandafter\expandafter\expandafter\pgfkeys%
\expandafter\expandafter\expandafter{\expandafter\pgf@dv@tempb\pgf@dv@temp}%
\pgf@dv@parse@named#3\pgf@stop%
}
}%
% Table format
%
% Description:
%
% A table consists of a head line, which contains the attribute names
% of the values that will be found in the following lines. Each line
% (except for the headline) contains one data point.
%
% Inside each line the data points are separated by a separator like a
% comma or a space or a colon. The separator can be configured using
% the key /pgf/data/separator (leave the separator empty or set it to
% \space for a space as separator). The default separator is a comma.
%
% Some tables will miss the headline. In this case, using the
% /pgf/data/headline key you can provide a headline yourself.
%
% Example:
%
% \data[format=table] {
% x y
% 10 5
% 11 6
% 6 7
% }
%
% \data[format=table,separator={,}] {
% x, y
% 10, 5
% 11, 6
% 6, 7
% }
%
% \data[format=table,headline=x y] {
% 10 5
% 11 6
% 6 7
% }
\pgfdeclaredataformat{table}
{} % no catcodes
{
\pgfkeysgetvalue{/pgf/data/headline}\pgf@dv@headline
\pgfkeysgetvalue{/pgf/data/separator}\pgf@dv@separator
\ifx\pgf@dv@separator\pgfutil@empty
\let\pgf@dv@separator\space
\fi
\ifx\pgf@dv@separator\pgf@dv@spacetext
\let\pgf@dv@separator\space
\fi
\expandafter\def\expandafter\pgf@dv@till@separator%
\expandafter##\expandafter1\pgf@dv@separator{\pgf@dv@table@handle{##1}}
\expandafter\def\expandafter\pgf@dv@till@separator@head%
\expandafter##\expandafter1\pgf@dv@separator{\pgf@dv@head@handle{##1}}
\ifx\pgf@dv@headline\pgfutil@empty
% Ok, read headline from file
\pgfdv@firstlinetrue
\else
% Headline already set
\pgfdv@firstlinefalse
\expandafter\pgf@dv@parse@headline\expandafter{\pgf@dv@headline}
\fi
}
{#1} % special line pattern, so read everything
{
\ifpgfdv@firstline
\pgfdv@firstlinefalse
\pgf@dv@parse@headline{#1}
\else
{
\c@pgf@counta=0\relax% keep track of attribute number
\def\pgf@marshal{\pgf@dv@parse@table#1}
\expandafter\expandafter\expandafter\pgf@marshal%
\expandafter\pgf@dv@separator\expandafter\pgfeol\pgf@dv@separator
\pgfdatapoint
}
\fi
}
{}% ignore empty lines
{}% no special end code
\newif\ifpgfdv@firstline
\pgfkeys{
/pgf/data/separator/.initial={,},
/pgf/data/headline/.initial=
}%
\def\pgf@dv@spacetext{\space}%
\def\pgf@dv@parse@table{%
\pgfutil@ifnextchar"% Special, but ignored right now...
{\pgferror{csv with quotes not yet implemented}}
{\pgf@dv@till@separator}
}%
\def\pgf@dv@table@handle#1{%
\def\pgf@temp{#1}%
\ifx\pgf@temp\pgfeoltext%
% Bingo! Stop
\let\pgf@next=\relax%
\else%
\advance\c@pgf@counta by1\relax%
\pgfkeysgetvalue{/pgf/data/table/attribute \the\c@pgf@counta}\pgf@dv@target
\ifx\pgf@dv@target\relax%
\edef\pgf@dv@target{attribute \the\c@pgf@counta}
\pgfkeyslet{/pgf/data/table/attribute \the\c@pgf@counta}\pgf@dv@target
\fi
\pgfkeyssetvalue{/data point/\pgf@dv@target}{#1}
\let\pgf@next=\pgf@dv@parse@table%
\fi%
\pgf@next%
}%
\def\pgf@dv@parse@headline#1{
\c@pgf@counta=0\relax% keep track of attribute number
\def\pgf@marshal{\pgf@dv@doparse@headline#1}
\expandafter\expandafter\expandafter\pgf@marshal%
\expandafter\pgf@dv@separator\expandafter\pgfeol\pgf@dv@separator
}%
\def\pgf@dv@doparse@headline{%
\pgfutil@ifnextchar"% Special, but ignored right now...
{\pgferror{csv with quotes not yet implemented}}
{\pgf@dv@till@separator@head}
}%
\def\pgf@dv@head@handle#1{%
\def\pgf@temp{#1}%
\ifx\pgf@temp\pgfeoltext%
% Bingo! Stop
\let\pgf@next=\relax%
\else%
\advance\c@pgf@counta by1\relax%
\pgfkeyssetvalue{/pgf/data/table/attribute \the\c@pgf@counta}{#1}
\let\pgf@next=\pgf@dv@doparse@headline%
\fi%
\pgf@next%
}%
\def\pgfeoltext{\pgfeol}%
%
%
% Micro math kernel for dv
%
%
% The idea behind the following methods is to "abstract away" which
% math engine is used. In the future, something fancy build on luatex
% might be used, so it would we should not rely directly on the
% fpu library code.
%
% The system works as follows: First, you "enter" a number into the
% engine. When you do so, it is converted into some internal
% representation that cannot be accessed any more and is called a
% "math variable" henceforth. All commands of the
% math system only work on math variables.
%
% In order to "exit" a value stored in a math variable from the
% engine, some other macros can be used.
%
% Operations like addition or multiplication take two math variables
% and store the result in another math variable.
% Store a value in a math variable of the math engine
%
% #1 = a math variable (a macro name) that is to store the value
% #2 = an expression describing a number
%
%
% Description:
%
% The #2 should be an expression that evaluates to a number. However,
% due to the way the pgf math engine(s) work, currently, there are
% several restrictions/the syntax is not as simple as one might
% hope. Fortunately, the syntax is hopefully compatible with
% easier-to-use future systems.
%
% The syntax is as follows: #2 may be
%
% 1. a simple high-precision number. This number is currently directly
% passed to \pgfmathfloatparsenumber, so typical permissible values
% are "100" or "10000000000000" or "nan" or "-5.673543345345e9000"
%
% 2. a mathematical expression, which *must* be surrounded by
% parentheses. From a "mathematical" point of view these
% parentheses are superfluous, but the they are used to help pgf
% distinguish expressions from high-precision numbers. (If, in the
% future, expressions may contain high precision numbers, the
% parentheses will simply be ignored.)
%
% The expression is evaluated using \pgfmathparse, which means that
% TeX-precision is used. This means, for instance, that numbers
% larger than about 16500 will create error messages.
%
% The advantage is that you may say write things like "(5+6)" or
% "(pi/2)".
%
% 3. In case #2 starts with an exclamation mark (indicating an
% "escape"), everything following the mark is simply evaluated by
% TeX. The effect of evaluating #2 should be that the math
% variable "\pgfdvmathvalue" is set to some value. This value will
% then be transferred to #1.
%
% 4. In case #2 is the result of calling \pgfdvmathexitbyserializing, the
% "serialized" value is restored. The idea is that the serialized
% will turn its internal representation of a number into something
% that can be stored as a text somewhere.
%
% Currently, "@" at the beginning of #2 is used to indicate that
% what follows is a serialized version of a math variable.
%
% In order to determine which of the above cases is to be used for a
% variable, the first symbol #2 is checked, *after* the first symbol
% of #2 has been expanded once (using \expandafter once).
%
% Example:
%
% \pgfdvmathenter{\mymacro}{20000000000000}
% \pgfdvmathenter{\mymacro}{(5+pi)}
% \pgfdvmathenter{\mymacro}{!\pgfdvmathadd{\pgfdvmathvalue}{\a}{\b}}
%
% \pgfdvmathenter{\foo}{5}
% \pgfdvmathexitbyserializing{\somevalue}{\foo}
% \pgfdvmathenter{\mymacro}{\somevalue}
\def\pgfdvmathenter#1#2{%
\expandafter\pgfdvmathenter@check\expandafter#1#2\pgfdvmath@end%
}%
\def\pgfdvmathenter@check#1{%
\pgfutil@ifnextchar @{\pgfdvmath@internal#1}{%
\pgfutil@ifnextchar ({\pgfdvmath@expression#1}{%)
\pgfutil@ifnextchar !{\pgfdvmath@execute#1}{\pgfdvmath@normal#1}}}%
}%
\def\pgfdvmath@internal#1@#2\pgfdvmath@end{%
\def#1{#2}%
}%
\def\pgfdvmath@expression#1(#2)#3\pgfdvmath@end{%
\pgfmathparse{#2}%
\pgfmathfloatparsenumber{\pgfmathresult}%
\let#1=\pgfmathresult%
}%
\def\pgfdvmath@execute#1!#2\pgfdvmath@end{%
#2%
\let#1=\pgfdvmathvalue%
}%
\def\pgfdvmath@normal#1#2\pgfdvmath@end{%
\pgfmathfloatparsenumber{#2}%
\let#1=\pgfmathresult%
}%
% Print a math variable in the math engine using \pgfmathprintnumber
%
% #1 = math variable
%
% Description:
%
% See the description of \pgfmathprintnumber
%
% Example:
%
% \pgfdvmathenter{\mymacro}{20000000000000}
% \pgfdvmathexitbyprinting{\mymacro}
\def\pgfdvmathexitbyprinting#1{%
\pgfmathprintnumber{#1}%
}%
% Exit a math variable as a number in a scientific and portable number
% format in a macro
%
% #1 = macro in which to store the value
% #2 = math variable
%
% Description:
%
% You can exit a number using this operation. You can then directly
% reenter the number using \pgfdvmathenter
%
% Example:
%
% \pgfdvmathenter{\mynumber}{20000000000000}
% \pgfdvmathexitbyscientificformat{\mymacro}{\mynumber}
\def\pgfdvmathexitbyscientificformat#1#2{%
\edef#1{\pgfmathfloatvalueof#2}%
}%
% Exit a math variable as a "serialized" (= string-based)
% version.
%
% #1 = macro in which to store the value
% #2 = math variable
%
% Description:
%
% The serialized version can be reentered using
% \pgfmathenter and is similar to \pgfdvmathexitbyscientificformat,
% but exiting and entering are (a bit) faster.
%
% Example:
%
% \pgfdvmathenter{\mynumber}{20000000000000}
% \pgfdvmathexitbyserializing{\mymacro}{\mynumber}
\def\pgfdvmathexitbyserializing#1#2{%
\edef#1{@#2}%
}%
% Operations on two numbers
%
% #1 = macro that should store the result of applying the
% corresponding operation to the following:
% #2 = entered number
% #3 = entered number
%
% Description:
%
% Sets #1 to the result of applying an operation to #2 and #3
%
% Example:
%
% \pgfdvmathenter{\a}{2000}
% \pgfdvmathenter{\b}{5+6}
% \pgfdvmathadd{\c}{\a}{\b}
\def\pgfdvmathadd#1#2#3{%
\pgfmathfloatadd{#2}{#3}%
\let#1=\pgfmathresult%
}%
\def\pgfdvmathsub#1#2#3{%
\pgfmathfloatsubtract{#2}{#3}%
\let#1=\pgfmathresult%
}%
\def\pgfdvmathmul#1#2#3{%
\pgfmathfloatmultiply{#2}{#3}%
\let#1=\pgfmathresult%
}%
\def\pgfdvmathdiv#1#2#3{%
\pgfmathfloatdivide{#2}{#3}%
\let#1=\pgfmathresult%
}%
% Multiply by small number
%
% #1 = macro that should store the result of applying the
% corresponding operation to the following:
% #2 = entered number
% #3 = fixed point number like 2 or 0.5, but not 10000000000
%
% Description:
%
% Sets #1 to the result of applying an operation to #2 and #3
%
% Example:
%
% \pgfdvmathenter{\a}{2000}
% \pgfdvmathadd{\b}{\a}{0.2}
% % \b now stores 400
\def\pgfdvmathmulfixed#1#2#3{%
\pgfmathfloatmultiplyfixed{#2}{#3}%
\let#1=\pgfmathresult%
}%
% Log, ln and exponent functions
%
% #1 = a math variable
% #2 = a math variable
%
% Description
%
% \pgfdvmathln will compute #1 = ln(#2)
% \pgfdvmathlog will compute #1 = log_{10}(#2)
% \pgfdvmathexp will compute #1 = exp(#2)
% \pgfdvmathpowten will compute #1 = 10^{#2}
\def\pgfdvmathln#1#2{%
\pgfmathfloatln{#2}%
\let#1=\pgfmathresult%
}%
\def\pgfdvmathlog#1#2{%
\pgfmathfloatln{#2}%
\pgfmathfloatmultiply{\pgfmathresult}{\pgfdvmathalwaysloge}%
\let#1=\pgfmathresult%
}%
\def\pgfdvmathexp#1#2{%
\pgfmathfloatexp{#2}%
\let#1=\pgfmathresult%
}%
\def\pgfdvmathpowten#1#2{%
\pgfmathfloattofixed{#2}%
\let\pgf@dv@temp=\pgfmathresult%
\pgfmathround{\pgf@dv@temp}%
\let\pgf@dv@temp@round=\pgfmathresult%
\pgf@x=\pgf@dv@temp@round pt%
\pgf@x=-\pgf@x%
\advance\pgf@x by\pgf@dv@temp pt\relax%
\ifdim\pgf@x>0.0002pt%
\pgfmathfloatmultiply{#2}{\pgfdvmathalwayslnten}%
\pgfmathfloatexp{\pgfmathresult}%
\else
\ifdim\pgf@x<-0.0002pt%
\pgfmathfloatmultiply{#2}{\pgfdvmathalwayslnten}%
\pgfmathfloatexp{\pgfmathresult}%
\else
\pgf@x=\pgf@dv@temp@round sp%
\c@pgf@counta=\pgf@x%
\pgfmathfloatcreate{1}{1.0}{\the\c@pgf@counta}%
\fi
\fi
\let#1=\pgfmathresult%
}%
% Floor functions
%
% #1 = a math variable
% #2 = a math variable
%
% Description
%
% Sets #1 to the largest integer less or equal to #2
\def\pgfdvmathfloor#1#2{%
\pgfmathifisint{#2}{%
\let#1=#2%
}{%
\pgfmathfloatgetflags#2\c@pgf@counta%
\ifcase\c@pgf@counta
\let#1=\pgfdvmathalwayszero%
\or
\pgfmathfloatfloor{#2}%
\let#1=\pgfmathresult%
\or
\pgfmathfloatsubtract{\pgfdvmathalwaysone}{#2}%
\pgfmathfloatfloor{\pgfmathresult}%
\pgfmathfloatsubtract{\pgfdvmathalwayszero}{\pgfmathresult}%
\let#1=\pgfmathresult%
\or\let#1=#2%
\or\let#1=#2%
\or\let#1=#2%
\fi%
}%
}%
% Advanced unary operations
%
% #1 = macro that should store the result of applying the
% operation to an entered number
% #2 = the operation (as a string like "ln")
% #3 = entered number
%
% Description:
%
% Sets #1 to the result of applying #2 to #3
%
% Example:
%
% \pgfdvmathenter{\a}{2000}
% \pgfdvmathunaryop{\b}{ln}{\a}
\def\pgfdvmathunaryop#1#2#3{%
\csname pgfmathfloat#2\endcsname{#3}%
\let#1=\pgfmathresult%
}%
% Advanced binary operations
%
% #1 = macro that should store the result of applying the
% operation to two entered number
% #2 = the operation (as a string like "veclen")
% #3 = first argument (an entered number)
% #4 = second argument (an entered number)
%
% Description:
%
% Sets #1 to the result of applying #2 to #3
%
% Example:
%
% \pgfdvmathenter{\a}{3}
% \pgfdvmathenter{\b}{4}
% \pgfdvmathbinop{\c}{veclen}{\a}{\b}
\def\pgfdvmathbinop#1#2#3#4{%
\csname pgfmathfloat#2\endcsname{#3}{#4}%
\let#1=\pgfmathresult%
}%
% Comparing values
%
% #1 = first math variable
% #2 = second math variable
% #3 = code to-be-executed if #1 < #2
% #4 = code to-be-executed if #1 >= #2
%
%
% Example:
%
% \pgfdvmathenter{\a}{3}
% \pgfdvmathenter{\b}{4}
% \pgfdvmathifless{\a}{\b}{yes}{should not happen}
\def\pgfdvmathifless#1#2#3#4{%
\pgfmathfloatlessthan{#1}{#2}%
\ifpgfmathfloatcomparison#3\else#4\fi%
}%
%
%
% Standard objects for data visualization
%
%
%
% Transformers
%
\pgfooclass{linear transformer}
{%
% Class linear transformer
%
% This class is a transformer class. It reacts to the transform
% datapoint signal. When this signal is raised, it will shift the
% coordinate system as follows: If the current value of /data
% point/this.attribute is 0, then the system is shifted to the
% current value of this.origin. If the current value is 1, the
% system is shifted to this.origin + this.unit vector. For other
% values of /data point/this.attribuate, the shift is interpolated
% between these two values.
\attribute attribute;%
% The attribute (/data point/this.attribute) by which
% the unit vector is multiplied. If it is empty (which is
% different from 0), no transformation is done at all.
\attribute origin = \pgfpointorigin;%
% The shift in case the /data point/this.attribute is 0.
\attribute unit vector;%
% The coordinate system is additionally shifted by this amount
% times the current value of /data point/this.attribute.
% Constructor
%
% #1 = attribute that is being transformed. Example: x
% #2 = a vector corresponding to one unit of #1.
% Example: \pgfpoint{1cm}{0cm}
\method linear transformer(#1,#2) {
\pgfooset{attribute}{#1}
\pgf@process{#2}
\edef\pgf@temp{\noexpand\pgfqpoint{\the\pgf@x}{\the\pgf@y}}
\pgfoolet{unit vector}\pgf@temp%
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,transform,transform datapoint signal)
}%
% Setter
\method set origin(#1) {
\pgf@process{#1}
\edef\pgf@temp{\noexpand\pgfqpoint{\the\pgf@x}{\the\pgf@y}}
\pgfoolet{origin}\pgf@temp%
}%
% Slot
%
% This slot should be connected to the transform datapoint
% signal. When this signal is emitted, the coordinate system will be
% shifted according to the current value of the attribute.
\method transform() {
\pgfkeysgetvalue{/data point/\pgfoovalueof{attribute}}\pgf@dv@val%
\ifx\pgf@dv@val\pgfutil@empty%
\else%
\ifx\pgf@dv@val\relax%
\else%
\pgfdvmathenter{\pgf@dv@math@var}{\pgf@dv@val}%
\pgfdvmathexitbyscientificformat{\pgf@dv@val}{\pgf@dv@math@var}%
\pgftransformshift{\pgfoovalueof{origin}}%
\pgfmathfloatgetexponent\pgf@dv@math@var\c@pgf@counta%
\ifnum\c@pgf@counta<-3\relax%
\else%
\pgftransformshift{\pgfpointscale{\pgf@dv@val}{\pgfoovalueof{unit vector}}}%
\fi%
\fi%
\fi%
}%
}%
%
% Numerical mapping of attributes to other attributes
%
\pgfooclass{interval mapper}
{%
% Class interval mapper
%
% This interval mapper reacts to the map datapoint signal. Its purpose is to
% map one attribute to another attribute. For the first attribute,
% an intervals is specified.
%
% In addition to the in interval [a,b] there is also an outinterval
% [c,d]. Values in the range [a,b] are linearly mapped to the
% range [c,d] and the result is stored in the second attribute.
%
% For instance, if the first range is [10,20] and the second range
% is [0,100], then 10 is mapped to 0, 11 is mapped to 10, 20 is
% mapped to 100 and 30 is mapped to 200.
%
% It is permissible to specify an additional non-linear
% transformation function f. In this case, for an input value x the
% position of f(x) inside the interval [f(a),f(b)] is determined and
% this position is linearly mapped to [c,d].
%
% For example, if f(x) = log_10 (x) and the first range [a,b] =
% [10,1000] and the second range is [1,2], then 10 is mapped to 1,
% 100 is mapped to 1.5 (since f(100) = 3 lies in the middle
% between f(10) = 2 and f(1000) = 4) and 100000 is mapped to 3.
\attribute in;%
% The name of the input attribute. If the value of this attribute
% is empty or undefined, no mapping is done.
%
% The in attribute may have a subkey called .../const. If this key
% has a value different from \relax, it will always be used instead
% of the in attribute itself. This can be useful to temporarily
% set a constant value to a key inside a mapping chain.
%
% If the subkey /is min or max is set to "min" or "max", the mapping
% will always be done to the respective out min or out max values.
\attribute out;%
% The name of the output attribute.
\attribute trans;%
% Stores (more or less) the transformation function.
\attribute out min;%
% Start of the second range (the value of c).
\attribute out min;%
% End of the second range (the value of d).
\attribute trans in min;%
% Transformed value of the start of the first range (the value
% f(a)).
\attribute scale;%
% The scaling factor, that is, the value of (f(b)-f(a))/(d-c).
% Constructor
%
% #1 = input attribute. Example: velocity.
% #2 = output attribute. Example: x
% #3 = optional transformation function. The input value for this
% function is stored in entered number \pgfvalue.
% The output of the function should be stored in the
% same entered number.
%
% The intervals are set using setter methods later on.
%
\method interval mapper(#1,#2,#3) {
\pgfooset{in}{#1}
\pgfooset{out}{#2}
\def\pgf@temp{#3}%
\ifx\pgf@temp\pgfutil@empty%
\else%
\pgfooset{trans}{%
#3%
}%
\fi%
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,map,map datapoint signal)
}%
% Method
%
% #1 = in interval minimum
% #2 = in interval maximum
% #3 = out interval minimum
% #4 = out interval maximum
%
% This method will (re)compute the correct mappings for the interval
% mapper.
\method set interval values(#1,#2,#3,#4) {
{%
\pgfdvmathenter{\pgf@in@interval@min}{#1}
\pgfdvmathenter{\pgf@in@interval@max}{#2}
\pgfdvmathenter{\pgf@out@interval@min}{#3}
\pgfdvmathenter{\pgf@out@interval@max}{#4}
% Let's start with the output, it's easier...
\pgfoolet{out min}{\pgf@out@interval@min}
\pgfoolet{out max}{\pgf@out@interval@max}
\pgfdvmathifless{\pgf@in@interval@min}{\pgf@in@interval@max}{%
\pgfdvmathsub{\pgf@out@diff}{\pgf@out@interval@max}{\pgf@out@interval@min}
\let\pgfvalue=\pgf@in@interval@min
\pgfoovalueof{trans}
\let\pgf@in@interval@min@transformed=\pgfvalue
\pgfoolet{trans in min}{\pgf@in@interval@min@transformed}%
\let\pgfvalue=\pgf@in@interval@max
\pgfoovalueof{trans}
\let\pgf@in@interval@max@transformed=\pgfvalue
\pgfdvmathsub{\pgf@diff@in@transformed}{\pgf@in@interval@max@transformed}{\pgf@in@interval@min@transformed}
%
% Precompute the scaling
%
\pgfdvmathdiv{\pgf@scale}{\pgf@out@diff}{\pgf@diff@in@transformed}%
\pgfoolet{scale}{\pgf@scale}%
}{%
\pgfoolet{scale}\pgf@dv@no@scale%
}%
}%
}%
\def\pgf@dv@no@scale{noscale}%
% Slot
\method map() {
\pgfooget{scale}\pgf@dv@scale
\ifx\pgf@dv@scale\pgfutil@empty%
% not yet setup
\else%
\pgfkeysgetvalue{/data point/\pgfoovalueof{in}/is min or max}\pgf@dv@is%
\ifx\pgf@dv@is\pgf@min@text%
\pgf@dv@set@out@min%
\else%
\ifx\pgf@dv@is\pgf@max@text%
\pgf@dv@set@out@max%
\else%
\ifx\pgf@dv@scale\pgf@dv@no@scale%
\pgf@dv@mapper@goto@mid%
\else%
\pgfkeysgetvalue{/data point/\pgfoovalueof{in}/const}\pgf@dv@external@value%
\ifx\pgf@dv@external@value\relax%
\pgfkeysgetvalue{/data point/\pgfoovalueof{in}}\pgf@dv@external@value%
\fi%
\ifx\pgf@dv@external@value\pgfutil@empty%
\pgf@dv@mapper@pos@check%
\else%
\ifx\pgf@dv@external@value\relax%
\pgf@dv@mapper@pos@check%
\else%
\pgfdvmathenter{\pgfvalue}{\pgf@dv@external@value}%
\pgf@dv@mapper@trans
\fi%
\fi%
\fi%
\fi%
\fi%
\fi%
}%
\def\pgf@dv@set@out@min{%
\pgfkeyslet{/data point/\pgfoovalueof{out}/is min or max}\pgf@min@text%
\pgfooget{out min}{\pgf@minmax@temp}%
\pgf@dv@set@out@now%
}%
\def\pgf@dv@set@out@max{%
\pgfkeyslet{/data point/\pgfoovalueof{out}/is min or max}\pgf@max@text%
\pgfooget{out max}{\pgf@minmax@temp}%
\pgf@dv@set@out@now%
}%
\def\pgf@dv@set@out@now{%
\pgfkeysgetvalue{/data point/\pgfoovalueof{out}/offset}\pgf@dv@external@offset%
\ifx\pgf@dv@external@offset\relax\else%
\ifx\pgf@dv@external@offset\pgfutil@empty\else%
\pgfdvmathenter{\pgfvalue}{\pgf@minmax@temp}%
\pgfdvmathenter{\pgf@dv@offset}{\pgf@dv@external@offset}%
\pgfdvmathadd{\pgfvalue}{\pgfvalue}{\pgf@dv@offset}
\pgfdvmathexitbyserializing{\pgf@minmax@temp}{\pgfvalue}%
\fi
\fi
\pgfkeyslet{/data point/\pgfoovalueof{out}}\pgf@minmax@temp%
}%
\def\pgf@dv@mapper@trans{
\pgfooget{trans in min}{\pgf@dv@trans@in@min}%
\pgfooget{scale}{\pgf@dv@scale}%
\pgfooget{out min}{\pgf@dv@out@min}%
\pgfoovalueof{trans}%
\pgfdvmathsub{\pgfvalue}{\pgfvalue}{\pgf@dv@trans@in@min}%
\pgfdvmathmul{\pgfvalue}{\pgfvalue}{\pgf@dv@scale}%
\pgfdvmathadd{\pgfvalue}{\pgfvalue}{\pgf@dv@out@min}%
\pgfkeysgetvalue{/data point/\pgfoovalueof{out}/offset}\pgf@dv@external@offset%
\ifx\pgf@dv@external@offset\relax\else%
\ifx\pgf@dv@external@offset\pgfutil@empty\else%
\pgfdvmathenter{\pgf@dv@offset}{\pgf@dv@external@offset}%
\pgfdvmathadd{\pgfvalue}{\pgfvalue}{\pgf@dv@offset}
\fi
\fi
\pgfdvmathexitbyserializing{\pgf@temp}{\pgfvalue}%
\pgfkeyslet{/data point/\pgfoovalueof{out}}\pgf@temp%
}%
\def\pgf@dv@mapper@pos@check{%
\pgfkeysgetvalue{/data point/\pgfoovalueof{in}/out pos}\pgf@dv@pos@value%
\ifx\pgf@dv@pos@value\relax\else\if\pgf@dv@pos@value\pgfutil@empty\else%
\pgfmathsetmacro{\pgf@dv@pos@num}{\pgf@dv@pos@value}%
\pgfmathsetmacro{\pgf@dv@pos@num@prime}{1-\pgf@dv@pos@num}%
% Ok, compute transformed min position:
\pgfooget{out min}{\pgf@out@interval@min}
\pgfooget{out max}{\pgf@out@interval@max}
\pgfdvmathmulfixed{\pgf@out@interval@min}{\pgf@out@interval@min}{\pgf@dv@pos@num@prime}
\pgfdvmathmulfixed{\pgf@out@interval@max}{\pgf@out@interval@max}{\pgf@dv@pos@num}
\pgfdvmathadd{\pgf@out@val}{\pgf@out@interval@min}{\pgf@out@interval@max}%
\pgfdvmathexitbyserializing{\pgf@temp}{\pgf@out@val}%
\pgfkeyslet{/data point/\pgfoovalueof{out}}\pgf@temp%
\fi\fi%
}%
\def\pgf@dv@mapper@goto@mid{%
% Ok, compute transformed min position:
\pgfooget{out min}{\pgf@out@interval@min}
\pgfooget{out max}{\pgf@out@interval@max}
\pgfdvmathmulfixed{\pgf@out@interval@min}{\pgf@out@interval@min}{.5}
\pgfdvmathmulfixed{\pgf@out@interval@max}{\pgf@out@interval@max}{.5}
\pgfdvmathadd{\pgf@out@val}{\pgf@out@interval@min}{\pgf@out@interval@max}%
\pgfdvmathexitbyserializing{\pgf@temp}{\pgf@out@val}%
\pgfkeyslet{/data point/\pgfoovalueof{out}}\pgf@temp%
}%
}%
%\newif\ifpgf@dvclip
\newif\ifpgf@dvignore
\pgfooclass{scaling mapper}
{%
% Class scaling mapper
%
% A scaling mapper is (mainly) used to scale an attribute in such a way
% that it can be rendered easily on a page. The idea is that you
% specify some attribute and a desired target interval size (like
% [0,5]). The scaling mapper will then survey the data and will setup a
% interval mapper in such a way that the minimum value present in the data is
% mapped to 0 and the maximum to 5. However, it is also possible to,
% say, only have the maximum value mapped to 5 and have 0 be mapped
% to 0. Other, more complicated specifications are also possible.
%
% The scaling mapper internally creates several objects: First, a surveyor
% for determining the minimum and maximum values of the attribute
% and a interval mapper for then mapping the values to the scaled
% values. Additionally, interval objects are needed.
\attribute in;%
% The to-be-scaled attribute;
\attribute out;%
% The attribute storing the scaled value.
\attribute in range obj;%
% This interval keep track of the range of the in attribute
\attribute scaling spec;%
% A specification of how the scaling should be performed.
%
% The format is the following:
%
% #1 at #2 and #3 at #4
%
% Here, #2 and #4 must be numbers. #1 and #3 can either be numbers
% or #1 can be the text "min" and #3 can be the text "max".
%
% The effect of such a specification is the following: The value #1
% is mapped to #2, the value #3 is mapped to #4 and values between
% #1 and #3 (or outside this range) are mapped linearly to a value
% between (or outside) #2 and #4. In case #1 is set to "min", the
% smallest observed value of the in-attribute is mapped to #3 and
% similarly for a value of "max" for #3.
%
% Additionally, as for a interval mapper, a function f might be specified
% that deforms the linear mapping. In case f is specified,
% f(#1) is mapped to #2 and f(#3) is mapped to #4.
\attribute spec maps min;%
% When the scaling spec maps "min" to some value, rather than some
% specific value to that value, then spec maps min will be set to
% \pgfutil@firstoftwo, otherwise to \pgfutil@secondoftwo
\attribute spec maps max;%
% Like spec maps min
\attribute function;%
% Stores the function
\attribute interval mapper;%
% Stores the interval mapper object
\attribute range surveyor;%
% Stores the range surveyor object
% Constructor
%
% #1 = in attribute
% #2 = out attribute
% #3 = scaling specification
% #4 = optional function
%
\method scaling mapper(#1,#2,#3,#4) {
%
% Save the parameters in attributes
%
\pgfooset{in}{#1}
\pgfooset{out}{#2}
\pgfooset{scaling spec}{#3}
\pgfooset{function}{#4}
%
% Now setup the objects for the before survey phase
%
%
% First, the in range interval
\pgfoonew \pgf@dv@in@range@obj=new interval(,)
\pgfoolet{in range obj}\pgf@dv@in@range@obj
% Second, the in range surveyor. We do not need to store this
% object, it will "do its work in the background"
\pgfoonew \pgf@dv@range@obj=new range surveyor(#1,\pgf@dv@in@range@obj)
\pgf@dv@range@obj.default connects()
\pgfoolet{range surveyor}\pgf@dv@range@obj
%
%
% The interval mapper:
%
\pgfoonew{interval mapper}=new interval mapper(#1,#2,#4)
\pgfoovalueof{interval mapper}.default connects()
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,phase,phase signal)
}%
% Getter
%
% Returns an interval object that stores the range of the in
% attribute.
\method get in range interval() {
\pgfooget{in range obj}\pgfdvinrangeinterval
}%
% Getter
%
% Returns the out attribute.
%
\method get out() {
\pgfooget{out}\pgfdvout
}%
% Getter
%
% Returns the function attribute.
%
\method get function(#1) {
\pgfooget{function}#1
}%
% Method
%
% #1 = a included in value
%
% This method only affects the survey. The value #1 is recorded as
% if it were encountered for the in attribute at some point.
%
\method include in value(#1) {
\pgfoovalueof{range surveyor}.include attribute value({#1})
}%
% Method
%
% #1 = value for the attribute
%
% Sets the attribute to the (evaluated) given value (evaluation
% using \pgfmathparse). When the value is evaluated, the values of
% \pgfdvmin and \pgfdvmax will be set to the minimum and maximum
% values of the in interval. (See \pgfdvmathenter with the "!"-notation).
%
% In case #1 is set to the special value "min", it evaluates to
% \pgfdvmin, when set to "max" it evaluates to \pgfdvmax.
%
\method set in to(#1) {%
\edef\pgf@temp{#1}%
\ifx\pgf@temp\pgf@min@text%
\pgf@dv@lib@set@mm%
\let\pgf@dv@value\pgfdvmin%
\pgfoovalueof{spec maps min}{\pgfkeyslet{/data point/\pgfoovalueof{in}/is min or max}\pgf@min@text}{}%
\else%
\ifx\pgf@temp\pgf@max@text%
\pgf@dv@lib@set@mm%
\let\pgf@dv@value\pgfdvmax%
\pgfoovalueof{spec maps min}{\pgfkeyslet{/data point/\pgfoovalueof{in}/is min or max}\pgf@max@text}{}%
\else%
\pgfdvmathenter{\pgf@dv@value}{\pgf@temp}%
\fi%
\fi%
\pgfdvmathexitbyserializing{\pgf@dv@serial}{\pgf@dv@value}%
\pgfkeyslet{/data point/\pgfoovalueof{in}}\pgf@dv@serial%
}%
\def\pgf@dv@lib@set@mm{
\pgfooget{in range obj}\pgfdvinrangeinterval
\pgfdvinrangeinterval.get min and max()%
}%
% Slot
\method phase(#1) {
\ifx#1\pgfdvendsurvey
% Ok, we setup the interval mapper.
%
% We start by computing the interval borders:
\pgfoovalueof{in range obj}.get min and max()
\ifx\pgfdvmin\pgfutil@empty% undefined, since no data points
\else%
\pgfooget{scaling spec}\pgf@temp%
\expandafter\pgf@lib@dv@parse@scaling\pgf@temp\pgf@stop%
\pgfoovalueof{interval mapper}.set interval values(%
\pgf@lib@dv@min,\pgf@lib@dv@max,%
\pgf@lib@dv@min@at,\pgf@lib@dv@max@at)
\fi
\fi
}%
% Internal helper
\def\pgf@lib@dv@parse@scaling#1 at#2and #3 at#4\pgf@stop{%
\def\pgf@lib@dv@min{#1}%
\pgfdvmathenter{\pgf@lib@dv@min@at@mv}{#2}
\def\pgf@lib@dv@max{#3}%
\pgfdvmathenter{\pgf@lib@dv@max@at@mv}{#4}
\ifx\pgf@lib@dv@min\pgf@min@text%
\let\pgf@lib@dv@min@mv\pgfdvmin
\pgfoolet{spec maps min}\pgfutil@firstoftwo%
\else
\pgfdvmathenter{\pgf@lib@dv@min@mv}{\pgf@lib@dv@min}
\pgfoolet{spec maps min}\pgfutil@secondoftwo%
\fi
\ifx\pgf@lib@dv@max\pgf@max@text%
\let\pgf@lib@dv@max@mv\pgfdvmax
\pgfoolet{spec maps max}\pgfutil@firstoftwo%
\else
\pgfdvmathenter{\pgf@lib@dv@max@mv}{\pgf@lib@dv@max}
\pgfoolet{spec maps max}\pgfutil@secondoftwo%
\fi
\pgfdvmathexitbyserializing{\pgf@lib@dv@min}{\pgf@lib@dv@min@mv}
\pgfdvmathexitbyserializing{\pgf@lib@dv@min@at}{\pgf@lib@dv@min@at@mv}
\pgfdvmathexitbyserializing{\pgf@lib@dv@max}{\pgf@lib@dv@max@mv}
\pgfdvmathexitbyserializing{\pgf@lib@dv@max@at}{\pgf@lib@dv@max@at@mv}
}%
\def\pgf@min@text{min}%
\def\pgf@max@text{max}%
}%
%
% Surveyors
%
\pgfooclass{range surveyor}
{%
% Class range surveyor
%
% A range surveyor is used only in the survey phase. Its job is to
% determine the minimum and maximum values of an attribute that are
% "seen" during the survey phase. Based on this value, the size of,
% say, an axis can be determined later on.
%
% You can also set the key "sub attributes" of the attribute. In
% this case, this key should contain -- as the name suggests -- a
% list of subkeys that should also be taken into account for the
% computation of the minimum and maximum value. Inside the "sub
% attributes" key, each subkey should be surrounded by a call of
% \pgfdvsub. For instance, if there are two sub attributes "/data
% point/velocity/min" and "/data point/velocity/max" for a key
% "/data point/velocity", then "/data point/velocity/sub attributes"
% should be set to "\pgfdvsub{/min}\pgfdvsub{/max}".
\attribute attribute;%
% The to-be-surveyed attribute
\attribute interval obj;%
% The interval object that protocols the minimum and maximum
% values.
% Constructor
%
% #1 = the attribute
% #2 = handle to the interval object
%
\method range surveyor(#1,#2) {
\pgfooset{attribute}{#1}
\pgfoolet{interval obj}#2
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,survey,survey datapoint signal)
}%
% Method
%
% #1 = a value
%
% Adjust the interval as if during the survey this value were
% encountered
\method include attribute value(#1) {
\pgf@dv@assign@val@stripped#1\pgf@stop%
\pgfoovalueof{interval obj}.adjust(\pgf@dv@range@surv)
}%
\def\pgf@dv@assign@val@stripped#1\pgf@stop{%
\def\pgf@dv@val{#1}
}%
% Slot
%
% This slot should be connected to the survey datapoint signal. For
% each datapoint, this method will call the adjust method of the
% interval.
%
\method survey() {
\let\pgfdvsub\pgf@dv@range@surv@sub
\pgfdvsub{}%
\pgfkeysvalueof{/data point/\pgfoovalueof{attribute}/sub attributes}
}%
\def\pgf@dv@range@surv@sub#1{
\pgfkeysgetvalue{/data point/\pgfoovalueof{attribute}#1}\pgf@dv@val%
\ifx\pgf@dv@val\relax%
\else%
\edef\pgf@dv@val{\pgf@dv@val}%
\ifx\pgf@dv@val\pgfutil@empty%
\else%
\pgfoovalueof{interval obj}.adjust(\pgf@dv@range@surv)%
\fi%
\fi%
}%
\def\pgf@dv@range@surv{%
\pgfdvmathenter{\pgf@dv@value}{\pgf@dv@val}%
% Now, protocol value
\ifx\pgfdvmin\pgfutil@empty%
\let\pgfdvmin\pgf@dv@value%
\else%
\pgfdvmathifless{\pgf@dv@value}{\pgfdvmin}{\let\pgfdvmin\pgf@dv@value}{}%
\fi%
\ifx\pgfdvmax\pgfutil@empty%
\let\pgfdvmax\pgf@dv@value%
\else%
\pgfdvmathifless{\pgfdvmax}{\pgf@dv@value}{\let\pgfdvmax\pgf@dv@value}{}%
\fi%
}%
}%
%
% Visualizers
%
\usepgflibrary{plothandlers}%
\pgfooclass{plot handler visualizer}
{%
% Class plot handler visualizer
%
% This visualizer uses one or more plot handlers to visualize data points.
% As the data points are processed, the canvas positions of the data
% points are recorded. At the end of a group of data points, the
% recorded stream of canvas position is visualized (rendered)
% using plot handlers. For instance, when the lineto plot handler
% is used, the data points are connected by straight lines, when the
% curveto plot handler is used, they are connected by smooth curves
% and so on.
%
% Since plot lines are not drawn immediately, but only at the end,
% when everything has been collected, multiple plot handlers can
% coexist peacefully at the same time.
%
% You can specify a "filter", which will cause only those data
% points to be visualized by the visualizer that pass the test. The
% filter should set \pgfdvfilterpassedfalse for to-be-filtered data
% point.
%
% You can specify "projection code" that changes the canvas x and
% canvas y positions. This projection code allows you to draw, say,
% projected points instead of the actual data point.
%
% The keys /data point/<name>/execute at begin and /data
% point/<name>/execute at end, where <name> is the name of
% the visualizer, should store code that is to be executed directly
% before and after the stream of coordinates is created. Typically,
% these keys will store commands to use the path created by the plot
% handler.
\attribute handlers;%
% The to-be-used handlers
\attribute name;%
% The attribute
\attribute filter=\pgfdvnamedvisualizerfilter;%
% Filter code
\attribute positions;%
% An internal protocol of the positions on the stream
\attribute cache;%
% An internal cache. Positions are first inserted into this
% cache. Every 100 steps this cache is moved to positions. The idea
% behind this is that it will avoid the quadratic time increase that
% is normally caused when a protocol is build in TeX.
\attribute projection code;%
% This code is empty by default. However, you can set it for
% instance to the following
%
% \pgfkeyssetvalue{/data point/y=0}\pgfdvmapdatapointtocanvas
%
% in order to visualize the data point with its y-coordinate
% replaced by 0.
% Constructor
%
% #1 = A name
% #2 = A comma-separated list of handlers like
% "\pgfplothandlerlineto,\pgfplothandlercurveto"
%
\method plot handler visualizer(#1,#2) {
\pgfooset{name}{#1}
\pgfooset{handlers}{#2}
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,protocol,visualize datapoint signal)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,phase,phase signal)
}%
% Setter
\method set filter(#1) {
\pgfooset{filter}{#1}
}%
% Setter
\method set projection code(#1) {
\pgfooset{projection code}{#1}
}%
% Slot
\method protocol() {
\pgfdvfilterpassedtrue
\pgfoovalueof{filter}
\ifpgfdvfilterpassed%
\pgf@dv@line@cache@it
\fi%
}%
\def\pgf@dv@line@cache@it{
% Cache it
\pgfooget{cache}\pgf@dv@cache
\pgfkeysgetvalue{/data point/outlier}\pgf@temp%
\ifx\pgf@temp\pgfutil@empty
{%
\pgfoovalueof{projection code}
\xdef\pgf@dv@add{\noexpand\pgf@dv@ph{\pgfkeysvalueof{/data
point/canvas x}}{\pgfkeysvalueof{/data point/canvas y}}}%
}
\else%
% An outlier!
\gdef\pgf@dv@add{\pgf@dv@outliner}%
\fi%
\expandafter\expandafter\expandafter\def%
\expandafter\expandafter\expandafter\pgf@dv@cache%
\expandafter\expandafter\expandafter{\expandafter\pgf@dv@cache\pgf@dv@add}%
% Possibly flush cache
\global\advance\pgf@lib@dv@cache@count by1\relax%
\ifnum\pgf@lib@dv@cache@count=100\relax%
\global\pgf@lib@dv@cache@count=0\relax%
% Append cache to positions
\pgfooget{positions}\pgf@dv@temp
\expandafter\expandafter\expandafter\def%
\expandafter\expandafter\expandafter\pgf@dv@temp%
\expandafter\expandafter\expandafter{\expandafter\pgf@dv@temp\pgf@dv@cache}%
\pgfoolet{positions}\pgf@dv@temp
\let\pgf@dv@cache\pgfutil@empty
\fi
\pgfoolet{cache}\pgf@dv@cache
}%
% Slot
\method phase(#1) {%
\ifx#1\pgfdvendvisualization%
\pgfoothis.render()%
\fi%
}%
% Internal method
\method render() {
\pgfscope
\pgfooget{handlers}\tikz@dv@temp@list
\foreach\tikz@dv@temp in\tikz@dv@temp@list{
\ifx\tikz@dv@temp\pgfutil@empty
\else
\pgfkeysvalueof{/data point/\pgfoovalueof{name}/execute at begin}
\tikz@dv@temp
\pgfdvnewstreamtrue
\pgfoovalueof{positions}
\pgfoovalueof{cache}
\ifpgfdvnewstream\else\pgfplotstreamend\fi
\pgfkeysvalueof{/data point/\pgfoovalueof{name}/execute at end}
\fi
}
\endpgfscope
\pgfoolet{positions}\pgfutil@empty
\pgfoolet{cache}\pgfutil@empty
}%
\def\pgf@dv@ph#1#2{\ifpgfdvnewstream\pgfplotstreamstart\pgfdvnewstreamfalse\fi\pgfplotstreampoint{\pgfqpoint{#1}{#2}}}%
\def\pgf@dv@outliner{\ifpgfdvnewstream\else\pgfplotstreamend\pgfdvnewstreamtrue\fi}%
}%
\newif\ifpgfdvnewstream
\newcount\pgf@lib@dv@cache@count
\pgfkeys{%
/data point/outlier/.initial=,
/data point/outlier/.default=true,
}%
% A possible filter for unnamed visualizers
%
% #1 = Text to be compared with key /data point/set
%
% Description:
%
% In a data visualization with multiple visualizers, data points
% typically "belong" only to a single visualizer. It is, thus,
% necessary to filter data points according to the current
% visualizer. This current visualizer is assumed to be stored in /data
% point/visualizer.
%
% When objects allow you to set a filter, you can use this filter to
% test against /data point/set being equal to #1.
\def\pgfdvvisualizerfilter#1{%
\pgfkeysgetvalue{/data point/set}\pgf@dv@visualizer%
\def\pgf@temp{#1}%
\ifx\pgf@temp\pgf@dv@visualizer%
\else
\pgfdvfilterpassedfalse
\fi%
}%
% A filter for named visualizer
%
% Description:
%
% This filter works like \pgfdvvisualizerfilter, only it assumes the
% the object defines a "name" attribute. In this case, the value of
% /data point/set is tested against this attribute.
\def\pgfdvnamedvisualizerfilter{%
\pgfkeysgetvalue{/data point/set}\pgf@dv@visualizer%
\pgfooget{name}\pgf@temp%
\ifx\pgf@temp\pgf@dv@visualizer%
\else
\pgfdvfilterpassedfalse
\fi%
}%
\pgfooclass{rectangle visualizer}
{%
% Class rectangle visualizer
%
% This visualizer visualizes a datapoint as a rectangle. It needs
% a name, so that /data point/<name>/attribute 1 and /data
% point/<name>/attribute 2 store two attributes names a1 to a2. Then,
% provided the current value of /data point/set equals name, for
% each data point a rectangle between (a1/min,a2/min) and
% (a1/max,a2/max) is created.
\attribute name;%
% The name
\attribute a1;%
\attribute a2;%
% The attributes, filled from /data point/<name>/attribute 1 and 2
% Constructor
%
% #1 = first attribute
% #2 = second attribute
%
\method rectangle visualizer(#1) {
\pgfooset{name}{#1}
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,visualize,visualize datapoint signal)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,phase,phase signal)
}%
% Slot
\method phase(#1) {%
\ifx#1\pgfdvbeginsurvey%
\pgfooeset{a1}{/data point/\pgfkeysvalueof{/data point/\pgfoovalueof{name}/attribute 1}}
\pgfooeset{a2}{/data point/\pgfkeysvalueof{/data point/\pgfoovalueof{name}/attribute 2}}
\pgfkeyssetvalue{\pgfoovalueof{a1}/sub attributes}{\pgfdvsub{/min}\pgfdvsub{/max}}
\pgfkeyssetvalue{\pgfoovalueof{a2}/sub attributes}{\pgfdvsub{/min}\pgfdvsub{/max}}
\fi%
}%
% Slot
\method visualize() {
{
\pgfkeysgetvalue{/data point/set}\pgf@dv@visualizer%
\pgfooget{name}\pgf@temp%
\ifx\pgf@temp\pgf@dv@visualizer%
\pgf@dv@rect@do
\fi
}
}%
\def\pgf@dv@rect@do{
\pgfkeysgetvalue{\pgfoovalueof{a1}/min}\pgf@dv@amin
\ifx\pgf@dv@amin\relax\else\ifx\pgf@dv@amin\pgfutil@empty\else
\pgfkeysgetvalue{\pgfoovalueof{a1}/max}\pgf@dv@amax
\ifx\pgf@dv@amax\relax\else\ifx\pgf@dv@amax\pgfutil@empty\else
\pgfkeysgetvalue{\pgfoovalueof{a2}/min}\pgf@dv@bmin
\ifx\pgf@dv@bmin\relax\else\ifx\pgf@dv@bmin\pgfutil@empty\else
\pgfkeysgetvalue{\pgfoovalueof{a2}/max}\pgf@dv@bmax
\ifx\pgf@dv@bmax\relax\else\ifx\pgf@dv@bmax\pgfutil@empty\else
\pgfkeysvalueof{/data point/\pgfoovalueof{name}/execute at begin}
\pgfkeyssetvalue{\pgfoovalueof{a1}}{\pgf@dv@amin}
\pgfkeyssetvalue{\pgfoovalueof{a2}}{\pgf@dv@bmin}
\pgfpathdvmoveto
\pgfkeyssetvalue{\pgfoovalueof{a2}}{\pgf@dv@bmax}
\pgfpathdvlineto
\pgfkeyssetvalue{\pgfoovalueof{a1}}{\pgf@dv@amax}
\pgfpathdvlineto
\pgfkeyssetvalue{\pgfoovalueof{a2}}{\pgf@dv@bmin}
\pgfpathdvlineto
\pgfkeyssetvalue{\pgfoovalueof{a1}}{\pgf@dv@amin}
\pgfpathdvlineto
\pgfpathclose
\pgfkeysvalueof{/data point/\pgfoovalueof{name}/execute at end}
\fi\fi
\fi\fi
\fi\fi
\fi\fi
}%
}%
\newcount\pgf@lib@dv@cache@count
%
% Label positioning classes
%
\pgfooclass{label visualizer}
{%
% Class label visualizer
%
% The job of this class is to visualize a label of a curve or some
% other object.
%
% The idea is as follows: This class monitors a certain
% attribute. When this attribute reaches a certain value for the
% first time, the following happens: A normalized vector of the line
% connecting the current canvas position to the canvas position of
% the previous data point is computed and stored in pgf@x/pgf@y. The
% coordinate system is shifted so that the current data point is at
% the origin. Then, some drawing code is executed.
\attribute attribute;%
% The monitored attribute
\attribute filter;%
% Filter code, see plot handler visualizer doc.
\attribute threshold;%
% When the attribute exceeds this threshold, the drawing code is
% executed
\attribute before canvas position=;%
% Stores canvas position of the data point before the interesting one
\attribute canvas position=;%
% Stores canvas position of the data point
\attribute code;%
% To-be-executed code when the label should be drawn
% Constructor
%
% #1 = attribute
% #2 = a macro, storing the threshold
% #3 = code
% #4 = filter code
%
\method label visualizer(#1,#2,#3,#4) {
\pgfooset{attribute}{#1}
\expandafter\pgfdvmathenter\expandafter{\expandafter\pgf@temp\expandafter}\expandafter{#2}
\pgfoolet{threshold}\pgf@temp
\pgfooset{code}{#3}
\pgfooset{filter}{#4}
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,test,visualize datapoint signal)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,phase,phase signal)
}%
% Slot
\method test() {
\pgfdvfilterpassedtrue
\pgfoovalueof{filter}
\ifpgfdvfilterpassed%
\pgfooget{attribute}\pgf@dv@attribute
\ifx\pgf@dv@attribute\pgfutil@empty%
% nothing to do (anymore)
\else%
\pgf@dv@label@vis@record
\fi%
\fi%
}%
\def\pgf@dv@label@vis@record{
% Record current position
\edef\pgf@dv@pos{%
\noexpand\pgfqpoint%
{\pgfkeysvalueof{/data point/canvas x}}%
{\pgfkeysvalueof{/data point/canvas y}}}%
\pgfooget{canvas position}\pgf@dv@temp%
\pgfoolet{before canvas position}\pgf@dv@temp%
\pgfoolet{canvas position}\pgf@dv@pos%
% Now check threshold
\pgfooget{threshold}\pgf@dv@thres%
\ifx\pgf@dv@thres\pgfutil@empty%
\else%
% Hmm, have to check, whether the value is, indeed, correct
\pgfkeysgetvalue{/data point/\pgfoovalueof{attribute}}\pgf@dv@val
\ifx\pgf@dv@val\relax%
\else\ifx\pgf@dv@val\pgfutil@empty%
\else%
\pgfdvmathenter{\pgf@dv@value}{\pgf@dv@val}%
\pgfooget{threshold}{\pgf@dv@thres}
% Now, protocol value
\pgfdvmathifless{\pgf@dv@value}{\pgf@dv@thres}{}{%
\pgfoolet{attribute}\pgfutil@empty% Stop!
}%
\fi\fi%
\fi%
}%
% Slot
\method phase(#1) {%
\ifx#1\pgfdvendvisualization%
\scope
\pgfcoordinate{label visualizer coordinate}{\pgfoovalueof{canvas position}}
\pgfcoordinate{label visualizer coordinate'}{\pgfoovalueof{before canvas position}}
\pgfoovalueof{code}
\endscope
\fi%
}%
}%
%
% Style sheets
%
\pgfooclass{style attribute}
{%
% Class style attribute
%
% Instances of this class are used to select a style based on the
% current value of an attribute.
%
% Instances of this class monitor an attribute. Whenever the "style"
% signal is raised, the object investigates the current value of the
% attribute. It then looks up /pgf/data visualization/style
% sheets/<name of style sheet>/<value of the attribute> and executes
% this key, provided it is defined. If it not defined, the key
% /pgf/data visualization/style sheets/<name of style sheet>/default
% style is executed with the value as a parameter.
\attribute attribute;%
% The name of the attribute
\attribute style sheet name;%
% The styling function
% Constructor
%
% #1 = attribute (including, if present, /data point/)
% #2 = style sheet name
%
\method style attribute(#1,#2) {
\pgfooset{attribute}{#1}
\pgfooset{style sheet name}{#2}
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,invoke style,style signal)
}%
% Slots
\method invoke style() {
\pgfooget{attribute}\pgf@dv@temp
\pgfkeysgetvalue{\pgf@dv@temp}\pgf@dv@temp@val
\ifx\pgf@dv@temp@val\pgfutil@empty%do nothing
\else\ifx\pgf@dv@temp@val\relax%do nothing
\else%
\pgfkeysifdefined{\pgf@dv@temp/\pgf@dv@temp@val}{\pgfkeysgetvalue{\pgf@dv@temp/\pgf@dv@temp@val}\pgf@dv@temp@val}{}% redirect
\edef\pgf@temp{/pgf/data visualization/style sheets/\pgfoovalueof{style sheet name}}
\pgfkeysifassignable{\pgf@temp/\pgf@dv@temp@val}{%
\pgfkeysalso{\pgf@temp/\pgf@dv@temp@val}}{%
\pgfkeysalso{\pgf@temp/default style/.expand once=\pgf@dv@temp@val}
}
\fi\fi%
}%
}%
% Declares a new style sheet
%
% #1 = name of style sheet
% #2 = settings
%
% Description:
%
% This is a shortcut for doing a /.cd to /pgf/data visualization/style sheets/#1
\def\pgfdvdeclarestylesheet#1#2{
\pgfkeys{/pgf/data visualization/style sheets/#1/.cd,#2}
}%
%
% Legend container class
%
\pgfooclass{legend}
{%
% Class legend
%
% This class is used to collect entries into a legend. The idea is
% that, say, for each line of a picture you would like to have an
% entry in a legend. Then you prepare these entries and send
% them to a legend container object. It will collect the entries
% and, at the end, arrange them in rows and columns by
% separating them using \pgfdvnextcell and \pgfdvendrow.
%
% By surrounding the resulting arrangement by a call to \pgfmatrix or
% a call to \halign you can then create a legend.
%
% To specify how the entries should be arranged, a size
% specification and two directions are needed.
%
% For the size specification you specify either the ideal number of
% columns and the maximum number of rows or you specify the ideal
% number of rows and the maximum number of columns. In the first
% case, the class first tries to create as many columns as specified
% by the "ideal" parameter. If there are less entries than this
% parameter, you obviously get less columns, namely as many as there
% are entries, each column containing only one entry. If there are
% more entries that the ideal number of columns, you get multiple
% columns, each containing as many entries to make sure that the
% ideal number is met. However, if a column would get more than the
% specified maximum number of elements per column, you get more
% columns that the ideal number -- to ensure that no column contains
% more than the desired number. The case is symmetric, but with the
% roles of columns and rows exchanged.
%
% Here is an example: You specify that you want 2 columns, ideally,
% each having a maximum of 4 entries. Here is what you would get:
%
% Number of entries & Number of resulting columns ... & ... and rows
% 1 & 1 & 1
% 2 & 2 & 1
% 3 & 2 & 2
% 4 & 2 & 2
% 5 & 2 & 3
% 6 & 2 & 3
% 7 & 2 & 4
% 8 & 2 & 4
% 9 & 3 & 4
% 10 & 3 & 4
% 11 & 3 & 4
% 12 & 3 & 4
% 13 & 4 & 4
%
%
% Once the number of columns and rows has been computed, the next
% step is to "fill" the table. For this, eight strategies may be
% specified: right then down, right then up, left then down, left
% then up, up then right, up then left, down then right, down then
% left. A strategy like "right then up" means the following: Each
% new entry should placed right of the previous entry in the
% arrangement. However, once the maximum number of elements in a row
% has been reached, the a new row should be started that is placed
% above ("up") then just-assembled row.
%
%
%
%
% Example:
%
% You create an object \legend and then call
%
% \pgfoofnew \legend=new legend(columns,2,3,down then right)
% \legend.add entry(first)
% \legend.add entry(second)
% \legend.add entry(third)
% \legend.add entry(fourth)
% \legend.add entry(fifth)
% \legend.add entry(sixth)
% \legend.add entry(seventh)
% \legend.get arrangement(\arrangement)
%
% Then \arrangment will expand to
%
% first \pgfdvnextcell fourth \pgfdvnextcell seventh \pgfdvendrow
% second \pgfdvnextcell fifth \pgfdvnextcell third \pgfdvendrow
% third \pgfdvendrow sixth \pgfdvnextcell \pgfdvendrow
%
% By saying \let\pgfdvendrow=\\ and \let\pgfdvnextcell=&, you
% can use \arrangment inside a table.
\attribute entries;%
% Collects the entries
\attribute columns or rows;%
% Specifies whether columns or rows are specified
\attribute ideal;%
% The ideal number of columns/rows
\attribute max;%
% The maximum number of entries per column/row
\attribute strategy;%
% Specifies how the matrix should be filled
\attribute number of entries=0;%
% Counts the number of entries that have been stored
% Constructor
%
% #1 = "columns" or "rows" -> specifies whether the ideal number and
% the max entries number refer to columns or the row
% #2 = the ideal number of #1's
% #3 = the maximum number of entries in a #1
% #4 = one of the eight strategies
%
\method legend(#1,#2,#3,#4) {
\pgfooset{columns or rows}{#1}
\pgfooset{ideal}{#2}
\pgfooset{max}{#3}
\pgfooset{strategy}{#4}
}%
% Method
\method default connects() {
}%
% Method
\method add entry(#1) {
\pgfooappend{entries}{{#1}}
\c@pgf@counta=\pgfoovalueof{number of entries}\relax%
\advance\c@pgf@counta by1\relax%
\pgfooeset{number of entries}{\the\c@pgf@counta}
}%
% Method
\method get arrangement(#1) {
{
%
% Step 1: Compute the desired number of rows or columns
%
%
% Compute the ideal number of entries per row/column (called
% "target" in the following) and entries per colum/row (called
% "per target" in the following)
%
% if (number of entries > ideal)
\ifnum\pgfoovalueof{number of entries}>\pgfoovalueof{ideal}\relax%
% {
% if (ideal * max > number of entries)
\c@pgf@counta=\pgfoovalueof{ideal}\relax%
\multiply\c@pgf@counta by\pgfoovalueof{max}\relax%
\ifnum\c@pgf@counta>\pgfoovalueof{number of entries}\relax
% {
% target = ideal;
% per target = ceil (number of entries / ideal);
\c@pgf@counta=\pgfoovalueof{ideal}\relax%
\c@pgf@countb=\pgfoovalueof{number of entries}\relax
\advance\c@pgf@countb by-1\relax
\divide\c@pgf@countb by\c@pgf@counta\relax%
\advance\c@pgf@countb by1\relax%
% }
% else
% {
% target = ceil(number of entries / max);
% per target = max;
\else
\c@pgf@countb=\pgfoovalueof{max}\relax%
\c@pgf@counta=\pgfoovalueof{number of entries}\relax
\advance\c@pgf@counta by-1\relax
\divide\c@pgf@counta by\c@pgf@countb\relax%
\advance\c@pgf@counta by1\relax%
\fi
% }
% }
% else
% {
% target = number of entries;
% per target = 1;
% }
\else
\c@pgf@counta=\pgfoovalueof{number of entries}\relax%
\c@pgf@countb=1\relax%
\fi%
%
% Ensure that counta = rows, countb = columns
%
\pgfooget{columns or rows}\pgf@temp
\ifx\pgf@temp\pgf@dv@columnstext%
\c@pgf@countc=\c@pgf@counta\relax
\c@pgf@counta=\c@pgf@countb\relax
\c@pgf@countb=\c@pgf@countc\relax
\fi
%\edef\temp{rows: \the\c@pgf@counta, columns: \the\c@pgf@countb}\temp
%
% Now arrange the matrix
%
\csname pgf@dv@legend@init@\pgfoovalueof{strategy}\endcsname
\expandafter\let\expandafter\pgf@dv@updater\csname pgf@dv@legend@update@\pgfoovalueof{strategy}\endcsname
\pgfooget{entries}\pgf@temp
\expandafter\pgf@dv@legend@arrange\pgf@temp\pgf@stop
%
% Now assemble the matrix
%
\edef\pgf@dv@row@list{1,...,\the\c@pgf@counta}
\edef\pgf@dv@column@list{1,...,\the\c@pgf@countb}
\global\let\pgf@dv@matrix\pgfutil@empty
\foreach \pgf@dv@row in \pgf@dv@row@list
{
\global\let\pgf@dv@matrix@row\pgf@dv@first@mark
\foreach \pgf@dv@column in \pgf@dv@column@list
{
\expandafter\let\expandafter\pgf@temp\csname pgf@dv@legend@entry@\pgf@dv@row @\pgf@dv@column\endcsname
\ifx\pgf@temp\relax
\let\pgf@temp\pgfutil@empty
\fi
\ifx\pgf@dv@matrix@row\pgf@dv@first@mark
\global\let\pgf@dv@matrix@row\pgf@temp
\else
\expandafter\pgfutil@g@addto@macro\expandafter\pgf@dv@matrix@row\expandafter{\expandafter\pgfdvnextcell\pgf@temp}
\fi
}
\pgfutil@g@addto@macro\pgf@dv@matrix@row{\pgfdvendrow}
\expandafter\pgfutil@g@addto@macro\expandafter\pgf@dv@matrix\expandafter{\pgf@dv@matrix@row}
}
\global\let\pgf@dv@matrix@row\relax
}
\let#1\pgf@dv@matrix
\global\let\pgf@dv@matrix\relax
}%
\def\pgf@dv@first@mark{\pgf@dv@first@mark}%
\def\pgf@dv@legend@arrange{%
\pgfutil@ifnextchar\pgf@stop{\pgfutil@gobble}{\pgf@dv@legend@handle@entry}
}%
\def\pgf@dv@legend@handle@entry#1{
\expandafter\def\csname pgf@dv@legend@entry@\the\c@pgf@countc @\the\c@pgf@countd\endcsname{#1}%
\pgf@dv@updater%
\pgf@dv@legend@arrange%
}%
\expandafter\def\csname pgf@dv@legend@init@down then right\endcsname{%
\c@pgf@countc=1\relax%
\c@pgf@countd=1\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@down then right\endcsname{%
\advance\c@pgf@countc by1\relax
\ifnum\c@pgf@countc>\c@pgf@counta\relax%
\c@pgf@countc=1\relax%
\advance\c@pgf@countd by1\relax%
\fi%
}%
\expandafter\def\csname pgf@dv@legend@init@right then down\endcsname{%
\c@pgf@countc=1\relax%
\c@pgf@countd=1\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@right then down\endcsname{%
\advance\c@pgf@countd by1\relax
\ifnum\c@pgf@countd>\c@pgf@countb\relax%
\c@pgf@countd=1\relax%
\advance\c@pgf@countc by1\relax%
\fi%
}%
\expandafter\def\csname pgf@dv@legend@init@up then right\endcsname{%
\c@pgf@countc=\c@pgf@counta\relax%
\c@pgf@countd=1\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@up then right\endcsname{%
\advance\c@pgf@countc by-1\relax
\ifnum\c@pgf@countc=0\relax%
\c@pgf@countc=\c@pgf@counta\relax%
\advance\c@pgf@countd by1\relax%
\fi%
}%
\expandafter\def\csname pgf@dv@legend@init@right then up\endcsname{%
\c@pgf@countc=\c@pgf@counta\relax%
\c@pgf@countd=1\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@right then up\endcsname{%
\advance\c@pgf@countd by1\relax
\ifnum\c@pgf@countd>\c@pgf@countb\relax%
\c@pgf@countd=1\relax%
\advance\c@pgf@countc by-1\relax%
\fi%
}%
\expandafter\def\csname pgf@dv@legend@init@left then up\endcsname{%
\c@pgf@countc=\c@pgf@counta\relax%
\c@pgf@countd=\c@pgf@countb\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@left then up\endcsname{%
\advance\c@pgf@countd by-1\relax
\ifnum\c@pgf@countd=0\relax%
\c@pgf@countd=\c@pgf@countb\relax%
\advance\c@pgf@countc by-1\relax%
\fi%
}%
\expandafter\def\csname pgf@dv@legend@init@up then left\endcsname{%
\c@pgf@countc=\c@pgf@counta\relax%
\c@pgf@countd=\c@pgf@countb\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@up then left\endcsname{%
\advance\c@pgf@countc by-1\relax
\ifnum\c@pgf@countc=0\relax%
\c@pgf@countc=\c@pgf@counta\relax%
\advance\c@pgf@countd by-1\relax%
\fi%
}%
\expandafter\def\csname pgf@dv@legend@init@left then down\endcsname{%
\c@pgf@countc=1\relax%
\c@pgf@countd=\c@pgf@countb\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@left then down\endcsname{%
\advance\c@pgf@countd by-1\relax
\ifnum\c@pgf@countd=0\relax%
\c@pgf@countd=\c@pgf@countb\relax%
\advance\c@pgf@countc by1\relax%
\fi%
}%
\expandafter\def\csname pgf@dv@legend@init@down then left\endcsname{%
\c@pgf@countc=1\relax%
\c@pgf@countd=\c@pgf@countb\relax%
}%
\expandafter\def\csname pgf@dv@legend@update@down then left\endcsname{%
\advance\c@pgf@countc by1\relax
\ifnum\c@pgf@countc>\c@pgf@countb\relax%
\c@pgf@countc=1\relax%
\advance\c@pgf@countd by-1\relax%
\fi%
}%
\def\pgf@dv@columnstext{columns}%
}%
%
% Help classes
%
\pgfooclass{interval}
{%
% Class interval
%
% Instances of this class store intervals. When either the min or
% the max value is empty, this corresponds to "not yet set", (not to
% "infinity).
\attribute min;%
% The minimum value of the interval
\attribute max;%
% The maximum value of the interval
% Constructor
%
% #1 = initial minimum value
% #2 = initial maximum value
%
\method interval(#1,#2) {
\pgfooset{min}{#1}
\pgfooset{max}{#2}
}%
% Method
\method default connects() {
}%
% Sets the minimum/maximum to a new value
\method set min(#1) {
\pgfooset{min}{#1}
}%
\method set max(#1) {
\pgfooset{max}{#1}
}%
\method let min(#1) {
\pgfoolet{min}{#1}
}%
\method let max(#1) {
\pgfoolet{max}{#1}
}%
% Getter
%
% Returns the current values of the minimum and maximum in the
% macros \pgfdvmin and \pgfdvmax.
\method get min and max() {
\pgfooget{min}\pgfdvmin
\pgfooget{max}\pgfdvmax
}%
% Adjusts the minimum and maximum values
%
% #1 = some code. When this code is executed, the values of
% \pgfdvmin and \pgfdvmax will be set to the current values of
% the minimum/maximum. The code may change these values. The
% changed values will then be stored.
%
% This method does nothing that cannot be achieved also by calling
% set/get methods, but it is easier to use and faster.
\method adjust(#1) {
{%
\pgfooget{min}\pgfdvmin
\pgfooget{max}\pgfdvmax
#1%
\pgfoolet{min}\pgfdvmin
\pgfoolet{max}\pgfdvmax
}%
}%
}%
\pgfooclass{count}
{%
% Class count
%
% This class can be used to count the number of data points that are
% present or that have a certain property. By default, for every
% data point a counter is incremented and the value of this counter
% is stored in an attribute. You can also specify an increment for
% the counter. You can specify that certain data points should
% not have an effect on the counter.
\attribute attribute;%
% The attribute that will be set to the current value of the counter
\attribute val=0;%
% The current value of the counter
\attribute max=0;%
% The current value of the counter
\attribute step=1;%
% The stepping by which the counter is incremented for each
% datapoint
\attribute start val=0;%
% The start value of the counter
\attribute filter=;%
% This attribute stores some code that is executed for each
% data point. If the data point sets the TeX-if ifpgfdvfilterpassed to
% true, then the counter is not incremented.
% Constructor
%
% #1 = The attribute in which the counter value is stored
%
\method count(#1) {
\pgfooset{attribute}{#1}
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,apply,prepare datapoint signal)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,phase,phase signal)
}%
% Getter
\method get max(#1) {
\pgfooget{max}{#1}
}%
% Setter
\method set value(#1) {
\pgfooset{val}{#1}
\pgfkeyssetvalue{/data point/\pgfoovalueof{attribute}}{#1}%
}%
% Setter
\method set start value(#1) {
\pgfooset{start val}{#1}
\pgfooset{max}{#1}
}%
% Setter
\method set filter(#1) {
\pgfooset{filter}{#1}
}%
% Setter
\method set step(#1) {
\pgfooset{step}{#1}
}%
% Slot
\method apply() {
\pgfdvfilterpassedtrue%
\pgfoovalueof{filter}%
\ifpgfdvfilterpassed%
\pgfmathparse{\pgfoovalueof{val}+\pgfoovalueof{step}}%
\pgfoolet{val}\pgfmathresult%
\pgfkeyslet{/data point/\pgfoovalueof{attribute}}\pgfmathresult%
\ifdim\pgfmathresult pt>\pgfoovalueof{max}pt\relax%
\pgfoolet{max}\pgfmathresult%
\fi%
\pgfooget{max}\pgfmathresult%
\pgfkeyslet{/data point/\pgfoovalueof{attribute}/max}\pgfmathresult%
\fi%
}%
% Slot
\method phase(#1) {
\ifx#1\pgfdvbeginsurvey
\pgfooeset{val}{\pgfoovalueof{start val}}
\else \ifx#1\pgfdvbeginvisualization
\pgfooeset{val}{\pgfoovalueof{start val}}
\fi\fi
}%
}%
\newif\ifpgfdvfilterpassed
\pgfooclass{accumulator}
{%
% Class accumulator
%
% This class is used to keep track of the sum of the values of some
% attribute. When this object is connected to some attribute, the
% subkey attribute/sum will always contain the sum of all values in
% all previous data points with respect to this
% attribute. Furthermore, the subkey attribute/prev key will hold
% the previous sum, which is sometimes also useful to have access
% to.
\attribute attribute;%
% The attribute to-be-accumulated
\attribute sum;%
% The initial value of the sum
% Constructor
%
% #1 = to-be-accumulated attribute
\method accumulator(#1) {
\pgfooset{attribute}{#1}
\pgfoothis.reset()
}%
% Method
\method default connects() {
\pgfoothis.get handle(\pgf@dv@me)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,apply,prepare datapoint signal)
\pgfkeysvalueof{/pgf/data visualization/obj}.connect(\pgf@dv@me,phase,phase signal)
}%
% Slot
\method apply() {%
% Save old sum
\pgfkeysgetvalue{/data point/\pgfoovalueof{attribute}/sum}\pgf@temp%
\pgfkeyslet{/data point/\pgfoovalueof{attribute}/prev sum}\pgf@temp%
% Add new attribute...
\pgfkeysgetvalue{/data point/\pgfoovalueof{attribute}}{\pgf@temp@b}%
\pgfdvmathenter{\pgf@dv@new@val}{\pgf@temp@b}%
% ... to sum
\pgfooget{sum}\pgf@dv@sum%
\pgfdvmathadd{\pgf@dv@sum}{\pgf@dv@new@val}{\pgf@dv@sum}%
\pgfoolet{sum}\pgf@dv@sum
% Record in attribute
\pgfdvmathexitbyscientificformat{\pgf@dv@serial@sum}{\pgf@dv@sum}
\pgfkeyslet{/data point/\pgfoovalueof{attribute}/sum}\pgf@dv@serial@sum
}%
% Method
%
% Use this method to reset the sum at any point.
%
\method reset() {
\pgfdvmathenter{\pgf@dv@temp}{0}
\pgfoolet{sum}{\pgf@dv@temp}
\pgfdvmathexitbyserializing{\pgf@dv@zero}{\pgf@dv@temp}
\pgfkeyslet{/data point/\pgfoovalueof{attribute}/prev sum}{\pgf@dv@zero}
\pgfkeyslet{/data point/\pgfoovalueof{attribute}/sum}{\pgf@dv@zero}
}%
% Slot
\method phase(#1) {
\ifx#1\pgfdvbeginsurvey
\pgfoothis.reset()
\else \ifx#1\pgfdvbeginvisualization
\pgfoothis.reset()
\fi\fi
}%
}%
%
%
% Help keys and, attributes
%
%
\pgfkeys{% do not even think of changing the values of the following:
/data point/always true/.initial=true,
/data point/always false/.initial=false,
/data point/always 0/.initial=0,
/data point/always 1/.initial=1,
/data point/always empty/.initial=,
/data point/always pgfusepath stroke/.initial=\pgfusepath{stroke},
}%
\pgfdvmathenter{\pgfdvmathalwaysloge}{0.434294481903252}%
\pgfdvmathenter{\pgfdvmathalwayslnten}{2.302585092994046}%
\pgfdvmathenter{\pgfdvmathalwayszero}{0}%
\pgfdvmathenter{\pgfdvmathalwaysone}{1}%
\endinput