@lofcz/tikz 0.0.0-stage → 0.1.0

package/runtime/dist/bundles/latex-extra/files/tex/generic/pgfplots/pgfcontrib/pgflibraryfillbetween.code.tex

@@ -0,0 +1,1265 @@
+% Copyright 2013 by Christian Feuersaenger
+%
+% This file may be distributed and/or modified
+%
+% 1. under the LaTeX Project Public License and/or
+% 2. under the GNU Free Documentation License.
+%
+% See the file doc/generic/pgf/licenses/LICENSE for more details.
+
+
+\usepgflibrary{intersections}
+
+\pgfutil@IfUndefined{pgf@intersections@version}{%
+	\input pgfplotsoldpgfsupp_pgflibraryintersections.code.tex
+}{%
+}%
+
+% FIXME : ARCHITECTURE VIOLATION:  REQUIRES
+% \usetikzlibrary{decorations.softclip}
+%
+%\usepgfmodule{decorations}
+
+\newif\ifpgfpathfillbetween@split
+
+\pgfkeys{%
+	/pgf/fill between/reverse/.is choice,
+	/pgf/fill between/reverse/.default=true,
+	/pgf/fill between/reverse/false/.code=\def\pgfpathfillbetween@reverse@mode{0},%
+	/pgf/fill between/reverse/true/.code=\def\pgfpathfillbetween@reverse@mode{1},%
+	%
+	% checks the coordinates of the first two path instructions as heuristics:
+	/pgf/fill between/reverse/auto/.code=\def\pgfpathfillbetween@reverse@mode{2},%
+	/pgf/fill between/reverse/auto,
+	/pgf/fill between/inner moveto/.is choice,
+	/pgf/fill between/inner moveto/connect/.code=\def\pgfpathfillbetween@inner@moveto{1},
+	/pgf/fill between/inner moveto/keep/.code=\def\pgfpathfillbetween@inner@moveto{2},
+	/pgf/fill between/inner moveto/connect,
+	%
+	% split=true allows to generate individual result paths for every
+	% region induced by the intersection points. Example:
+	% "color positive region in red and negative region in green".
+	% The case split=false results in just one output path
+	% (simpler+faster, but of course less powerful).
+	/pgf/fill between/split/.is if=pgfpathfillbetween@split,
+	/pgf/fill between/split/.default=true,
+	%
+	% Used to report results. This is mainly useful in conjunction
+	% with split=true: each result segment will be streamed.
+	%
+	% Results are reported in the sequence
+	%   begin
+	%     next ready
+	%     next ready
+	%     ...
+	%   end
+	%
+	% 'begin' has one arguments: the number of following single
+	% streams.
+	/pgf/fill between/result stream/begin/.code=,%
+	%
+	% 'next ready' has macro arguments, but the macro \pgfretval
+	% contains the lowlevel path as result (i.e. you can write
+	% \pgfsetpath\pgfretval to activate it).
+	/pgf/fill between/result stream/next ready/.code={
+		\pgfaddpathandBB{\pgfretval}%
+	},%
+	%
+	% 'end' has no arguments.
+	/pgf/fill between/result stream/end/.code=,%
+	%
+	/pgf/fill between/omit empty segments/.is choice,
+	/pgf/fill between/omit empty segments/.default=true,
+	/pgf/fill between/omit empty segments/false/.code=\def\pgfpathfillbetween@omit@empty@segments{0},%
+	/pgf/fill between/omit empty segments/true/.code=\def\pgfpathfillbetween@omit@empty@segments{1},%
+	/pgf/fill between/omit empty segments/true,
+}%
+
+% \pgfpathfillbetween[<options>]{<first path>}{<second path>}
+%
+% Generates a new path consisting of the "fill between" of the two arguments.
+% #1: optional arguments with /pgf/fill between prefix
+% #2: a macro containing the first path. More precisely, it is supposed to be a return value of \pgfgetpath.
+% #3: a macro containing the second path (in a format understood by \pgfsetpath). It is supposed to be a return value of \pgfgetpath.
+\def\pgfpathfillbetween{\pgfutil@ifnextchar[{\pgfpathfillbetween@opt}{\pgfpathfillbetween@opt[]}}%
+\def\pgfpathfillbetween@opt[#1]#2#3{%
+	\begingroup
+	\pgfqkeys{/pgf/fill between}{#1}%
+	%
+	% remove any special round-corner-tokens:
+	\pgfprocessround{#2}{#2}%
+	\pgfprocessround{#3}{#3}%
+	%
+	\if1\pgfpathfillbetween@inner@moveto
+		% inner moveto=connect:
+		\pgfpathfillbetween@connect@inner@movetos#2%
+		\pgfpathfillbetween@connect@inner@movetos#3%
+	\fi
+	%
+	\if2\pgfpathfillbetween@reverse@mode
+		% reverse=auto
+		\expandafter\pgfpathfillbetween@heuristics@get@direction#2\pgf@stop
+		\let\pgfpath@filled@dir@first=\pgfretval
+		\expandafter\pgfpathfillbetween@heuristics@get@direction#3\pgf@stop
+		\let\pgfpath@filled@dir@second=\pgfretval
+		%
+		\ifx\pgfpath@filled@dir@first\pgfpath@filled@dir@second
+			% Ok, they (seem to) have the same direction. Reverse one of them:
+			\def\pgfpathfillbetween@reverse@mode{1}%
+		\else
+			\def\pgfpathfillbetween@reverse@mode{0}%
+		\fi
+	\fi
+	%
+	% softclip, if configured (no-op otherwise):
+	\pgfpathcomputesoftclippath{#2}{\pgfpathfillbetween@softclip@A}\let#2=\pgfretval%
+	\pgfpathcomputesoftclippath{#3}{\pgfpathfillbetween@softclip@B}\let#3=\pgfretval%
+	%
+	\ifx#2\pgfutil@empty
+		\ifx\pgfpathfillbetween@softclip@A\pgfutil@empty
+			\pgfpathfillbetween@warning{first}%
+		\else
+			\pgfpathfillbetween@warning{soft-clipped first}%
+		\fi
+	\else
+		\ifx#3\pgfutil@empty
+			\ifx\pgfpathfillbetween@softclip@B\pgfutil@empty
+				\pgfpathfillbetween@warning{second}%
+			\else
+				\pgfpathfillbetween@warning{soft-clipped second}%
+			\fi
+		\else
+			%
+			\ifpgfpathfillbetween@split
+				\pgfpathfillbetween@compute@splitted{#2}{#3}%
+			\else
+				\pgfkeys{/pgf/fill between/result stream/begin=1}%
+				\pgfpathfillbetween@compute{#2}{#3}%
+				\pgfpathfillbetween@invoke{result stream/next ready}%
+				\pgfpathfillbetween@invoke{result stream/end}%
+			\fi
+		\fi
+	\fi
+	%
+	%
+	\endgroup
+}%
+
+\def\pgfpathfillbetween@warning#1{%
+	\pgfwarning{fill between skipped: the #1 input path is empty.}%
+}%
+
+% Replaces all 'moveto' operations inside of the soft path '#1' by
+% 'lineto'. This excludes the first moveto.
+%
+% The motivation is that fillbetween should ignore inner movetos.
+%
+% UPDATE: it turned out that replacing inner movetos is necessary, but
+% not sufficient. Now, this macro does more:
+% - it replaces isolated inner movetos by lineto
+% - if two successive inner movetos occur, it throws away the first
+%   one replaces the second by lineto
+% - if one or more trailing movetos occur in a path, these will be
+%   thrown away.
+\def\pgfpathfillbetween@connect@inner@movetos#1{%
+	\expandafter\pgfpathfillbetween@connect@inner@movetos@#1\pgf@stop%
+	\let#1=\pgfretval
+}
+\def\pgfpathfillbetween@connect@inner@movetos@#1#2\pgf@stop{%
+	\ifx#1\pgfsyssoftpath@movetotoken
+		\pgfpathfillbetween@connect@inner@movetos@@{#2}%
+		\expandafter\def\expandafter\pgfretval\expandafter{\expandafter\pgfsyssoftpath@movetotoken\pgfretval}%
+	\else
+		\pgfpathfillbetween@connect@inner@movetos@@{#1#2}%
+	\fi
+}%
+
+% Substitute all movetotokens by linetotokens.
+%
+% In addition, it should *deduplicate* movetos, i.e.
+% "moveto{<x>}{<y}moveto{<x2>}{<y2>}"
+% -> "moveto{<x2>}{<y2>}"
+%
+% and: trailing movetos should be discarded.
+\def\pgfpathfillbetween@connect@inner@movetos@@#1{%
+	% this implementation is derived from \pgfutilstrreplace - it does
+	% almost the same as
+	% s/\pgfsyssoftpath@movetotoken/pgfsyssoftpath@linetotoken/g
+	% -> but with the extra additions of deduplication and trailing
+	%  moveto removal.
+	\def\pgfretval{}%
+	\pgfpathfillbetween@search@and@replace@loop{#1}%
+}
+\def\pgfpathfillbetween@connect@inner@moveto@foundit@#1\pgfsyssoftpath@movetotoken#2#3#4{%
+	\ifx#4\pgf@EOI
+		% ah - a trailing moveto.
+		% In this case, we remember all until the moveto, but we omit
+		% the trailing moveto and its arguments.
+		\expandafter\def\expandafter\pgfretval\expandafter{\pgfretval #1}%
+		%
+		% ... and stop searching.
+		\let\pgf@loc@TMPa\relax
+	\else
+		\ifx#4\pgfsyssoftpath@movetotoken
+			% DEDUPLICATE: we have at least two successive movetos.
+			% silently skip the first moveto and its arguments and go on
+			% with the second moveto.
+			\def\pgf@loc@TMPa{\pgfpathfillbetween@connect@inner@moveto@foundit@#1\pgfsyssoftpath@movetotoken}%
+		\else
+			% substitute it by a lineto.
+			\expandafter\def\expandafter\pgfretval\expandafter{\pgfretval #1\pgfsyssoftpath@linetotoken{#2}{#3}}%
+			%
+			% ... continue the standard loop which skips over paths
+			% until the next moveto. Remember to re-insert '#4':
+			\def\pgf@loc@TMPa{\pgfpathfillbetween@connect@inner@moveto@foundit@@ #4}%
+		\fi
+	\fi
+	\pgf@loc@TMPa
+}%
+\def\pgfpathfillbetween@connect@inner@moveto@foundit@@#1\pgf@EOI{%
+	\pgfpathfillbetween@search@and@replace@loop{#1}%
+}%
+
+\def\pgfpathfillbetween@search@and@replace@loop#1{%
+	\pgfutil@in@{\pgfsyssoftpath@movetotoken}{#1}%
+	\ifpgfutil@in@
+		\def\pgf@loc@TMPa{\pgfpathfillbetween@connect@inner@moveto@foundit@ #1\pgf@EOI}%
+	\else
+		\expandafter\def\expandafter\pgfretval\expandafter{\pgfretval #1}%
+		\let\pgf@loc@TMPa=\relax
+	\fi
+	\pgf@loc@TMPa
+}%
+
+\def\pgfpathfillbetween@invoke#1{\pgfkeysvalueof{/pgf/fill between/#1/.@cmd}\pgfeov}
+
+\def\pgfpathfillbetween@replace@first@moveto#1#2\pgf@stop{%
+	\ifx#1\pgfsyssoftpath@movetotoken
+		\def\pgfretval{\pgfsyssoftpath@linetotoken #2}%
+	\else
+		\def\pgfretval{#1#2}%
+	\fi
+}%
+
+\def\pgfpathfillbetween@compute@splitted#1#2{%
+	% 0. normalize path sequences.
+	%  ATTENTION : there are implicit assumptions on the INTERNAL ORDER of the two paths!
+    %    This implementation needs to loop over them synchronously, i.e. it processes
+	%       the 0.th segment of a and the 0th of b,
+	%       the 1.th segment of a and the 1th of b,
+	%    and so on. Here, "i th segment" implies a sort order in ascending x direction.
+	%    This is, however, a weakness of \pgfintersectionofpaths - it does not really support this kind of sorting.
+	%
+	%   I work around this by restricting the implementation to the "common use-cases", i.e. to two plots of functions which do not intersect themselves (i.e. to "functions" in the original sense). This will probably (almost surely) fail for parametric functions or circles.
+    %
+	\if0\pgfpathfillbetween@reverse@mode
+		% reverse=false
+		%
+		% This means one plot is in direction '+' and one in '-', i.e.
+		% a:  x ---> x ---> x
+		% b:  x <--- x <--- x
+		%
+		% However, we have the implicit assumption that both paths can be processed synchronously, i.e. that they have the SAME direction.
+		% To this end, we have to reverse one of them here (since \pgfintersectionofpaths does not automatically sort results in a suitable way):
+		%
+		\pgf@reverse@path{#2}%
+		\let#2=\pgfretval
+		%
+		% However, we need to re-reverse the individual segments later-on...
+		% So: set 'reverse=true'. Will be respected when assembling the splitted segments...
+		\def\pgfpathfillbetween@reverse@mode{1}%
+	\fi
+	%
+	% 1. compute intersection points:
+	\pgf@intersect@sort@by@second@pathfalse
+	%
+	% FIXME : do we want to sort by time!? That might be needed for curvetos ... ?
+	\pgf@intersect@sortfalse
+	\pgfintersectionofpaths%
+		{%
+			\pgfsetpath#1%
+		}%
+		{%
+			\pgfsetpath#2%
+		}%
+	%
+	% FIXME : computing the intersections is fine... but it would be
+	% even finer to report the resulting points back to tikz!
+	% -> call the *tikz* intersection lib through some sort of callback!?
+	%
+	% 2.  split the first involved path into the
+	% segments induced by the intersection points:
+	\pgfcomputeintersectionsegments{1}%
+	\let\pgfpathfilled@a@segments=\pgfretval
+%
+	% 2. split the second involved path into the
+	% segments induced by the intersection points:
+	\pgfcomputeintersectionsegments{2}%
+	\let\pgfpathfilled@b@segments=\pgfretval
+	%
+	\ifnum\pgfpathfilled@a@segments=\pgfpathfilled@b@segments\relax
+	\else
+		\pgferror{Illegal internal state encountered: the number segments induced by the intersection points of the two paths DIFFER between the first and the second path: first path has \pgfpathfilled@a@segments\space whereas the second has \pgfpathfilled@b@segments.}%
+	\fi
+	%
+	% STEP 1: find out if there are empty segments. Numerical
+	% inaccuracies occasionally result in such segments; we silently
+	% skip them.
+	\def\c@pgfpathfilled@nonemptysegments{0}%
+	\def\c@pgfpathfilled@counter{0}%
+	\pgfmathloop
+	\ifnum\c@pgfpathfilled@counter<\pgfpathfilled@a@segments\relax
+		\expandafter\let\expandafter\pgf@loc@path@a\csname pgf@intersect@path@split@a@\c@pgfpathfilled@counter\endcsname
+		\expandafter\let\expandafter\pgf@loc@path@b\csname pgf@intersect@path@split@b@\c@pgfpathfilled@counter\endcsname
+		%
+		\if1\pgfpathfillbetween@omit@empty@segments
+			\pgfpathfillbetween@compute@checkempty{\pgf@loc@path@a}%
+			% A segment is empty if BOTH of its input segments are empty:
+			\if1\pgfretval
+				\pgfpathfillbetween@compute@checkempty{\pgf@loc@path@b}%
+				\if1\pgfretval
+					\pgfutil@IfUndefined{pgfplots@log}{}{%
+						\pgfplots@log4{fillbetween: skipping empty intersection segment no \c@pgfpathfilled@counter}%
+					}%
+					\expandafter\def\csname pgf@interset@path@empty@\c@pgfpathfilled@counter\endcsname{1}%
+				\else
+					\expandafter\def\csname pgf@interset@path@empty@\c@pgfpathfilled@counter\endcsname{0}%
+					\pgfutil@advancestringcounter\c@pgfpathfilled@nonemptysegments
+				\fi
+			\else
+				\expandafter\def\csname pgf@interset@path@empty@\c@pgfpathfilled@counter\endcsname{0}%
+				\pgfutil@advancestringcounter\c@pgfpathfilled@nonemptysegments
+			\fi
+		\else
+			\expandafter\def\csname pgf@interset@path@empty@\c@pgfpathfilled@counter\endcsname{0}%
+			\pgfutil@advancestringcounter\c@pgfpathfilled@nonemptysegments
+		\fi
+		%
+		\pgfutil@advancestringcounter\c@pgfpathfilled@counter
+	\repeatpgfmathloop
+	%
+	\ifnum\c@pgfpathfilled@nonemptysegments=0
+	\else
+		\pgfkeys{/pgf/fill between/result stream/begin=\c@pgfpathfilled@nonemptysegments}%
+		% Recombine the pairs of segments (a_i, b_i), i = 0,..., N-1 in a
+		% filled way:
+		\def\c@pgfpathfilled@counter{0}%
+		\pgfmathloop
+		\ifnum\c@pgfpathfilled@counter<\pgfpathfilled@a@segments\relax
+			\if0\csname pgf@interset@path@empty@\c@pgfpathfilled@counter\endcsname
+				\expandafter\let\expandafter\pgf@loc@path@a\csname pgf@intersect@path@split@a@\c@pgfpathfilled@counter\endcsname
+				\expandafter\let\expandafter\pgf@loc@path@b\csname pgf@intersect@path@split@b@\c@pgfpathfilled@counter\endcsname
+				%
+				\pgfpathfillbetween@compute{\pgf@loc@path@a}{\pgf@loc@path@b}%
+				% report to the result stream. It knows how to deal with it:
+				\pgfpathfillbetween@invoke{result stream/next ready}%
+				%
+			\fi
+			\pgfutil@advancestringcounter\c@pgfpathfilled@counter
+		\repeatpgfmathloop
+		\pgfpathfillbetween@invoke{result stream/end}%
+	\fi
+}
+
+\def\pgflibraryfillbetweenemptysegmenttolerance{1pt}
+
+\def\pgfpathfillbetween@compute@checkempty#1{%
+	\def\pgfretval{0}%
+	\pgf@compute@BB{#1}%
+	\advance\pgf@xb by-\pgf@xa
+	\advance\pgf@yb by-\pgf@ya
+	% if one of the dimensions is empty, the segment is empty:
+	\ifdim\pgf@xb<\pgflibraryfillbetweenemptysegmenttolerance\relax
+		\def\pgfretval{1}%
+	\fi
+	\ifdim\pgf@yb<\pgflibraryfillbetweenemptysegmenttolerance\relax
+		\def\pgfretval{1}%
+	\fi
+}
+
+\def\pgfpathfillbetween@compute#1#2{%
+%\message{Combination of ^^J  \meaning#1\space and ^^J \meaning#2...^^J}%
+	%
+	\if1\pgfpathfillbetween@reverse@mode
+		% reverse=true
+		%
+		% Ok, then reverse one of the paths. We choose the second one as that is easier to debug.
+		% FIXME : might make sense to determine which one is shorter...
+		\pgf@reverse@path{#2}%
+		\let#2=\pgfretval
+	\fi
+	%
+	% FIXME: what should I do if I have closed paths!? What is the
+	% expected behavior!? I know that the combination of two closed
+	% paths should probably be used as is, perhaps with even-odd-rule.
+	% This here should do the job.
+	%
+	% NOTE: I believe the 'split' fails to work with closed paths.
+	\pgfpathfillbetween@contains@closepathtoken{#1}%
+	\let\b@pgfpathfillbetween@contains@close@a=\pgfretval
+	\pgfpathfillbetween@contains@closepathtoken{#2}%
+	\let\b@pgfpathfillbetween@contains@close@b=\pgfretval
+	%
+	\def\b@pgfpathfillbetween@contains@close{0}%
+	\if1\b@pgfpathfillbetween@contains@close@b
+		\def\b@pgfpathfillbetween@contains@close{1}%
+	\fi
+	\if1\b@pgfpathfillbetween@contains@close@a
+		\def\b@pgfpathfillbetween@contains@close{1}%
+	\fi
+	%
+	\if0\b@pgfpathfillbetween@contains@close@b
+		\expandafter\pgfpathfillbetween@replace@first@moveto#2\pgf@stop
+		\let#2=\pgfretval
+	\fi
+	%
+	\t@pgf@toka=\expandafter{#1}%
+	\t@pgf@tokb=\expandafter{#2}%
+	%
+	\if0\b@pgfpathfillbetween@contains@close
+		% we need to close the resulting combined path, otherwise decorations will look strange:
+		\expandafter\pgfpathfillbetween@get@first@coord#1\pgf@stop
+		\t@pgf@tokc=\expandafter{\expandafter\pgfsyssoftpath@closepathtoken\pgfretval}%
+	\else
+		\t@pgf@tokc={}%
+	\fi
+	%
+	\edef\pgfretval{\the\t@pgf@toka\the\t@pgf@tokb\the\t@pgf@tokc}%
+	%
+%\message{^^J   = \meaning\pgfretval^^J}%
+	% that's it.
+}
+
+% #1 a macro containing a softpath
+% OUTPUT:
+%   \pgfretval = 1 if the path contains \pgfsyssoftpath@closepathtoken
+%   and 0 otherwise.
+\def\pgfpathfillbetween@contains@closepathtoken#1{%
+	\expandafter\pgfutil@in@\expandafter\pgfsyssoftpath@closepathtoken\expandafter{#1}%
+	\ifpgfutil@in@
+		\def\pgfretval{1}%
+	\else
+		\def\pgfretval{0}%
+	\fi
+}
+
+\def\pgfpathfillbetween@get@first@coord#1#2#3#4\pgf@stop{%
+	\def\pgfretval{{#2}{#3}}%
+}%
+
+% assigns the bounding box of path #1 to 
+% (pgf@xa , pgf@ya) = (minx,miny)
+% (pgf@xb , pgf@yb) = (maxx,maxy)
+\def\pgf@compute@BB#1{%
+	\begingroup
+	\dimendef\pgf@pathmaxx=0 %
+	\dimendef\pgf@pathminx=1 %
+	\dimendef\pgf@pathmaxy=2 %
+	\dimendef\pgf@pathminy=3 %
+	\pgf@pathmaxx=-16000pt\relax%
+	\pgf@pathminx=16000pt\relax%
+	\pgf@pathmaxy=-16000pt\relax%
+	\pgf@pathminy=16000pt\relax%
+	\let\pgf@protocolsizes=\pgf@compute@BB@protocol@sizes
+	\expandafter\pgfsetpath@loop#1\pgf@stop
+	\xdef\pgf@marshal{%
+		\pgf@xa=\the\pgf@pathminx\relax
+		\pgf@ya=\the\pgf@pathminy\relax
+		\pgf@xb=\the\pgf@pathmaxx\relax
+		\pgf@yb=\the\pgf@pathmaxy\relax
+	}%
+	\endgroup
+	\pgf@marshal
+}%
+\def\pgf@compute@BB@protocol@sizes#1#2{%
+  \ifdim#1<\pgf@pathminx\pgf@pathminx#1\fi%
+  \ifdim#1>\pgf@pathmaxx\pgf@pathmaxx#1\fi%
+  \ifdim#2<\pgf@pathminy\pgf@pathminy#2\fi%
+  \ifdim#2>\pgf@pathmaxy\pgf@pathmaxy#2\fi%
+}
+
+% A utility function like \pgfsetpath which calls \pgfsetpath *and* protocols
+% the size of each path segment (i.e. compute the bounding box).
+%
+% #1 a macro containing a softpath (i.e. something returned by
+% \pgfgetpath)
+%
+% SIDE--EFFECT: defines \pgfpointlastofsetpath  to be the last point of path #1
+\def\pgfsetpathandBB#1{%
+	\let\pgfpointlastofsetpath=\pgfutil@empty
+	\expandafter\pgfsetpath@loop#1\pgf@stop
+	%
+	\pgfsetpath{#1}%
+}%
+
+% Like \pgfsetpathandBB, but this here *appends* to the existing
+% softpath.
+%
+% #1 a macro containing a softpath (i.e. something returned by
+% \pgfgetpath)
+% SIDE--EFFECT: defines \pgfpointlastofsetpath  to be the last point of path #1
+\def\pgfaddpathandBB#1{%
+	\let\pgfpointlastofsetpath=\pgfutil@empty
+	\expandafter\pgfsetpath@loop#1\pgf@stop
+	\pgfaddpath#1%
+}
+
+% Like \pgfsetpath, but this here *appends* to the existing
+% softpath.
+%
+% #1 a macro containing a softpath (i.e. something returned by
+% \pgfgetpath)
+\def\pgfaddpath#1{%
+	% append to any previous path elements:
+	\pgfgetpath\pgf@temp
+	\t@pgf@tokc=\expandafter{\pgf@temp}%
+	\t@pgf@toka=\expandafter{#1}%
+	\edef\pgfretval{\the\t@pgf@tokc\the\t@pgf@toka}%
+	\pgfsetpath{\pgfretval}%
+}
+
+% Takes a softpath on input, replaces its first moveto by a lineto,
+% and returns it as softpath.
+% #1: a macro containing a softpath (i.e. the result of \pgfgetpath)
+%
+% On output, \pgfretval contains a modified path.
+\def\pgfpathreplacefirstmoveto#1{%
+	\ifx#1\pgfutil@empty
+		\let\pgfretval=#1%
+	\else
+		\expandafter\pgfpathfillbetween@replace@first@moveto#1\pgf@stop
+	\fi
+}
+
+% Defines \pgfretval to be '+' if the path's direction is "ascending"
+% and "-" otherwise.
+%
+% Here, "ascending" means that its first two coordinates have
+% ascending X coordinates. If the X coordinates are equal, the Y
+% coordinates are used instead.
+\def\pgfpathfillbetween@heuristics@get@direction#1#2#3{%
+	\pgfutil@ifnextchar\pgf@stop{%
+		% wow. it has just one path element... we can do nothing.
+		\def\pgfretval{+}%
+		\pgfutil@gobble
+	}{%
+		\pgfpathfillbetween@heuristics@get@direction@{#1}{#2}{#3}%
+	}%
+}%
+
+% example: \pgfsyssoftpath@movetotoken{#2}{#3}\pgfsyssoftpath@linetotoken{#5}{#6}#7\pgf@stop
+% example:
+%	\pgfsyssoftpath@movetotoken{#2}{#3}
+%	\pgfsyssoftpath@curvetosupportatoken{<x>}{<y>}
+%	\pgfsyssoftpath@curvetosupportbtoken{<x>}{<y>}
+%	\pgfsyssoftpath@curvetotoken{<x>}{<y>}\pgf@stop
+\def\pgfpathfillbetween@heuristics@get@direction@#1#2#3#4#5#6#7\pgf@stop{%
+	\def\pgf@temp{#4}%
+	\def\pgf@tempb{\pgfsyssoftpath@curvetosupportatoken}%
+	\ifx\pgf@temp\pgf@tempb
+		% Ah - a curveto! Use the end-point for the heuristics.
+		\pgfpathfillbetween@heuristics@get@direction@curveto #1{#2}{#3}#4{#5}{#6}#7\pgf@stop
+	\else
+		% Ok, assume it is line to (or its variants):
+		\pgfpathfillbetween@heuristics@get@direction@@{#2}{#3}{#5}{#6}%
+	\fi
+}%
+
+\def\pgfpathfillbetween@heuristics@get@direction@curveto#1#2#3\pgfsyssoftpath@curvetosupportatoken#4\pgfsyssoftpath@curvetotoken#5#6#7\pgf@stop{%
+	\pgfpathfillbetween@heuristics@get@direction@@{#2}{#3}{#5}{#6}%
+}%
+
+% #1: x1
+% #2: y1
+% #3: x2
+% #4: y2
+\def\pgfpathfillbetween@heuristics@get@direction@@#1#2#3#4{%
+	\edef\pgfretval{%
+		\ifdim #1<#3\space
+			+%
+		\else
+			\ifdim #1=#3\space
+				\ifdim #2<#4\space
+					+%
+				\else
+					-%
+				\fi
+			\else
+				-%
+			\fi
+		\fi
+	}%
+}
+
+% Accumulates the path's bounding box, the last moveto, and the last
+% coord.
+\def\pgfsetpath@loop#1{%
+	\ifx#1\pgf@stop%
+		\let\pgfsetpathBB@protocolsizesnext=\relax%
+	\else%
+		\ifx#1\pgfsyssoftpath@movetotoken%
+			\let\pgfsetpathBB@protocolsizesnext=\pgfsetpathBB@protocolsizestoken@moveto%
+		\else%
+			\ifx#1\pgfsyssoftpath@linetotoken%
+				\let\pgfsetpathBB@protocolsizesnext=\pgfsetpathBB@protocolsizestoken@simple%
+			\else%
+				\ifx#1\pgfsyssoftpath@closepathtoken%
+					\let\pgfsetpathBB@protocolsizesnext=\pgfsetpathBB@protocolsizestoken@simple%
+				\else%
+					\ifx#1\pgfsyssoftpath@curvetosupportatoken%
+						\let\pgfsetpathBB@protocolsizesnext=\pgfsetpathBB@protocolsizestoken@curveto%
+					\else%
+						\ifx#1\pgfsyssoftpath@rectcornertoken%
+							\let\pgfsetpathBB@protocolsizesnext=\pgfsetpathBB@protocolsizestoken@rect%
+						\fi%
+					\fi%
+				\fi%
+			\fi%
+		\fi%
+	\fi%
+	\pgfsetpathBB@protocolsizesnext}
+
+\def\pgfsetpathBB@protocol@lastmoveto#1#2{%
+	\gdef\pgfsyssoftpath@lastmoveto{{#1}{#2}}%
+}
+
+\def\pgfsetpathBB@protocolsizestoken@moveto#1#2{%
+	% required for --cycle, among others:
+	\pgfsetpathBB@protocol@lastmoveto{#1}{#2}%
+	\pgfsetpathBB@protocolsizestoken@simple{#1}{#2}%
+}
+\def\pgfsetpathBB@protocolsizestoken@simple#1#2{%
+	\def\pgfpointlastofsetpath{\pgfqpoint{#1}{#2}}%
+	\pgf@protocolsizes{#1}{#2}%
+	\pgfsetpath@loop%
+}
+
+\def\pgfsetpathBB@protocolsizestoken@curveto#1#2\pgfsyssoftpath@curvetosupportbtoken#3#4\pgfsyssoftpath@curvetotoken#5#6{%
+	\def\pgfpointlastofsetpath{\pgfqpoint{#5}{#6}}%
+	\pgf@protocolsizes{#1}{#2}%
+	\pgf@protocolsizes{#3}{#4}%
+	\pgf@protocolsizes{#5}{#6}%
+	\pgfsetpath@loop
+}
+
+\def\pgfsetpathBB@protocolsizestoken@rect#1#2\pgfsyssoftpath@rectsizetoken#3#4{%
+	\pgf@protocolsizes{#1}{#2}%
+	\pgf@xa=#1\relax%
+	\advance\pgf@xa by#3\relax%
+	\pgf@ya=#2\relax%
+	\advance\pgf@ya by#4\relax%
+	\pgf@protocolsizes{\pgf@xa}{\pgf@ya}%
+	\pgfsetpath@loop
+}%
+
+% Defines \pgfretval to be the reversed path of #1.
+%
+% #1 is supposed to be a macro containing a path without rounding specials (i.e. a result
+% of \pgfprocessround)
+\def\pgfcomputereversepath#1{%
+	% unfortunately, this is already used by internal macros...
+	\pgf@reverse@path#1%
+}%
+\def\pgf@reverse@path#1{%
+	% ATTENTION: this here is a special implementation which
+	% operates directly on softpaths. It does not make use of \pgf@decorate@inputsegmentobjects@reverse (reverse path decoration)
+	% because (a) decorations require their own special format and (b)
+	% this implementation is faster (both with respect to runtime asymptotics and runtime constant).
+	\def\pgf@reverse@first@type{}%
+	\def\pgf@reverse@last@pt{}%
+	\def\b@pgf@reversepath@last@is@close{0}%
+	\pgfprependlistnewempty{pgfretval}%
+	\let\pgfreverse@iterate=\pgfreverse@checkfirst@then
+	\expandafter\pgf@reverse@loop#1\pgf@stop
+	%
+	\if 0\b@pgf@reversepath@last@is@close%
+		\expandafter\pgfreverse@prepend@last\expandafter{\pgf@reverse@first@type}{x}{x}%
+	\else
+		% as soon as a closepathtoken is encountered, the associated
+		% moveto is processed right away.
+		%
+		% FIXME : I doubt that the implementation works if more than
+		% one closepathtoken is in here ...
+	\fi
+	\pgfprependlistlet\pgfretval={pgfretval}%
+	%
+}%
+
+\def\pgf@reverse@loop#1{%
+	\ifx#1\pgf@stop%
+		\let\pgfreverse@next=\relax%
+	\else%
+		\def\b@pgf@reversepath@last@is@close{0}%
+		\ifx#1\pgfsyssoftpath@movetotoken%
+			\let\pgfreverse@next=\pgfreverse@token@moveto%
+		\else%
+			\ifx#1\pgfsyssoftpath@linetotoken%
+				\let\pgfreverse@next=\pgfreverse@token@lineto%
+			\else%
+				\ifx#1\pgfsyssoftpath@closepathtoken%
+					\let\pgfreverse@next=\pgfreverse@token@close%
+				\else%
+					\ifx#1\pgfsyssoftpath@curvetosupportatoken%
+						\let\pgfreverse@next=\pgfreverse@token@curveto%
+					\else%
+						\ifx#1\pgfsyssoftpath@rectcornertoken%
+							\let\pgfreverse@next=\pgfreverse@token@rect%
+						\fi%
+					\fi%
+				\fi%
+			\fi%
+		\fi%
+	\fi%
+	\pgfreverse@next}
+
+\def\pgfreverse@checkfirst@then#1{%
+	\def\pgf@reverse@first@type{#1}%
+	\let\pgfreverse@iterate=\pgfutil@gobble
+}%
+
+\def\pgfreverse@prepend@last#1#2#3{%
+	\ifx\pgf@reverse@last@pt\pgfutil@empty
+	\else
+		\t@pgf@toka={#1}%
+		\t@pgf@tokb=\expandafter{\pgf@reverse@last@pt}%
+		\edef\pgf@marshal{\the\t@pgf@toka\the\t@pgf@tokb}%
+		\expandafter\pgfprependlistpushfront\pgf@marshal\to{pgfretval}%
+	\fi
+	\def\pgf@reverse@last@pt{{#2}{#3}}%
+}%
+
+\def\pgfreverse@token@moveto#1#2{%
+	\pgfreverse@iterate{\pgfsyssoftpath@movetotoken}%
+	\pgfreverse@prepend@last\pgfsyssoftpath@movetotoken{#1}{#2}%
+	\pgf@reverse@loop%
+}
+
+\def\pgfreverse@token@lineto#1#2{%
+	\pgfreverse@iterate{\pgfsyssoftpath@linetotoken}%
+	\pgfreverse@prepend@last\pgfsyssoftpath@linetotoken{#1}{#2}%
+	\pgf@reverse@loop
+}
+\def\pgfreverse@token@close#1#2{%
+	% close tokens are complicated: they always correspond to the most
+	% recent moveto token.
+	%
+	% First: remember that the last encountered token was 'close': if
+	% this is the lastmost token, we must not insert a final moveto.
+	\def\b@pgf@reversepath@last@is@close{1}%
+	%
+	% Second: *append*
+	% \pgfsyssoftpath@closepathtoken{<lastx>}{<lasty>}.
+	%
+	% Appending is unsupported by the prepend-list, so we have to
+	% terminate it, append, and reinitialize it with the result:
+	\pgfprependlistlet\pgfretval={pgfretval}%
+	\t@pgf@toka=\expandafter{\pgfretval}%
+	\t@pgf@tokb={\pgfsyssoftpath@closepathtoken}%
+	\t@pgf@tokc=\expandafter{\pgf@reverse@last@pt}%
+	\edef\pgf@marshal{\the\t@pgf@toka\the\t@pgf@tokb\the\t@pgf@tokc}%
+	%
+	% ... create a new list with the result:
+	\pgfprependlistnewempty{pgfretval}%
+	\expandafter\pgfprependlistpushfront\pgf@marshal\to{pgfretval}%
+	%
+	% and prepend a moveto.
+	\pgfreverse@prepend@last\pgfsyssoftpath@movetotoken{#1}{#2}%
+	%
+	\pgf@reverse@loop
+}
+
+\def\pgfreverse@token@curveto#1#2\pgfsyssoftpath@curvetosupportbtoken#3#4\pgfsyssoftpath@curvetotoken#5#6{%
+	\pgfreverse@iterate{\pgfsyssoftpath@curvetosupportatoken{#1}{#2}\pgfsyssoftpath@curvetosupportbtoken{#3}{#4}\pgfsyssoftpath@curvetotoken}%
+	\pgfreverse@prepend@last{\pgfsyssoftpath@curvetosupportatoken{#3}{#4}\pgfsyssoftpath@curvetosupportbtoken{#1}{#2}\pgfsyssoftpath@curvetotoken}{#5}{#6}%
+	\pgf@reverse@loop
+}
+
+\def\pgfreverse@token@rect#1#2\pgfsyssoftpath@rectsizetoken#3#4{%
+	% FIXME: UNTESTED
+	\pgf@xa=#1\relax%
+	\advance\pgf@xa by#3\relax%
+	\pgf@ya=#2\relax%
+	\advance\pgf@ya by#4\relax%
+	\edef\pgf@marshal{%
+		\noexpand\pgfsyssoftpath@movetotoken
+		{%
+			{#1}{#2}%
+			\noexpand\pgfsyssoftpath@linetotoken{\the\pgf@xa}{#2}%
+			\noexpand\pgfsyssoftpath@linetotoken{\the\pgf@xa}{\the\pgf@ya}%
+			\noexpand\pgfsyssoftpath@linetotoken{#1}{\the\pgf@ya}%
+			\noexpand\pgfsyssoftpath@closepathtoken{#1}{#2}%
+		}%
+	}%
+	\pgfreverse@iterate\pgfsyssoftpath@movetotoken
+	\edef\pgf@reverse@last@pt{{#1}{#2}}%
+	\expandafter\pgf@reverse@loop\pgf@marshal%
+}
+
+% ----------------------------------------
+% Given that some intersections have been computed already (and are in
+% the current scope), this command computes the intersection segments
+% for one of the input arguments.
+%
+% On output, both \pgfretval and \pgfintersectionsegments contain the number of computed segments. The
+% segments as such can be accessed via \pgfgetintersectionsegmentpath.
+%
+% #1 : should be '1' if the FIRST argument of
+% \pgfintersectionofpaths should be used and '2' the SECOND
+% argument of \pgfintersectionofpaths should be used on input.
+%
+% EXAMPLE:
+%
+%   	\def\inputValue{%
+%   		\pgfsyssoftpath@movetotoken {56.90549pt}{0.0pt}%
+%   		\pgfsyssoftpath@linetotoken {85.35823pt}{28.45274pt}%
+%   		\pgfsyssoftpath@linetotoken {113.81097pt}{0.0pt}%
+%   		\pgfsyssoftpath@linetotoken {142.26372pt}{28.45274pt}%
+%   		\pgfsyssoftpath@linetotoken {170.71646pt}{0.0pt}%
+%   	}
+%
+%   	\pgfpointintersectionsolution{1}%
+%   	\pgfplotsassertequalstok{\the\pgf@x, \the\pgf@y}{71.13918pt, 14.2278pt}{solution 1}
+%   	\pgfpointintersectionsolution{2}%
+%   	\pgfplotsassertequalstok{\the\pgf@x, \the\pgf@y}{99.59497pt, 14.2278pt}{solution 2}
+%   	\pgfpointintersectionsolution{3}%
+%   	\pgfplotsassertequalstok{\the\pgf@x, \the\pgf@y}{128.05057pt, 14.2278pt}{solution 3}
+%   	\pgfpointintersectionsolution{4}%
+%   	\pgfplotsassertequalstok{\the\pgf@x, \the\pgf@y}{156.50636pt, 14.2278pt}{solution 4}
+%
+%
+%   	\pgfcomputeintersectionsegments{1}%
+%
+%   	\message{OUTPUT: \meaning\pgfretval^^J}%
+%   	\expandafter\def\csname expected@a@0\endcsname{%
+%   		\pgfsyssoftpath@movetotoken {56.90549pt}{0.0pt}%
+%   \pgfsyssoftpath@linetotoken{71.13918pt}{14.2278pt}%
+%   	}
+%   	\expandafter\def\csname expected@a@1\endcsname{%
+%   		\pgfsyssoftpath@movetotoken{71.13918pt}{14.2278pt}%
+%   		\pgfsyssoftpath@linetotoken {85.35823pt}{28.45274pt}%
+%   \pgfsyssoftpath@linetotoken{99.59497pt}{14.2278pt}%
+%   	}
+%   	\expandafter\def\csname expected@a@2\endcsname{%
+%   		\pgfsyssoftpath@movetotoken{99.59497pt}{14.2278pt}%
+%   		\pgfsyssoftpath@linetotoken {113.81097pt}{0.0pt}%
+%   \pgfsyssoftpath@linetotoken{128.05057pt}{14.2278pt}%
+%   	}
+%   	\expandafter\def\csname expected@a@3\endcsname{%
+%   		\pgfsyssoftpath@movetotoken{128.05057pt}{14.2278pt}%
+%   		\pgfsyssoftpath@linetotoken {142.26372pt}{28.45274pt}%
+%   \pgfsyssoftpath@linetotoken{156.50636pt}{14.2278pt}%
+%   	}
+%   	\expandafter\def\csname expected@a@4\endcsname{%
+%   		\pgfsyssoftpath@movetotoken{156.50636pt}{14.2278pt}%
+%   		\pgfsyssoftpath@linetotoken {170.71646pt}{0.0pt}%
+%   	}
+%   %
+\def\pgfcomputeintersectionsegments#1{%
+	\pgfcomputeintersectionsegments@set@src{#1}%
+	\ifnum\pgfintersectionsolutions=0 %
+		\pgfutil@namelet{pgf@intersect@path@split@\pgf@insert@intersections@src @0}{pgf@intersect@path@\pgf@insert@intersections@src}%
+		\def\pgfretval{0}%
+	\else
+		%
+		% This algorithm *relies* on an increasing sort order. Sort
+		% them:
+		\pgfintersectionsolutionsortbytime@@%
+		%
+		%
+		\pgfapplistnewempty{pgfretval@tmp}%
+		\def\pgf@insert@cursolution{1}%
+		\def\c@pgf@path@result{0}%
+		\let\c@pgf@path@segment=\c@pgf@countd
+		\let\c@pgf@path@segment@trg=\c@pgf@countc
+		\c@pgf@path@segment=0 %
+		\pgf@fillbetween@get@time@off{\pgf@insert@intersections@src}{\pgf@insert@cursolution}%
+		\c@pgf@path@segment@trg=\pgfretval\relax
+		%
+		\pgfutil@namelet{pgf@loc@TMPa}{pgf@intersect@path@\pgf@insert@intersections@src}%
+		\expandafter\pgf@insert@intersections@loop\pgf@loc@TMPa\pgf@stop
+		%
+		\pgfapplistlet\pgf@loc@TMPa={pgfretval@tmp}%
+		\expandafter\let\csname pgf@intersect@path@split@\pgf@insert@intersections@src @\c@pgf@path@result\endcsname=\pgf@loc@TMPa%
+		\pgfutil@advancestringcounter\c@pgf@path@result%
+		\let\pgfretval=\c@pgf@path@result%
+	\fi
+	\let\pgfintersectionsegments=\pgfretval
+}%
+
+% Defines \pgfretval to contain the desired path segment as softpath.
+%
+% @see \pgfsetpath
+% @see \pgfsetpathandBB
+% @see \pgfaddpathandBB
+%
+% #1: the value '1' if results for the FIRST argument of
+% \pgfintersectionofpaths are requested or '2' if results for the
+% SECOND path are requested (compare \pgfcomputeintersectionsegments).
+% #2: the segment index (a number 0<= #2 < numbersegments).
+%  The number of segments is \pgfintersectionsegments
+\def\pgfgetintersectionsegmentpath#1#2{%
+	\pgfcomputeintersectionsegments@set@src{#1}%
+	\pgfmathparse{#2}%
+	\afterassignment\pgfcomputeintersectionsegments@set@src@gobble
+	\c@pgf@countc=\pgfmathresult\relax%
+	\ifnum\c@pgf@countc<0
+		\advance\c@pgf@countc by \pgfintersectionsegments\relax
+	\fi
+	\expandafter\let\expandafter\pgfretval\csname pgf@intersect@path@split@\pgf@insert@intersections@src @\the\c@pgf@countc\endcsname
+	\ifx\pgfretval\relax
+		\pgferror{There is no intersection segment '#2' in path '#1'}%
+	\fi
+}%
+\def\pgfcomputeintersectionsegments@set@src@gobble#1\relax{}
+
+\def\pgfcomputeintersectionsegments@set@src#1{%
+	\ifcase#1\relax
+		% 0
+		\pgferror{illegal argument supplied.}
+	\or
+		\def\pgf@insert@intersections@src{a}%
+	\or
+		\def\pgf@insert@intersections@src{b}%
+	\else
+		\pgferror{illegal argument supplied.}
+	\fi
+}%
+
+\def\pgfintersectionsolutionsortbytime@@{%
+	% this is an O(n^2) sort method. It might suffice provided that
+	% the number of intersections is small... and it is the same
+	% runtime as that of the intersection lib as such (which is, in
+	% fact, worse).
+	%
+	% Note that this bubble-sort-approach has the benefit that if the
+	% input sequence *is* actually sorted, that it will have no effect
+	% at all (linear time).
+	\pgf@intersect@solutions@sortfinishtrue%
+	\pgfmathloop%
+		\ifnum\pgfmathcounter<\pgfintersectionsolutions\relax%
+			\pgfutil@tempcnta=\pgfmathcounter%
+			\advance\pgfutil@tempcnta by1\relax%
+			%
+			% acquire the sort keys...
+			\pgfintersectiongetsolutiontimes{\pgfmathcounter}{\pgf@loc@tmp@A@a}{\pgf@loc@tmp@A@b}%
+			\pgfintersectiongetsolutiontimes{\the\pgfutil@tempcnta}{\pgf@loc@tmp@B@a}{\pgf@loc@tmp@B@b}%
+			%
+			\ifdim\csname pgf@loc@tmp@A@\pgf@insert@intersections@src\endcsname pt>%
+				\csname pgf@loc@tmp@B@\pgf@insert@intersections@src\endcsname pt\relax%
+				\pgf@intersect@solutions@sortfinishfalse%
+				%
+				\pgfintersectionsolutionsortbytime@swap{pgfpoint@intersect@solution@\pgfmathcounter}%
+					{pgfpoint@intersect@solution@\the\pgfutil@tempcnta}%
+				%
+				\pgfintersectionsolutionsortbytime@swap{pgf@intersect@solution@props@\pgfmathcounter}%
+					{pgf@intersect@solution@props@\the\pgfutil@tempcnta}%
+			\fi%
+	\repeatpgfmathloop%
+	\ifpgf@intersect@solutions@sortfinish%
+	\else%
+		\expandafter\pgfintersectionsolutionsortbytime@@%
+	\fi%
+}
+
+
+% #1: either 'a' or 'b', depending on the required part
+% #2: the solution index (starting with 1)
+% Defines \pgfretval to contain the result.
+\def\pgf@fillbetween@get@time@off#1#2{%
+	\pgfintersectiongetsolutionsegmentindices{#2}{\pgf@temp@a}{\pgf@temp@b}%
+	\edef\pgfretval{\csname pgf@temp@#1\endcsname}%
+}%
+
+% ----------------------------------------------------------------------------------
+
+
+% Splits a Bezier curve at a designated time 't'
+% using decasteljau
+%--------------------------------------------------
+% Point lerp(float t, Point A, Point B) {
+% return A*(1-t) + B*t; // + and * overloaded for Points
+% }
+%
+% void split(t, Point P[4], Point L[4], Point R[4]) {
+% 	Point P01 = lerp(t, P[0], P[1]);
+% 	Point P12 = lerp(t, P[1], P[2]);
+% 	Point P23 = lerp(t, P[2], P[3]);
+% 	Point P012 = lerp(t, P01, P12);
+% 	Point P123 = lerp(t, P12, P13);
+% 	Point Q = lerp(t, P012, P123);
+% 	L[0] = P[0]; L[1] = P01; L[2] = P012; L[3] = Q;
+% 	R[0] = Q;
+% 	R[1] = P123; R[2] = P23; R[3] = P[3];
+% }
+%--------------------------------------------------
+% INPUT:
+%  #1: a value in the range [0,1] which determines the split point
+%  #2,#3,#4,#5: the points of the curve, each of the form {<x>}{<y>}
+%
+% OUTPUT:
+%  \pgfretval@L{{<A>}{<B>}{<C>}{<D>}}
+%  \pgfretval@R{{<A>}{<B>}{<C>}{<D>}}
+%
+% @see \pgf@split@curveto@softpaths
+\def\pgf@split@curveto#1#2#3#4#5{%
+	\begingroup
+	\pgf@xa=-#1pt %
+	\advance\pgf@xa by1pt %
+	\edef\pgf@split@one@m@t{\pgf@sys@tonumber\pgf@xa}%
+	%
+	\pgf@split@curveto@lerp{#1}{\pgf@split@one@m@t}{#2}{#3}%
+	\pgf@split@curveto@tomacro\pgf@split@curveto@p@AB
+	%
+	\pgf@split@curveto@lerp{#1}{\pgf@split@one@m@t}{#3}{#4}%
+	\pgf@split@curveto@tomacro\pgf@split@curveto@p@BC
+	%
+	\pgf@split@curveto@lerp{#1}{\pgf@split@one@m@t}{#4}{#5}%
+	\pgf@split@curveto@tomacro\pgf@split@curveto@p@CD
+	%
+	\pgf@split@curveto@lerp{#1}{\pgf@split@one@m@t}{\pgf@split@curveto@p@AB}{\pgf@split@curveto@p@BC}%
+	\pgf@split@curveto@tomacro\pgf@split@curveto@p@ABC
+	%
+	\pgf@split@curveto@lerp{#1}{\pgf@split@one@m@t}{\pgf@split@curveto@p@BC}{\pgf@split@curveto@p@CD}%
+	\pgf@split@curveto@tomacro\pgf@split@curveto@p@BCD
+	%
+	\pgf@split@curveto@lerp{#1}{\pgf@split@one@m@t}{\pgf@split@curveto@p@ABC}{\pgf@split@curveto@p@BCD}%
+	\pgf@split@curveto@tomacro\pgf@split@curveto@p@Q
+	%
+	\xdef\pgf@marshal{%
+		\edef\noexpand\pgfretval@L{{#2}{\pgf@split@curveto@p@AB}{\pgf@split@curveto@p@ABC}{\pgf@split@curveto@p@Q}}%
+		\edef\noexpand\pgfretval@R{{\pgf@split@curveto@p@Q}{\pgf@split@curveto@p@BCD}{\pgf@split@curveto@p@CD}{#5}}%
+	}%
+	\endgroup
+	\pgf@marshal
+}
+
+% Splits a Bezier curve at a designated time 't'
+%
+% This variants takes a part of a softpath as input:
+%
+% #1: a curveto- a macro containing a softpath of the form
+%   <x><y>\pgfsyssoftpath@curvetosupportatoken<x><y>\pgfsyssoftpath@curvetosupportbtoken<x><y>\pgfsyssoftpath@curvetotoken<x><y>
+% #2: t in [0,1]
+%
+% OUTPUT: \pgfretval@L contains the LEFT segment (in the same softpath format) and \pgfretval@R contains the RIGHT segment (in the softpath format), \pgfretval contains the intersection point (i.e. the point evaluated at 't')
+\def\pgf@split@curveto@softpaths#1#2{%
+	\expandafter\pgf@split@curveto@softpaths@#1{#2}%
+}
+
+\def\pgf@split@curveto@softpaths@#1#2\pgfsyssoftpath@curvetosupportatoken#3#4\pgfsyssoftpath@curvetosupportbtoken#5#6\pgfsyssoftpath@curvetotoken#7#8#9{%
+	\pgf@split@curveto{#9}%
+		{{#1}{#2}}%
+		{{#3}{#4}}%
+		{{#5}{#6}}%
+		{{#7}{#8}}%
+	\expandafter\pgf@split@curveto@softpaths@@\pgfretval@L\pgfretval@L
+	\expandafter\pgf@split@curveto@softpaths@@\pgfretval@R\pgfretval@R
+}%
+
+\def\pgf@split@curveto@softpaths@@#1#2#3#4#5{%
+	% we can silently omit the moveto component.
+	\def#5{\pgfsyssoftpath@curvetosupportatoken#2\pgfsyssoftpath@curvetosupportbtoken#3\pgfsyssoftpath@curvetotoken#4}%
+	\def\pgfretval{#1}%
+}%
+
+% ----------------------------------------------------------------------------------
+
+% defines \pgf@x, \pgf@y to be A*(1-t) + B*t
+% #1: the scalar value 't' in [0,1]
+% #2: the scalar value '1-t' in [0,1]
+% #3: a 2d point 'A' of the form {<x>}{<y>}
+% #4: a 2d point 'B' of the form {<x>}{<y>}
+\def\pgf@split@curveto@lerp#1#2#3#4{%
+	\pgfpointadd
+		{\pgfqpointscale{#2}{\expandafter\pgfqpoint#3}}%
+		{\pgfqpointscale{#1}{\expandafter\pgfqpoint#4}}%
+}%
+
+\def\pgf@split@curveto@tomacro#1{%
+	\edef#1{{\the\pgf@x}{\the\pgf@y}}%
+}
+
+
+\def\pgfcomputeintersectionsegments@@{%
+%\message{processing segment \the\c@pgf@path@segment\space (current solution \pgf@insert@cursolution/\pgfintersectionsolutions; target segment \the\c@pgf@path@segment@trg, currentxy \pgfinsert@intersect@tok@currentxy, lastxy \pgfinsert@intersect@tok@lastxy)^^J}%
+	\pgfmathloop
+	% we need to loop: it is fully acceptable if more than one
+	% solution is on the same segment.
+	\ifnum\c@pgf@path@segment=\c@pgf@path@segment@trg
+		%
+		\pgf@insert@intersections@split@segment
+		\expandafter\pgfapplistpushback\pgfretval\to{pgfretval@tmp}%
+		%
+		%
+		% report the current result segment!
+		\pgfapplistlet\pgf@loc@TMPa={pgfretval@tmp}%
+		\expandafter\let\csname pgf@intersect@path@split@\pgf@insert@intersections@src @\c@pgf@path@result\endcsname=\pgf@loc@TMPa%
+		\pgfutil@advancestringcounter\c@pgf@path@result%
+		% ... and start a new result segment. Keep in mind that it
+		% should start with a moveto:
+		\pgfapplistnewempty{pgfretval@tmp}%
+		\csname pgfpoint@intersect@solution@\pgf@insert@cursolution\endcsname%
+		\edef\pgf@loc@TMPa{\noexpand\pgfsyssoftpath@movetotoken{\the\pgf@x}{\the\pgf@y}}%
+		\expandafter\pgfapplistpushback\pgf@loc@TMPa\to{pgfretval@tmp}%
+		%
+		%
+		% OK, iterate:
+		\ifnum\pgf@insert@cursolution=\pgfintersectionsolutions\relax
+			% collect all remaining ones:
+			\c@pgf@path@segment@trg=10000000 %
+		\else
+			\pgfutil@advancestringcounter\pgf@insert@cursolution
+			\pgf@fillbetween@get@time@off{\pgf@insert@intersections@src}{\pgf@insert@cursolution}%
+			\c@pgf@path@segment@trg=\pgfretval\relax
+		\fi
+	\repeatpgfmathloop
+	\expandafter\pgfapplistpushback\pgfinsert@intersect@tok\to{pgfretval@tmp}%
+	\let\pgfinsert@intersect@tok@lastxy=\pgfinsert@intersect@tok@currentxy
+	\advance\c@pgf@path@segment by1 %
+}%
+
+% INPUT:
+%  - \pgfinsert@intersect@tok@type is the current type (one of \pgfsyssoftpath@linetotoken or \pgfsyssoftpath@curvetotoken)
+%  - \pgf@insert@cursolution is the current intersection index
+%  - \pgfinsert@intersect@tok is the current path segment. On output, it is the *remaining* path segment.
+%  - \pgfinsert@intersect@tok@lastxy the (x,y) coordinates of the last seen coordinate.
+%
+% OUTPUT:
+%  - \pgfretval the segment which has been splitted off. It will be appended to the result.
+%  - \pgfinsert@intersect@tok the remaining path segment which is to be processed
+%  - \pgfinsert@intersect@tok@lastxy the (x,y) coordinates of the last seen coordinate which is to be processed.
+\def\pgf@insert@intersections@split@segment{%
+	\ifx\pgfinsert@intersect@tok@type\pgfsyssoftpath@linetotoken
+		\csname pgfpoint@intersect@solution@\pgf@insert@cursolution\endcsname%
+		\edef\pgfretval{\noexpand\pgfsyssoftpath@linetotoken{\the\pgf@x}{\the\pgf@y}}%
+		% ... and keep \pgfinsert@intersect@tok at its current value (it is \pgfsyssoftpath@linetotoken{<next x>}{<next y>})
+	\else
+		\ifx\pgfinsert@intersect@tok@type\pgfsyssoftpath@curvetotoken
+			% Ah; a curveto. That's more involved!
+			% First, get the time offset of the current intersection:
+			%
+			% Get the global time:
+			\pgfintersectiongetsolutiontimes{\pgf@insert@cursolution}{\pgf@split@it@time@a}{\pgf@split@it@time@b}%
+			% Get time at the beginning of the current solution segment:
+			\pgfintersectiongetsolutionsegmentindices{\pgf@insert@cursolution}{\pgf@split@it@timeoff@a}{\pgf@split@it@timeoff@b}%
+			% compute local time within the current solution segment:
+			\pgf@xa=\csname pgf@split@it@time@\pgf@insert@intersections@src\endcsname pt %
+			\advance\pgf@xa by-\csname pgf@split@it@timeoff@\pgf@insert@intersections@src\endcsname pt %
+			\edef\pgf@split@it@time{\pgf@sys@tonumber\pgf@xa}%
+			%
+			\let\pgf@split@it@start=\pgfinsert@intersect@tok@lastxy
+			% we have to insert the last XY coordinates:
+			\t@pgf@toka=\expandafter{\pgf@split@it@start}%
+			\t@pgf@tokb=\expandafter{\pgfinsert@intersect@tok}%
+			\edef\pgf@temp{\the\t@pgf@toka\the\t@pgf@tokb}%
+			% Split into TWO curveto operations!
+			\pgf@split@curveto@softpaths{\pgf@temp}{\pgf@split@it@time}%
+			% ok, the first returned sub-curveto is the result of this method...
+			\let\pgfretval=\pgfretval@L
+			% ... and the second is the "remainder" which is still to be processed.
+			\let\pgfinsert@intersect@tok=\pgfretval@R
+		\else
+			\pgferror{Unsupported path type \meaning\pgfinsert@intersect@tok@type. Cannot process these paths.}%
+		\fi
+	\fi
+	%
+	\csname pgfpoint@intersect@solution@\pgf@insert@cursolution\endcsname%
+	\edef\pgfinsert@intersect@tok@lastxy{{\the\pgf@x}{\the\pgf@y}}%
+}%
+
+\def\pgf@insert@intersections@loop#1{%
+	\ifx#1\pgf@stop%
+		\let\pgfinsert@intersect@tok\pgfutil@empty%
+		\let\pgfinsert@intersect@tok@type\pgfutil@empty
+		\pgfcomputeintersectionsegments@@%
+		\let\pgfinsert@intersect@next=\relax%
+	\else%
+		\ifx#1\pgfsyssoftpath@movetotoken%
+			\let\pgfinsert@intersect@next=\pgfinsert@intersect@token@moveto%
+		\else%
+			\ifx#1\pgfsyssoftpath@linetotoken%
+				\let\pgfinsert@intersect@next=\pgfinsert@intersect@token@lineto%
+			\else%
+				\ifx#1\pgfsyssoftpath@closepathtoken%
+					\let\pgfinsert@intersect@next=\pgfinsert@intersect@token@close%
+				\else%
+					\ifx#1\pgfsyssoftpath@curvetosupportatoken%
+						\let\pgfinsert@intersect@next=\pgfinsert@intersect@token@curveto%
+					\else%
+						\ifx#1\pgfsyssoftpath@rectcornertoken%
+							\let\pgfinsert@intersect@next=\pgfinsert@intersect@token@rect%
+						\fi%
+					\fi%
+				\fi%
+			\fi%
+		\fi%
+	\fi%
+	\pgfinsert@intersect@next}
+
+\def\pgfinsert@intersect@token@moveto#1#2{%
+	\def\pgfinsert@intersect@tok{\pgfsyssoftpath@movetotoken{#1}{#2}}%
+	\let\pgfinsert@intersect@tok@type\pgfsyssoftpath@movetotoken
+	\def\pgfinsert@intersect@tok@lastxy{{#1}{#2}}%
+	\expandafter\pgfapplistpushback\pgfinsert@intersect@tok\to{pgfretval@tmp}%
+	\pgf@insert@intersections@loop%
+}
+
+\def\pgfinsert@intersect@token@lineto#1#2{%
+	\def\pgfinsert@intersect@tok{\pgfsyssoftpath@linetotoken{#1}{#2}}%
+	\let\pgfinsert@intersect@tok@type\pgfsyssoftpath@linetotoken
+	\def\pgfinsert@intersect@tok@currentxy{{#1}{#2}}%
+	\pgfcomputeintersectionsegments@@%
+	\pgf@insert@intersections@loop
+}
+\def\pgfinsert@intersect@token@close#1#2{%
+	\def\pgfinsert@intersect@tok{\pgfsyssoftpath@closepathtoken{#1}{#2}}%
+	\let\pgfinsert@intersect@tok@type\pgfsyssoftpath@linetotoken
+	\def\pgfinsert@intersect@tok@currentxy{{#1}{#2}}%
+	\pgfcomputeintersectionsegments@@%
+	\pgf@insert@intersections@loop
+}
+
+\def\pgfinsert@intersect@token@curveto#1#2\pgfsyssoftpath@curvetosupportbtoken#3#4\pgfsyssoftpath@curvetotoken#5#6{%
+	\def\pgfinsert@intersect@tok{\pgfsyssoftpath@curvetosupportatoken{#1}{#2}\pgfsyssoftpath@curvetosupportbtoken{#3}{#4}\pgfsyssoftpath@curvetotoken{#5}{#6}}%
+	\let\pgfinsert@intersect@tok@type\pgfsyssoftpath@curvetotoken
+	\def\pgfinsert@intersect@tok@currentxy{{#5}{#6}}%
+	\pgfcomputeintersectionsegments@@%
+	\pgf@insert@intersections@loop
+}
+
+\def\pgfinsert@intersect@token@rect#1#2\pgfsyssoftpath@rectsizetoken#3#4{%
+	\pgf@xa=#1\relax%
+	\advance\pgf@xa by#3\relax%
+	\pgf@ya=#2\relax%
+	\advance\pgf@ya by#4\relax%
+	\edef\pgf@marshal{%
+		\noexpand\pgfsyssoftpath@movetotoken{#1}{#2}%
+		\noexpand\pgfsyssoftpath@linetotoken{#1}{\the\pgf@ya}%
+		\noexpand\pgfsyssoftpath@linetotoken{\the\pgf@xa}{\the\pgf@ya}%
+		\noexpand\pgfsyssoftpath@linetotoken{\the\pgf@xa}{#2}%
+		\noexpand\pgfsyssoftpath@closepathtoken{#1}{#2}%
+	}%
+	\expandafter\pgf@insert@intersections@loop\pgf@marshal%
+}
+
+
+% #1: a macro containing the clip path. More precisely, it is supposed to be a return value of \pgfgetpath.
+\def\pgffillbetweensetsoftclippathfirst#1{%
+	\let\pgfpathfillbetween@softclip@A=#1%
+}%
+
+% #1: a macro containing the clip path. More precisely, it is supposed to be a return value of \pgfgetpath.
+\def\pgffillbetweensetsoftclippathsecond#1{%
+	\let\pgfpathfillbetween@softclip@B=#1%
+}%
+
+% #1: a macro containing the clip path. More precisely, it is supposed to be a return value of \pgfgetpath.
+\def\pgffillbetweensetsoftclippath#1{%
+	\pgffillbetweensetsoftclippathfirst{#1}%
+	\pgffillbetweensetsoftclippathsecond{#1}%
+}
+
+% Default: no clip paths
+\pgffillbetweensetsoftclippathfirst{\pgfutil@empty}
+\pgffillbetweensetsoftclippathsecond{\pgfutil@empty}
+\endinput