##################################################################
# Modul fuer Koordinaten-Achsen
#
# Letzte Aenderung: 10.01.2012
##################################################################<>
use POSIX qw /floor ceil/;
use Math::Trig;
use strict;
use warnings;
my (
	$xachsetrue, $yachsetrue, $xminachse, $yminachse, $xmaxachse,
	$ymaxachse,  $xschritt,   $yschritt,  $xskala,    $yskala,
	$xtext,      $ytext,      $xmark,     $ymark,     $zmark
);

$xachsetrue = $yachsetrue = 0;
##################################################################
# Achsen zeichnen:
# wurden die einzelnen Achsen schon aufgerufen?
# Wurden die Achsen gezeichnet?
##################################################################
sub achsengezeichnet {
	my ($xodery) = @_;
	if ( $xodery eq "x" ) {
		if   ( getachsenzeichnen("x") == 0 ) { return 0; }
		else                                 { return 1; }
	}
	elsif ( $xodery eq "y" ) {
		if   ( getachsenzeichnen("y") == 0 ) { return 0; }
		else                                 { return 1; }
	}
	else { return "ERROR"; }
}

my $achsenart = "->";

sub setachsenart {
	my ($achsenarthier) = @_;
	$achsenart = $achsenarthier;
}

my $subticks = 0;

sub setsubticks {
	my ($ticks) = @_;
	$subticks = $ticks;
}

sub getsubticks { return $subticks; }

sub getachsenart { return $achsenart; }

sub setachsenzeichnen {
	my ( $wert, $xodery ) = @_;
	if ( $xodery eq "x" ) { $xachsetrue = $wert; }
	if ( $xodery eq "y" ) { $yachsetrue = $wert; }
}

sub getachsenzeichnen {
	my ($xodery) = @_;
	if ( $xodery eq "x" ) { return $xachsetrue; }
	if ( $xodery eq "y" ) { return $yachsetrue; }
}

$xmark = $ymark = $zmark = "";

sub setmarkierung {
	my ( $wert, $xyz ) = @_;
	if ( $xyz eq "x" ) { $xmark = $wert; }
	if ( $xyz eq "y" ) { $ymark = $wert; }
	if ( $xyz eq "z" ) { $zmark = $wert; }
}

sub getmarkierung {
	my ($xyz) = @_;
	if ( $xyz eq "x" ) { return $xmark; }
	if ( $xyz eq "y" ) { return $ymark; }
	if ( $xyz eq "z" ) { return $zmark; }
}

sub setschritt {
	my ( $schritt, $xodery ) = @_;
	if ( $xodery eq "x" ) { $xschritt = $schritt; }
	if ( $xodery eq "y" ) { $yschritt = $schritt; }
}

sub getschritt {
	my ($xodery) = @_;
	if ( $xodery eq "x" ) { return $xschritt; }
	if ( $xodery eq "y" ) { return $yschritt; }
}

sub setskala {
	my ( $schritt, $xodery ) = @_;
	if ( $xodery eq "x" ) { $xskala = $schritt; }
	if ( $xodery eq "y" ) { $yskala = $schritt; }
}

sub getskala {
	my ($xodery) = @_;
	if ( $xodery eq "x" ) { return $xskala; }
	if ( $xodery eq "y" ) { return $yskala; }
}

sub settext {
	my ( $schritt, $xodery ) = @_;
	if ( $xodery eq "x" ) { $xtext = $schritt; }
	if ( $xodery eq "y" ) { $ytext = $schritt; }
}

sub gettext {
	my ($xodery) = @_;
	if ( $xodery eq "x" ) { return $xtext; }
	if ( $xodery eq "y" ) { return $ytext; }
}

sub setminmaxachsen {
	my ( $min, $xodery, $minmax ) = @_;
	if ( $xodery eq "x" ) {
		if   ( $minmax eq "min" ) { $xminachse = $min; }
		else                      { $xmaxachse = $min; }
	}
	if ( $xodery eq "y" ) {
		if   ( $minmax eq "min" ) { $yminachse = $min; }
		else                      { $ymaxachse = $min; }
	}
}
##################################################################
# Wie ist das Minimum und Maximum?
##################################################################
sub getminmaxachsen {
	my ( $xodery, $minmax ) = @_;
	if ( $xodery eq "x" ) {
		if   ( $minmax eq "min" ) { return $xminachse; }
		else                      { return $xmaxachse; }
	}
	if ( $xodery eq "y" ) {
		if   ( $minmax eq "min" ) { return $yminachse; }
		else                      { return $ymaxachse; }
	}
}

my ( $xmitte, $ymitte );
$xmitte = $ymitte = 0;

sub setmitte { $xmitte = $ymitte = 1; }

sub achsenbeschriftung {
	my ( $layer, $farbe, $xmax, $ymax, $xtext, $ytext ) = @_;

	if ( $xmitte == 0 ) {
		beschriftung( $layer, $farbe, $xmax, getschnitt("y") - 0.6 / getskalierung("y"),
			0, 180, $xtext );
	}
	else {
		beschriftung(
			$layer, $farbe,
			getschnitt("x") + ( $xmax - getschnitt("x") ) / 2,
			getschnitt("y") - 1 / getskalierung("y"),
			0, "c", $xtext
		);
	}
	if ( $ymitte == 0 ) {
		beschriftung(
			$layer, $farbe,
			getschnitt("x") + 0.2 / getskalierung("x"),
			$ymax - 0.2 / getskalierung("y"),
			0, 0, $ytext
		);
	}
	else {
		beschriftung(
			$layer, $farbe,
			getschnitt("x") - 1.2 / getskalierung("x"),
			getschnitt("y") + ( $ymax - getschnitt("y") ) / 2,
			90, "c", $ytext
		);
	}

}

my $pfeilartachsen = "->";

sub setpfeilart {
	my ($art) = @_;
	$pfeilartachsen = $art;
}

sub getpfeilart { return $pfeilartachsen; }

sub xachse {
	my (
		$layer,     $farbe,    $linienstaerke, $linienart, $xminachse,
		$xmaxachse, $xschritt, $xskala,        $xtext
	) = @_;

	if ( achsengezeichnet("y") == 0 ) {
		schnittsetzen( $xminachse, "x" );
	}
	minmax( $xminachse - $xschritt, -1, $xmaxachse + $xschritt, 1 );
	achsen(
		$layer,     $farbe,  $linienstaerke, $linienart, getpfeilart(), $xminachse,
		$xmaxachse, 0,       0,              $xschritt,  $xskala,       $xtext,
		0,          "keine", ""
	);
}

##################################################################
# die y-Achse wird gezeichnet
##################################################################
sub yachse {
	my (
		$layer,     $farbe,    $linienstaerke, $linienart, $yminachse,
		$ymaxachse, $yschritt, $yskala,        $ytext
	) = @_;

	minmax( -1, $yminachse - $yschritt, 1, $ymaxachse + $yschritt );

	achsen(
		$layer,    $farbe,     $linienstaerke, $linienart, getpfeilart(), 0,
		0,         $yminachse, $ymaxachse,     0,          $yskala,       "",
		$yschritt, $yskala,    $ytext
	);

}

my ( $ystep, $xstep );

$ystep = $xstep = 1;

sub achsen {
	my (
		$layer,     $farbe,     $linienstaerke, $linienart, $pfeilart,
		$xminachse, $xmaxachse, $yminachse,     $ymaxachse, $xschritt,
		$xskala,    $xtext,     $yschritt,      $yskala,    $ytext
	) = @_;

	minmax(
		$xminachse - $xschritt,
		$yminachse - $yschritt,
		$xmaxachse + $xschritt,
		$ymaxachse + $yschritt
	);

	$ystep = $yschritt;
	$xstep = $xschritt;

	if ( getmatheheft() == 1 ) {
		setmatheheft(2);
		matheheft( $layer, "lightgray", $xminachse, $yminachse, $xmaxachse, $ymaxachse );
	}

	if ( getgitter() == 1 ) {
		setgitter(2);
		kariert(
			1,     "lightgray", 0.25,      "solid", $xminachse, $yminachse,
			$xmaxachse, $ymaxachse,  $xschritt, 0,       0,          $yschritt,
			0,          0
		);
	}

	my ( $parameterweiter, $achsen );

	if ( $xminachse != $xmaxachse ) {
		if ( $xschritt == 0 ) {
			$xschritt = aufrunden( $xmaxachse * 10000, 1 ) / 10000;
			$xschritt = schoenetabelle( $xmaxachse * 10000 ) / 10000;
		}
	}

	if ( $yminachse != $ymaxachse ) {
		if ( $yschritt == 0 ) {
			$yschritt = aufrunden( $ymaxachse * 10000, 1 ) / 10000;
			$yschritt = schoenetabelle( $ymaxachse * 10000 ) / 10000;
		}
	}

	if ( $xminachse == $xmaxachse ) {
		$achsen = "xAxis=false, showorigin=true,";
	}
	elsif ( $yminachse == $ymaxachse ) {
		$achsen = "yAxis=false, showorigin=true, ";
	}
	else { $achsen = "showorigin=false,"; }
	setgrossskalierung( $xmaxachse - $xminachse, $ymaxachse - $yminachse );
	if ( $linienart eq "" ) { $linienart = "solid"; }
	if ( $xskala eq "keine" ) {

		$parameterweiter =
		    $achsen
		  . "comma, ticks=none, labels=none, subticks= "
		  . getsubticks() . ", Dx="
		  . $xschritt . ", Dy="
		  . $yschritt
		  . ", dx=0pt, dy=0pt, Ox="
		  . getschnitt("x") . ", Oy="
		  . getschnitt("y");

	}
	elsif ( $xskala eq "nurstriche" ) {
		$parameterweiter =
		    $achsen
		  . "comma, labels=none, subticks="
		  . getsubticks() . ", Dx="
		  . $xschritt . ", Dy="
		  . $yschritt
		  . ", dx=0pt, dy=0pt, Ox="
		  . getschnitt("x") . ", Oy="
		  . getschnitt("y");

	}
	elsif ( $xskala eq "nureins" ) {
		xmarkierung( $layer, 1, 1, $farbe );
		ymarkierung( $layer, 1, 1, $farbe );
		$parameterweiter =
		    $achsen
		  . "comma, labels=none, subticks=0, Dx="
		  . $xschritt . ", Dy="
		  . $yschritt
		  . ", dx=0pt, dy=0pt, Ox="
		  . getschnitt("x") . ", Oy="
		  . getschnitt("y");

	}
	else {
		$parameterweiter =
		    $achsen
		  . "comma, subticks="
		  . getsubticks() . ", Dx="
		  . $xschritt . ", Dy="
		  . $yschritt
		  . ", dx=0pt, dy=0pt, Ox="
		  . getschnitt("x") . ", Oy="
		  . getschnitt("y");
	}

	if ( $xmitte == 1 ) {
		achsenbeschriftung( $layer, $farbe, $xmaxachse, $ymaxachse, $xtext, $ytext );
	}

	paar( getschnitt("x"), getschnitt("y") );
	paar( $xminachse,      $yminachse );

	paar( $xmaxachse, $ymaxachse );

	if ( $xmitte == 0 ) {
		textanhaengen( "[" . $xtext . ",-90][" . $ytext . ",0]" );
	}

	if ( $linienstaerke > 0 ) {
		befehlerzeugen( $layer, "psaxes", $farbe, $linienart, $linienstaerke, $parameterweiter,
			$pfeilart, gettexthier() );
	}

	settexthier("");

	setachsengraph( $xminachse, $yminachse, $xmaxachse, $ymaxachse );

	if ( $xskala eq "keine" ) {
		minmax( $xminachse, $yminachse, $xmaxachse, $ymaxachse );
	}
	else {
		minmax(
			$xminachse - $xschritt * 2,
			$yminachse - $yschritt * 2,
			$xmaxachse + $xschritt * 2,
			$ymaxachse + $yschritt * 2
		);
	}
}

sub schoenetabelle {
	my ($obergrenze) = @_;

	my (
		$schoen1,    $schoen2,     $schoen3,  $kriterium1, $kriterium2,
		$skalierung, $breite,      $kandidat, $schritt,    $skalenstrich,
		$basis,      $skalierung2, $i,        $schoenerschritt
	);

	$schoen1         = 1;
	$schoen2         = 2;
	$schoen3         = 5;
	$kriterium1      = 5;
	$kriterium2      = 12.5;
	$schoenerschritt = 0;

	$skalierung = 10**floor( logarithmus( $obergrenze, 10 ) );

	$breite = $obergrenze / $skalierung;

	if ( $breite >= $schoen3 ) { $kandidat = $schoen3; }
	else {
		if   ( $breite >= $schoen2 ) { $kandidat = $schoen2; }
		else                         { $kandidat = $schoen1; }
	}
	$skalierung2 = $skalierung;
	$basis       = $kandidat;
	for ( $i = 1 ; $i <= 15 ; $i++ ) {

		$schritt      = $skalierung2 * $basis;
		$skalenstrich = $obergrenze / $schritt;

		if (   ( $skalenstrich > $kriterium1 )
			&& ( $skalenstrich < $kriterium2 ) )
		{
			$schoenerschritt = $schritt;
		}

		if   ( $basis == 1 ) { $skalierung2 = $skalierung2 / 10; }
		else                 { $skalierung2 = $skalierung2; }
		if ( $basis == $schoen3 ) { $basis = $schoen2; }
		else {
			if   ( $basis == $schoen2 ) { $basis = $schoen1; }
			else                        { $basis = $schoen3; }
		}
	}

	return $schoenerschritt;

}

##################################################################
# Achsen mit Bogenmass
##################################################################
sub xachserad {
	my ( $layer, $farbe, $linienstaerke, $linienart, $xminachse, $xmaxachse, $xschritt, $xtext ) =
	  @_;
	minmax( $xminachse - $xschritt, -1, $xmaxachse + $xschritt, 1 );

	xyachserad( $layer, $farbe, $linienstaerke, $linienart, $xminachse, $xmaxachse, 0, 0, $xschritt,
		$xtext, 0, 0, "", 1, "rad" );

}

sub xyachserad {
	my (
		$layer,     $farbe,     $linienstaerke, $linienart, $xminachse,
		$xmaxachse, $yminachse, $ymaxachse,     $xschritt,  $xtext,
		$yschritt,  $yskala,    $ytext,         $xbruch,    $rad
	) = @_;

	my ( $label, $i, $mark, $zahl, $pi, $grad );

	if ( $rad eq "deg" ) {
		$label     = degtorad($xschritt);
		$xminachse = degtorad($xminachse);
		$xmaxachse = degtorad($xmaxachse);
		$grad      = "deg";
	}
	elsif ( $rad eq "rad" ) {
		$label     = $xschritt;
		$xminachse = $xminachse;
		$xmaxachse = $xmaxachse;
		$grad      = "rad";
	}
	elsif ( $rad eq "degtorad" ) {
		$label     = degtorad($xschritt);
		$xminachse = degtorad($xminachse);
		$xmaxachse = degtorad($xmaxachse);
		$grad      = "rad";
	}
	else {
		$label     = $xschritt;
		$xminachse = $xminachse;
		$xmaxachse = $xmaxachse;
		$grad      = "deg";
	}

	$pi = degtorad(180);

	achsen(
		$layer,     $farbe,         $linienstaerke, $linienart,
		"->",       $xminachse,     $xmaxachse,     $yminachse,
		$ymaxachse, $xmaxachse * 2, $yskala,        $xtext,
		$yschritt,  $yskala,        $ytext
	);

	for ( $i = 0 ; $i < $xmaxachse ; $i = $i + $label ) {
		if ( $i != 0 ) {

			if ( $xbruch == 1 ) {
				if ( $grad eq "deg" ) {
					$zahl = radtodeg($i);
					$mark = "\$" . $zahl . "\^{\\circ}\$";
					$mark =~ tr/./,/s;
				}
				else {
					$zahl = $i / $pi;
					$mark = "\$" . $zahl . "\\pi\$";
					$mark =~ tr/./,/s;
				}
			}
			else {

				if ( $grad eq "deg" ) {
					$zahl = radtodeg( $i * $xbruch );
					$mark = "\$" . $zahl . "\^{\\circ}\$";
					$mark =~ tr/./,/s;
				}
				else {
					$zahl = $i / $pi * $xbruch;
					$mark = "\$\\frac{" . $zahl . "}{" . $xbruch . "}\\pi\$";
					$mark =~ tr/./,/s;
				}

			}
			xmarkierung( $layer, $i, $mark, $farbe );
		}
	}

	for ( $i = 0 ; $i > $xminachse ; $i = $i - $label ) {
		if ( $i != 0 ) {

			if ( $xbruch == 1 ) {
				if ( $grad eq "deg" ) {
					$zahl = abs( radtodeg($i) );
					$mark = "\$-" . $zahl . "\^{\\circ}\$";
					$mark =~ tr/./,/s;
				}
				else {
					$zahl = abs( $i / $pi );
					$mark = "\$-" . $zahl . "\\pi\$";
					$mark =~ tr/./,/s;
				}
			}
			else {

				if ( $grad eq "deg" ) {
					$zahl = abs( radtodeg( $i * $xbruch ) );
					$mark = "\$-" . $zahl . "\^{\\circ}\$";
					$mark =~ tr/./,/s;
				}
				else {
					$zahl = abs( $i / $pi * $xbruch );
					$mark = "\$-\\frac{" . $zahl . "}{" . $xbruch . "}\\pi\$";
					$mark =~ tr/./,/s;
				}

			}
			xmarkierung( $layer, $i, $mark, $farbe );
		}
	}
}

##################################################################
### Markierungen an den Achsen
##################################################################

my $xmarkierungkopf = 0;

sub xmarkierung {
	my ( $layer, $x, $text, $farbe ) = @_;
	minmax( $x, -$ystep / getskalierung("y"), $x, $ystep / getskalierung("y") );

	$text =~ tr/./,/s;
	if ( $xmarkierungkopf == 0 ) {
		pstricks(
			105, "\\makeatletter\\newcommand{\\psxpoint}[3][black]{%
 \\psline[linewidth=.5pt,linecolor=#1]{-}(#2,\\pst\@xticksizeB)(#2,\\pst\@xticksizeA)
 \\rput[t](! #2 \\pst\@number\\pslabelsep \\pst\@number\\pst\@xticksizeB add
 \\pst\@number\\psyunit div neg ){\\color{#1}#3}}
\\makeatother \n"
		);
		$xmarkierungkopf = 1;
	}
	if ( $farbe eq "black" ) {
		schreibeinarray( $layer, sprintf( "\\psxpoint{%g}{%s}", $x, $text ) );
	}
	else {
		schreibeinarray( $layer, sprintf( "\\psxpoint[%s]{%g}{%s}", $farbe, $x, $text ) );
	}

}

my $xmarkierungkopfohne = 0;

sub xmarkierungohne {
	my ( $layer, $x, $text, $farbe ) = @_;
	minmax( $x, -$ystep / getskalierung("y"), $x, $ystep / getskalierung("y") );

	$text =~ tr/./,/s;
	if ( $xmarkierungkopfohne == 0 ) {
		pstricks(
			105, "\\makeatletter\\newcommand{\\psxpointohne}[3][black]{%
 \\rput[t](! #2 \\pst\@number\\pslabelsep \\pst\@number\\pst\@xticksizeB add
 \\pst\@number\\psyunit div neg ){\\color{#1}#3}}
\\makeatother \n"
		);
		$xmarkierungkopfohne = 1;
	}
	if ( $farbe eq "black" ) {
		schreibeinarray( $layer, sprintf( "\\psxpointohne{%g}{%s}", $x, $text ) );
	}
	else {
		schreibeinarray( $layer, sprintf( "\\psxpointohne[%s]{%g}{%s}", $farbe, $x, $text ) );
	}
}

sub xmarkierungstrahl {
	my ( $layer, $x, $ylaenge, $text, $linienart, $linienstaerke, $farbe, $parameter ) = @_;

	$text =~ tr/./,/s;

	linie(
		$layer, $x, $ylaenge / 2,
		"", $x, -$ylaenge / 2,
		"", $linienart, $linienstaerke, $farbe, $parameter, ""
	);
	beschriftung( $layer, $farbe, $x, -( $ylaenge / 2 + $ylaenge / 4 ), 0, 270, $text );

}

sub ymarkierungstrahl {
	my ( $layer, $y, $xlaenge, $text, $linienart, $linienstaerke, $farbe, $parameter ) = @_;

	$text =~ tr/./,/s;

	linie(
		$layer, $xlaenge / 2,
		$y, "", -$xlaenge / 2,
		$y, "", $linienart, $linienstaerke, $farbe, $parameter, ""
	);
	beschriftung( $layer, $farbe, -( $xlaenge / 2 + $xlaenge / 4 ), $y, 0, 180, $text );

}

my $xmarkierungkopfoben = 0;

sub xmarkierungoben {
	my ( $layer, $x, $text, $farbe ) = @_;
	minmax( $x, -1, $x, 1 );

	if ( $xmarkierungkopfoben == 0 ) {
		pstricks(
			105, "\\makeatletter\\newcommand{\\psxpointoben}[3][black]{%
 \\psline[linewidth=.5pt,linecolor=#1]{-}(#2,\\pst\@xticksizeB)(#2,\\pst\@xticksizeA)
 \\rput[b](! #2 \\pst\@number\\pslabelsep \\pst\@number\\pst\@xticksizeB add
 \\pst\@number\\psyunit div ){\\color{#1}#3}}
\\makeatother \n"
		);
		$xmarkierungkopfoben = 1;
	}
	if ( $farbe eq "black" ) {
		schreibeinarray( $layer, sprintf( "\\psxpointoben{%g}{%s}", $x, $text ) );
	}
	else {
		schreibeinarray( $layer, sprintf( "\\psxpointoben[%s]{%g}{%s}", $farbe, $x, $text ) );
	}

}

my $xmulti = 0;

sub xmarkierungmulti {
	my ( $layer, $x1, $x2, $schritt, $farbe ) = @_;
	minmax( $x1, 0, $x2, 0 );

	my $dx = $x2 - $x1;
	if ( $xmulti == 0 ) {
		pstricks(
			105, "\\makeatletter\\newcommand{\\psxpointstrich}[3][black]{%
 \\psline[linewidth=.5pt,linecolor=#1]{-}(#2,\\pst\@xticksizeB)(#2,\\pst\@xticksizeA)}
\\makeatother"
		);
		$xmulti = 1;
	}
	schreibeinarray(
		$layer,
		sprintf(
			"\\multido{\\n=%g+%g}{%i}{\\psxpointstrich[%s]{\\n}{\\n+1}}",
			$x1, $schritt, $dx, $farbe,
		)
	);
}

my $ymarkierungkopf = 0;

sub ymarkierung {
	my ( $layer, $ywert, $text, $farbe ) = @_;
	minmax( -$xstep / getskalierung("x"), $ywert, $xstep / getskalierung("x"), $ywert );

	if ( $ymarkierungkopf == 0 ) {
		pstricks(
			105, "\\makeatletter\\newcommand{\\psypoint}[3][black]{%
 \\psline[linewidth=.5pt,linecolor=#1]{-}(\\pst\@yticksizeB,#2)(\\pst\@yticksizeA,#2)
 \\rput[r](! \\pst\@number\\pslabelsep \\pst\@number\\pst\@yticksizeA sub
 \\pst\@number\\psxunit div neg #2){\\color{#1}#3}}
\\makeatother
"
		);
		$ymarkierungkopf = 1;
	}
	schreibeinarray( $layer, sprintf( "\\psypoint[%s]{%g}{%s}", $farbe, $ywert, $text ) );
}

my $ymarkierungkopfohne = 0;

sub ymarkierungohne {
	my ( $layer, $ywert, $text, $farbe ) = @_;
	minmax( -$xstep / getskalierung("x"), $ywert, $xstep / getskalierung("x"), $ywert );

	if ( $ymarkierungkopfohne == 0 ) {
		pstricks(
			105, "\\makeatletter\\newcommand{\\psypointohne}[3][black]{%
 \\rput[r](! \\pst\@number\\pslabelsep \\pst\@number\\pst\@yticksizeA sub
 \\pst\@number\\psxunit div neg #2){\\color{#1}#3}}
\\makeatother
"
		);
		$ymarkierungkopfohne = 1;
	}
	schreibeinarray( $layer, sprintf( "\\psypointohne[%s]{%g}{%s}", $farbe, $ywert, $text ) );

}

my $ymarkierungkopfneu = 0;

sub ymarkierunglinks {
	my ( $layer, $ywert, $text, $farbe ) = @_;
	minmax( 0, $ywert, 0, $ywert );

	if ( $ymarkierungkopfneu == 0 ) {
		pstricks(
			105, "\\makeatletter\\newcommand{\\psypointlinks}[3][black]{%
 \\psline[linewidth=.5pt,linecolor=#1]{-}(\\pst\@yticksizeB,#2)(\\pst\@yticksizeA,#2)
 \\rput[l](! \\pst\@number\\pslabelsep \\pst\@number\\pst\@yticksizeA sub
 \\pst\@number\\psxunit div #2){\\color{#1}#3}}
\\makeatother
"
		);
		$ymarkierungkopfneu = 1;
	}
	schreibeinarray( $layer, sprintf( "\\psypointlinks[%s]{%g}{%s}", $farbe, $ywert, $text ) );

}

sub markierung {
	my (
		$layer, $func,      $x,             $y,       $xtext, $ytext,
		$farbe, $linienart, $linienstaerke, $striche, $parameter
	) = @_;
	minmax( $x, $y, $x, $y );
	my $parameterweiter = "";
	if ( dreidimensional( $func, "y" ) == 0 ) {
		if ( $striche =~ /x/ ) {
			linie( $layer, $x, $y, "", $x, 0, "", $linienart, $linienstaerke, $farbe, $parameter,
				"" );
			if ( $y < 0 ) { xmarkierungoben( $layer, $x, $xtext, $farbe ); }
			else          { xmarkierung( $layer, $x, $xtext, $farbe ); }
		}
		if ( $striche =~ /y/ ) {
			linie( $layer, $x, $y, "", 0, $y, "", $linienart, $linienstaerke, $farbe, $parameter,
				"" );
			if ( $x < 0 ) { ymarkierunglinks( $layer, $y, $ytext, $farbe ); }
			else          { ymarkierung( $layer, $y, $ytext, $farbe ); }

		}
		if ( $parameter eq "" ) {
			$parameterweiter = "dotstyle=x, dotsize=1pt";
		}
		else { $parameterweiter = $parameter; }

		paar( $x, $y );
		befehlerzeugen( $layer, "psdot", $farbe, $linienart, $linienstaerke, $parameterweiter, "",
			gettexthier() );

	}
	else {
		tripel( $x, $y, calcfunk3d( $func, "x", $x, "y", $y ) );
		if ( get3dpstricks() == 1 ) {

			$parameterweiter = "drawCoor, dotstyle=x, dotsize=1pt,";
			$parameterweiter = $parameterweiter . " " . " " . $parameter;
			befehlerzeugen( $layer, "pstThreeDDot", $farbe, $linienart, $linienstaerke,
				$parameterweiter, "", gettexthier() );
		}
		else {
			$parameterweiter = "dotstyle=x, dotsize=1pt,";
			$parameterweiter = $parameterweiter . " " . " " . $parameter;
			befehlerzeugen( $layer, "psdot", $farbe, $linienart, $linienstaerke, $parameterweiter,
				"", gettexthier() );
		}
		xmarkierung3d( $layer, $x, $xtext, $farbe );
		ymarkierung3d( $layer, $y, $ytext, $farbe )

	}
	settexthier("");

}
##################################################################
# Pfeile an den Achsen
##################################################################
sub xpfeil {
	my ( $layer, $x, $ywert, $text, $farbe, $linienstaerke, $linienart ) = @_;
	my $ywerttext;

	if ( get3dzeichnen() == 1 ) {
		linie( $layer, $x, $ywert, 0, $x, getschnitt("y"), 0, $linienart, $linienstaerke, $farbe,
			"", "->" );
		if ( $ywert > 0 ) {
			$ywerttext = $ywert + 0.1;
			beschriftung(
				$layer, $farbe,
				x3d( $x, $ywerttext, 0 ),
				y3d( $x, $ywerttext, 0 ),
				0, 0, $text
			);
		}
		else {
			$ywerttext = $ywert - 0.1;
			beschriftung(
				$layer, $farbe,
				x3d( $x, $ywerttext, 0 ),
				y3d( $x, $ywerttext, 0 ),
				0, 180, $text
			);
		}
	}
	else {
		linie( $layer, $x, $ywert, "", $x, getschnitt("y"), "", $linienart, $linienstaerke, $farbe,
			"", "->" );
		if ( $ywert > 0 ) {
			$ywerttext = $ywert + 0.1;
			beschriftung( $layer, $farbe, $x, $ywerttext, 0, 90, $text );
		}
		else {
			$ywerttext = $ywert - 0.3;
			beschriftung( $layer, $farbe, $x, $ywerttext, 0, 90, $text );
		}
	}
}

sub xpfeilkasten {
	my ( $layer, $x, $y, $text, $farbe, $linienstaerke, $linienart ) = @_;

	my ( $breite, $hoehe, $laenge );

	$laenge = length($text);

	if   ( $laenge == 0 ) { $breite = 0.15 * 3; }
	else                  { $breite = 0.15 * $laenge; }

	$hoehe = 0.7;
	xpfeil( $layer, $x, $y, "", $farbe, $linienstaerke, $linienart );

	if ( $y > 0 ) {
		rechtecktext(
			$layer,      $x - $breite, $y,             $x + $breite,
			$y + $hoehe, $text,        $farbe,         "",
			"",          $linienart,   $linienstaerke, ""
		);
	}
	else {
		rechtecktext(
			$layer, $x - $breite, $y - $hoehe,    $x + $breite,
			$y,     $text,        $farbe,         "",
			"",     $linienart,   $linienstaerke, ""
		);
	}

}

sub ypfeil {
	my ( $layer, $x, $ywert, $text, $farbe, $linienstaerke, $linienart ) = @_;
	my $xtext;
	if ( get3dzeichnen() == 1 ) {
		linie( $layer, $x, $ywert, 0, getschnitt("x"), $ywert, 0, $linienart, $linienstaerke,
			$farbe, "", "->" );
		if ( $x > 0 ) {
			$xtext = $x + 0.1;
			beschriftung(
				$layer, $farbe,
				x3d( $xtext, $ywert, 0 ),
				y3d( $xtext, $ywert, 0 ),
				0, 270, $text
			);
		}
		else {
			$xtext = $x - 0.1;
			beschriftung(
				$layer, $farbe,
				x3d( $xtext, $ywert, 0 ),
				y3d( $xtext, $ywert, 0 ),
				0, 90, $text
			);
		}
	}
	else {

		linie( $layer, $x, $ywert, "", getschnitt("x"), $ywert, "", $linienart, $linienstaerke,
			$farbe, "", "->" );
		if ( $x > 0 ) {
			$xtext = $x + 0.1;
			beschriftung( $layer, $farbe, $xtext, $ywert, 0, 0, $text );
		}
		else {
			$xtext = $x - 0.1;
			beschriftung( $layer, $farbe, $xtext, $ywert, 0, 180, $text );
		}
	}

}

sub ypfeilkasten {
	my ( $layer, $x, $y, $text, $farbe, $linienstaerke, $linienart ) = @_;

	ypfeil( $layer, $x, $y, "", $farbe, $linienstaerke, $linienart );

	my ( $breite, $hoehe, $laenge );

	$laenge = length($text);

	if   ( $laenge == 0 ) { $breite = 0.2 * 3; }
	else                  { $breite = 0.2 * $laenge; }

	$hoehe = 0.7;

	if ( $x > 0 ) {
		rechtecktext(
			$layer,            $x,         $y - 0.5 * $hoehe, $x + $breite,
			$y + 0.5 * $hoehe, $text,      $farbe,            "",
			"",                $linienart, $linienstaerke,    ""
		);
	}
	else {
		rechtecktext(
			$layer,            $x - $breite, $y - 0.5 * $hoehe, $x,
			$y + 0.5 * $hoehe, $text,        $farbe,            "",
			"",                $linienart,   $linienstaerke,    ""
		);
	}

}

sub zpfeil {
	my ( $layer, $zwert, $ywert, $text, $farbe, $linienstaerke, $linienart ) = @_;
	my $ywerttext;

	linie( $layer, 0, $ywert, $zwert, 0, getschnitt("y"), $zwert, $linienart, $linienstaerke,
		$farbe, "", "->" );
	if ( $ywert > 0 ) {
		$ywerttext = $ywert + 0.1;
		beschriftung(
			$layer, $farbe,
			x3d( 0, $ywerttext, $zwert ),
			y3d( 0, $ywerttext, $zwert ),
			0, 0, $text
		);
	}
	else {
		$ywerttext = $ywert - 0.1;
		beschriftung(
			$layer, $farbe,
			x3d( 0, $ywerttext, $zwert ),
			y3d( 0, $ywerttext, $zwert ),
			0, 180, $text
		);
	}
	abstand($layer);
}

1;
