# 
# PERL mapweaver module by gary68
#
#
#
#
# Copyright(C)2011, Gerhard Schwanz
#
# This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the 
# Free Software Foundation; either version 3 of the License, or(at your option)any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with this program; if not, see <http://www.gnu.org/licenses/>
#


package mwMap; 

use strict;
use warnings;

use mwConfig;
# use mwMisc;
# use mwFile;
# use mwLabel;

use OSM::osm;

use Geo::Proj4;


my $areaNum = 0;
my %areaDef =();

use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);

require Exporter;

@ISA = qw(Exporter AutoLoader);

@EXPORT = qw(initGraph
			coordsOut
			drawCircle
			drawSquare
			drawTriangle
			drawDiamond
			drawRect
			drawText
			writeMap
			drawWay
			drawArea
			fitsPaper
			getScale
			createPath
			pathText
			placeIcon
			convert
			gridSquare
			getDimensions
			initOneways
			addOnewayArrows
			addAreaIcon
			createShield
			getMaxShieldSize
			getShieldSizes
			getShieldId
			addToLayer
			createLegendFile
	);


my @belowWays =("background", "base", "area", "multi");

my @aboveWays =("arealabels", "wayLabels", "routes", "routeStops", "shields", "nodes", "icons", "text", "additional", "occupied");

my @elements =("scale", "ruler", "legend", "wns", "header", "footer", "rectangles", "title", "gpx");

my %svgLayer =();
my %wayLayer =();

my $shieldPathId = 0;
my %createdShields =();
my %shieldXSize =();
my %shieldYSize =();

my $proj;

my($bottom, $left, $right, $top);
my($sizeX, $sizeY);
my($projLeft, $projBottom, $projRight, $projTop);
my($projSizeX, $projSizeY);

sub initGraph{
	# function initializes the picture and projection

	my($x, $l, $b, $r, $t)= @_;	

	# my $l0 = int($l)- 1;
	my $l0 = int(($r+$l)/ 2);

	$proj = Geo::Proj4->new(	proj => cv('projection'), 
		ellps => cv('ellipsoid'), 
		lon_0 => $l0 
)or die "parameter error: ".Geo::Proj4->error. "\n"; 


($projLeft, $projBottom)= $proj->forward($b, $l); # lat/lon!!!
($projRight, $projTop)= $proj->forward($t, $r); # lat/lon!!!

	$projSizeX = $projRight - $projLeft;
	$projSizeY = $projTop - $projBottom;

	my $factor = $projSizeY / $projSizeX;

	$sizeX = int($x);
	$sizeY = int($x * $factor);

	$top = $t;
	$left = $l;
	$right = $r;
	$bottom = $b;

	if((cv('bgcolor')ne "none")and(cv('bgcolor')ne "")){		my $col = cv('bgcolor');
		my $svgText = "fill=\"$col\" ";
		drawRect(0, 0, $sizeX, $sizeY, 0, $svgText, "background");
}
	if(cv('ruler')ne "0"){		drawRuler();
}
	if(cv('scale')ne "0"){		drawScale();
}
	if(cv('grid')!= 0){		drawGrid();
}	if(cv('coords')eq "1"){		drawCoords();
}	if(length cv('foot')> 0){		drawFoot();
}	if(length cv('head')> 0){		drawHead();
}
}
sub addToLayer{	my($layer, $text)= @_;

	if($layer =~ /^[\d\-\.]+$/){		push @{$wayLayer{$layer}}, $text;
		# print "adding NUMERIC: $text\n";
}	else{		push @{$svgLayer{$layer}}, $text;
		# print "adding TEXTUAL: $text\n";
}}
sub drawWay{
	# accepts list of nodes(plus convert=1)or list of x,y,x,y(convert=0)and draws way/polygon to layerNr if defined or to layerName

	my($nodesRef, $convert, $svgString, $layerName, $layerNumber)= @_;
	my @points =();
	my $valid = 0;

	# convert? and expand.
	my($lonRef, $latRef, $tagRef)= mwFile::getNodePointers();
	if($convert){		foreach my $node(@$nodesRef){			my($x, $y)= convert($$lonRef{$node}, $$latRef{$node});
			push @points, $x, $y;
			if(! coordsOut($x, $y)){				$valid = 1;
		}	}}	else{		@points = @$nodesRef;
		foreach my $node(@$nodesRef){			my($x, $y)=($$lonRef{$node}, $$latRef{$node});
			if(! coordsOut($x, $y)){				$valid = 1;
		}	}}
	my $refp = simplifyPoints(\@points);
	@points = @$refp;

	if($valid){
		my $svg = "<polyline points=\"";
		for(my$i=0; $i<scalar(@points)-1; $i+=2){			$svg = $svg . $points[$i] . "," . $points[$i+1] . " ";
	}
		$svg = $svg . "\" $svgString />";

		if(defined $layerNumber){			push @{$wayLayer{$layerNumber}}, $svg;
	}		else{			push @{$svgLayer{$layerName}}, $svg;
	}}	else{		# if(){print "way not drawn, outside\n";}}}


sub drawText{
	my($x, $y, $convert, $text, $svgString, $layerName)= @_;

	if($convert){($x, $y)= convert($x, $y);
}
	if(! coordsOut($x, $y)){
		my $svg = "<text x=\"$x\" y=\"$y\" $svgString>" . $text . "</text>";

		push @{$svgLayer{$layerName}}, $svg;
}}



sub drawCircle{
	# draws circle element to svgLayer given; if convertCoords then lon / lat is converted to x / y
	# circleradius either in pixel or in meters(convert=1)	my($x, $y, $convertCoords, $radius, $convertRadius, $format, $layerName)= @_;

	if($convertCoords){($x, $y)= convert($x, $y);
}	if($convertRadius){		$radius = $radius /(1000 * distance($left, $bottom, $right, $bottom))* $sizeX;
}
	if(! coordsOut($x, $y)){
		my $svg = "<circle cx=\"$x\" cy=\"$y\" r=\"$radius\" ";
		$svg .= $format . " />";

		push @{$svgLayer{$layerName}}, $svg;
}}
sub drawSquare{
	# draws square element to svgLayer given; if convertCoords then lon / lat is converted to x / y
	# square size either in pixel or in meters(convert=1)	my($x, $y, $convertCoords, $size, $convertSize, $format, $layerName)= @_;

	if($convertCoords){($x, $y)= convert($x, $y);
}	if($convertSize){		$size = $size /(1000 * distance($left, $bottom, $right, $bottom))* $sizeX;
}
	my $x1 = $x - $size;
	my $y1 = $y - $size;
	my $dSize = 2 * $size;

	if(! coordsOut($x, $y)){
		my $svg = "<rect x=\"$x1\" y=\"$y1\" width=\"$dSize\" height=\"$dSize\" ";
		$svg .= $format . " />";

		push @{$svgLayer{$layerName}}, $svg;
}}
sub drawTriangle{
	# draws triangle element to svgLayer given; if convertCoords then lon / lat is converted to x / y
	# square size either in pixel or in meters(convert=1)	my($x, $y, $convertCoords, $size, $convertSize, $format, $layerName)= @_;

	if($convertCoords){($x, $y)= convert($x, $y);
}	if($convertSize){		$size = $size /(1000 * distance($left, $bottom, $right, $bottom))* $sizeX;
}
	my $h = int(sqrt($size * $size / 2));

	my $x1 = $x;
	# my $y1 = $y - $size;
	my $y1 = $y - $h;
	my $x2 = $x - $h;
	my $y2 = $y + $h;
	my $x3 = $x + $h;
	my $y3 = $y + $h;

	if(! coordsOut($x1, $y1, $x2, $y2, $x3, $y3)){
		my $svg = "<polyline points=\"$x1,$y1 $x2,$y2 $x3,$y3 $x1,$y1\" ";
		$svg .= $format . " />";

		push @{$svgLayer{$layerName}}, $svg;
}}
sub drawDiamond{
	# draws diamond element to svgLayer given; if convertCoords then lon / lat is converted to x / y
	# square size either in pixel or in meters(convert=1)	my($x, $y, $convertCoords, $size, $convertSize, $format, $layerName)= @_;

	if($convertCoords){($x, $y)= convert($x, $y);
}	if($convertSize){		$size = $size /(1000 * distance($left, $bottom, $right, $bottom))* $sizeX;
}
	my $x1 = $x - $size; # left
	my $y1 = $y;
	my $x2 = $x; # top
	my $y2 = $y - $size;
	my $x3 = $x + $size; #right
	my $y3 = $y;
	my $x4 = $x; # bottom
	my $y4 = $y + $size;

	if(! coordsOut($x1, $y1, $x2, $y2, $x3, $y3, $x4, $y4)){		my $svg = "<polyline points=\"$x1,$y1 $x2,$y2 $x3,$y3 $x4,$y4 $x1,$y1\" ";
		$svg .= $format . " />";

		push @{$svgLayer{$layerName}}, $svg;
}}
sub drawRect{
	# draws square element to svgLayer given; if convertCoords then lon / lat is converted to x / y
	# square size either in pixel or in meters(convert=1)	my($x1, $y1, $x2, $y2, $convertCoords, $format, $layerName)= @_;

	if($convertCoords){($x1, $y1)= convert($x1, $y1);
($x2, $y2)= convert($x2, $y2);
}
	my $sizeX = $x2 - $x1;
	my $sizeY = $y2 - $y1;

	if(! coordsOut($x1, $y1, $x2, $y2)){		my $svg = "<rect x=\"$x1\" y=\"$y1\" width=\"$sizeX\" height=\"$sizeY\" ";
		$svg .= $format . " />";

		push @{$svgLayer{$layerName}}, $svg;
}}

sub createPath{#
# creates path element for later use with textPath
#
	my($pathName, $refp, $layer)= @_;

	my $refp2 = simplifyPoints($refp);
	my @points = @$refp2;

	my $svg = "<path id=\"" . $pathName . "\" d=\"M ";
	my $i;
	my $first = 1;
	for($i=0; $i<scalar(@points); $i+=2){		if($first){			$svg = $svg . $points[$i] . "," . $points[$i+1] . " ";
			$first = 0;
	}		else{			$svg = $svg . "L " . $points[$i] . "," . $points[$i+1] . " ";
	}}	$svg = $svg . "\" />\n";

	push @{$svgLayer{$layer}}, $svg;
}

sub pathText{#
# draws text to path element; alignment: start, middle, end
#
	my($svgText, $text, $pathName, $tSpan, $alignment, $offset, $layer)= @_;

	my $svg = "<text $svgText >\n";
	$svg = $svg . "<textPath xlink:href=\"#" . $pathName . "\" text-anchor=\"" . $alignment . "\" startOffset=\"" . $offset . "%\" >\n";
	$svg = $svg . "<tspan dy=\"" . $tSpan . "\" >" . $text . " </tspan>\n";
	$svg = $svg . "</textPath>\n</text>\n";

	push @{$svgLayer{$layer}}, $svg;
}

sub placeIcon{#
# create SVG text for icons
#


	my($x, $y, $icon, $sizeX, $sizeY, $layer)= @_;

	if(! coordsOut($x, $y)){
		my($out)= "<image x=\"" . $x . "\"";
		$out .= " y=\"" . $y . "\"";
		if($sizeX > 0){$out .= " width=\"" . $sizeX . "\"";}		if($sizeY > 0){$out .= " height=\"" . $sizeY . "\"";}		$out .= " xlink:href=\"" . $icon . "\" />";

		push @{$svgLayer{$layer}}, $out;
}}

sub drawArea{#
# draws mp in svg ARRAY of ARRAY of nodes/coordinates
#
	my($svgText, $icon, $ref, $convert, $layer)= @_;
	my @ways = @$ref;
	my $i;
	my $svg = "";
	my $valid = 1;
	my @newArray =();

	# TODO loop converts original data !!!

	if($convert){		my($lonRef, $latRef, $tagRef)= mwFile::getNodePointers();
		foreach my $aRef(@ways){			my @way = @$aRef;
			my @newCoords =();
			foreach my $n(@way){				my($x, $y)= convert($$lonRef{$n}, $$latRef{$n});
				push @newCoords, $x, $y;
				if(coordsOut($x, $y)){					$valid = 0;
			}		}			push @newArray , [@newCoords];
	}		@ways = @newArray;
}
	if(defined $areaDef{$icon}){		$svg = "<path $svgText fill-rule=\"evenodd\" style=\"fill:url(" . $areaDef{$icon}. ")\" d=\"";
}	else{		$svg = "<path $svgText fill-rule=\"evenodd\" d=\"";
}	
	foreach my $way(@ways){		my @actual = @$way;
		for($i=0; $i<scalar(@actual); $i+=2){			if($i == 0){$svg .= " M ";}else{$svg .= " L ";}			$svg = $svg . $actual[$i] . " " . $actual[$i+1];
	}		$svg .= " z";
}
	$svg = $svg . "\" />";

	if($valid){		push @{$svgLayer{$layer}}, $svg;
}}


# ---------------------------------------------------------------------

sub writeMap{
	my $fileName = cv('out');

	open(my $file, ">", $fileName)|| die "can't open svg output file $fileName\n";

	print $file "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n";
	print $file "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\" >\n";

	my $w = $sizeX / 300 * 2.54; # cm
	my $h = $sizeY / 300 * 2.54;

	my($svg)= "<svg version=\"1.1\" baseProfile=\"full\" xmlns=\"http://www.w3.org/2000/svg\" ";
	$svg .= "xmlns:xlink=\"http://www.w3.org/1999/xlink\" xmlns:ev=\"http://www.w3.org/2001/xml-events\" ";
	$svg .= "width=\"$w" . "cm\" height=\"$h" . "cm\" viewBox=\"0 0 $sizeX $sizeY\">\n";
	print $file $svg;

	# definitions
	if(defined @{$svgLayer{'definitions'}}){		print $file "<defs>\n";
		foreach(@{$svgLayer{'definitions'}}){print $file $_, "\n";}		print $file "</defs>\n";
}
	# below ways
	foreach my $layer(@belowWays){		if(defined @{$svgLayer{$layer}}){			print $file "<g id=\"$layer\">\n";
			foreach(@{$svgLayer{$layer}}){print $file $_, "\n";}			print $file "</g>\n";
	}}
	# ways
	foreach my $layer(sort{$a <=> $b}keys %wayLayer){		if(defined @{$wayLayer{$layer}}){			print $file "<g id=\"way$layer\">\n";
			foreach(@{$wayLayer{$layer}}){print $file $_, "\n";}			print $file "</g>\n";
	}}

	# above of ways
	foreach my $layer(@aboveWays){		if(defined @{$svgLayer{$layer}}){			print $file "<g id=\"$layer\">\n";
			foreach(@{$svgLayer{$layer}}){print $file $_, "\n";}			print $file "</g>\n";
	}}

	foreach my $layer(@elements){		if(defined @{$svgLayer{$layer}}){			print $file "<g id=\"$layer\">\n";
			foreach(@{$svgLayer{$layer}}){print $file $_, "\n";}			print $file "</g>\n";
	}}

	print $file "</svg>\n";

	close($file);

	if(cv('pdf')eq "1"){		my($pdfName)= $fileName;
		$pdfName =~ s/\.svg/\.pdf/;
		print "creating pdf file $pdfName ...\n";
		`inkscape -A $pdfName $fileName`;
}
	if(cv('png')eq "1"){		my($pngName)= $fileName;
		$pngName =~ s/\.svg/\.png/;
		my $dpi = cv('pngdpi');
		print "creating png file $pngName($dpi dpi)...\n";
		`inkscape --export-dpi=$dpi -e $pngName $fileName`;
}


}
# -----------------------------------------------------------------------------------

sub drawGrid{#
# draw grid on top of map. receives number of parts in x/lon direction
#

	my $number = cv('grid');
	my $color = cv('gridcolor');

	my $part = $sizeX / $number;
	my $numY = $sizeY / $part;

	my $svgStringLine="stroke=\"$color\" stroke-width=\"5\" stroke-dasharray=\"30,30\"";

	my $svgStringText = mwMisc::createTextSVG(cv('elementFontFamily'), cv('elementFont'), undef, undef, 60, $color, undef, undef);

	# vertical lines
	for(my $i = 1; $i <= $number; $i++){		my @coords =($i*$part, 0, $i*$part, $sizeY);
		drawWay(\@coords, 0, $svgStringLine, "additional", undef);
		drawText(($i-1)*$part+$part/2, 160, 0, chr($i+64), $svgStringText, "additional");

}
	# hor. lines
	for(my $i = 1; $i <= $numY; $i++){		my @coords =(0, $i*$part, $sizeX, $i*$part);
		drawWay(\@coords, 0, $svgStringLine, "additional", undef);
		drawText(20,($i-1)*$part+$part/2, 0, $i, $svgStringText, "additional");

}}
sub drawCoords{#
# draws coordinates grid on map
#
	my $exp = cv('coordsexp'); 
	my $color = cv('coordscolor');
	my $step = 10 ** $exp;

	# vert. lines
	my $start = int($left / $step)+ 1;
	my $actual = $start * $step;

	my $svgStringLine="stroke=\"$color\" stroke-width=\"3\"";
	my $svgStringText = mwMisc::createTextSVG(cv('elementFontFamily'), cv('elementFont'), undef, undef, 30, $color, undef, undef);

	while($actual < $right){		my($x1, $y1)= convert($actual, 0);

		drawText($x1+10, $sizeY-50, 0, $actual, $svgStringText, "additional");

		my @coords =($x1, 0, $x1, $sizeY);
		drawWay(\@coords, 0, $svgStringLine, "additional", undef);

		$actual += $step;
}
	# hor lines
	$start = int($bottom / $step)+ 1;
	$actual = $start * $step;
	while($actual < $top){		# print "actualY: $actual\n";
		my($x1, $y1)= convert(0, $actual);

		drawText($sizeX-180, $y1+30, 0, $actual, $svgStringText, "additional");

		my @coords =(0, $y1, $sizeX, $y1);
		drawWay(\@coords, 0, $svgStringLine, "additional", undef);

		$actual += $step;
}}



# -----------------------------------------------------------------------------------

sub convert{
	# converts real world coordinates to system graph pixel coordinates

	my($x, $y)= @_;

	my($x1, $y1)= $proj->forward($y, $x); # lat/lon!!!

	my $x2 = int(($x1 - $projLeft)/($projRight - $projLeft)* $sizeX);
	my $y2 = $sizeY - int(($y1 - $projBottom)/($projTop - $projBottom)* $sizeY);

	return($x2, $y2);
}
sub simplifyPoints{	my $ref = shift;
	my @points = @$ref;
	my @newPoints;
	my $maxIndex = $#points;

	if(scalar @points > 4){		# push first
		push @newPoints, $points[0], $points[1];

		# push other
		for(my $i=2; $i <= $maxIndex; $i+=2){			# $simplifyTotal++;
			if(($points[$i]==$points[$i-2])and($points[$i+1]==$points[$i-1])){				# same
				# $simplified++;
		}			else{				push @newPoints, $points[$i], $points[$i+1];
		}	}		return(\@newPoints);
}	else{		return($ref);
}
}
sub drawRuler{#
# draws ruler
#
	my $col = cv('rulercolor');	

	my $B; my $B2;
	my $L; my $Lpix;
	my $x;
	my $text;

	my $lineThickness = 8; # at 300dpi
	my $textSize = 40; # at 300 dpi
	my $textDist = 60; # at 300 dpi
	my $lineLen = 40; # at 300 dpi

	my $xOffset = 2 * $lineThickness;
	my $yOffset = 2 * $lineThickness;
		
	$B = $right - $left; 				# in degrees
	$B2 = $B * cos($top/360*3.14*2)* 111.1;	# in km
	$text = "50m"; $x = 0.05;			# default length ruler

	if($B2 > 0.5){$text = "100 m"; $x = 0.1;}# enlarge ruler
	if($B2 > 1){$text = "500 m"; $x = 0.5;}# enlarge ruler
	if($B2 > 5){$text = "1 km"; $x = 1;}	if($B2 > 10){$text = "5 km"; $x = 5;}	if($B2 > 50){$text = "10 km"; $x = 10;}	$L = $x /(cos($top/360*3.14*2)* 111.1);	# length ruler in km
	$Lpix = $L / $B * $sizeX;			# length ruler in pixels

	my $rSizeX = int($Lpix + 2 * $xOffset);
	my $rSizeY = int($lineLen + $textSize + 3 * $yOffset);
	addToLayer("definitions", "<g id=\"rulerdef\" width=\"$rSizeX\" height=\"$rSizeY\" >");

	if(cv('rulerbackground')ne "none"){		my $color = cv('rulerbackground');
		my $svgString = "fill=\"$color\"";
		drawRect(0, 0, $rSizeX, $rSizeY, 0, $svgString, "definitions");
}
	my $svgString = "stroke=\"$col\" stroke-width=\"$lineThickness\" stroke-linecap=\"round\" ";

	my @coords =($xOffset, $yOffset, $xOffset+$Lpix, $yOffset);
	drawWay(\@coords, 0, $svgString, "definitions", undef);

	@coords =($xOffset, $yOffset, $xOffset, $yOffset+$lineLen);
	drawWay(\@coords, 0, $svgString, "definitions", undef);

	@coords =($xOffset+$Lpix, $yOffset, $xOffset+$Lpix, $yOffset+$lineLen);
	drawWay(\@coords, 0, $svgString, "definitions", undef);

	@coords =($xOffset+$Lpix/2, $yOffset, $xOffset+$Lpix/2, $yOffset+$lineLen/2);
	drawWay(\@coords, 0, $svgString, "definitions", undef);


	my $scale= getScale();
	$text .= "(1:$scale)";


	$svgString = mwMisc::createTextSVG(cv('elementFontFamily'), cv('elementFont'), undef, undef, 35, $col, undef, undef);
	drawText($xOffset, $yOffset+$textDist+30, 0, $text, $svgString, "definitions");

	addToLayer("definitions", "</g>");

	my $posX = 40; my $posY = 40;

	if(cv('ruler')eq "2"){		$posX = $sizeX - 40 - $rSizeX;
		$posY = 40;
}
	if(cv('ruler')eq "3"){		$posX = 40;
		$posY = $sizeY - 40 - $rSizeY;
}
	if(cv('ruler')eq "4"){		$posX = $sizeX - 40 - $rSizeX;
		$posY = $sizeY - 40 - $rSizeY;
}
	addToLayer("ruler", "<use x=\"$posX\" y=\"$posY\" xlink:href=\"#rulerdef\" />");
}
sub drawScale{#
# draws scale value
#
	my $col = cv('scalecolor');	

	my $xOffset = 20;
	my $yOffset = 20;
	my $fontSize = 70;		
	my $borderDist = 60;

	my $rSizeX = int(350 + 2 * $xOffset);
	my $rSizeY = int($fontSize + 2 * $yOffset);
	addToLayer("definitions", "<g id=\"scaledef\" width=\"$rSizeX\" height=\"$rSizeY\" >");

	if(cv('scalebackground')ne "none"){		my $color = cv('scalebackground');
		my $svgString = "fill=\"$color\"";
		drawRect(0, 0, $rSizeX, $rSizeY, 0, $svgString, "definitions");
}
	my $scale= getScale();

	my $svgString = mwMisc::createTextSVG(cv('elementFontFamily'), cv('elementFont'), undef, undef, $fontSize, $col, undef, undef);
	drawText($xOffset, $fontSize + $yOffset, 0, "1:$scale", $svgString, "definitions");

	addToLayer("definitions", "</g>");

	my $posX = $borderDist; my $posY = $borderDist;

	if(cv('scale')eq "2"){		$posX = $sizeX - $borderDist - $rSizeX;
		$posY = $borderDist;
}
	if(cv('scale')eq "3"){		$posX = $borderDist;
		$posY = $sizeY - $borderDist - $rSizeY;
}
	if(cv('scale')eq "4"){		$posX = $sizeX - $borderDist - $rSizeX;
		$posY = $sizeY - $borderDist - $rSizeY;
}
	addToLayer("scale", "<use x=\"$posX\" y=\"$posY\" xlink:href=\"#scaledef\" />");
}
sub drawFoot{#
# draws footer
#
	my $col = cv('footcolor');	
	my $text = cv('foot');	
	my $len = length $text;

	my $xOffset = 20;
	my $yOffset = 20;
	my $fontSize = cv('footsize');		
	my $borderDistX = 60;
	my $borderDistY = $fontSize + 50;

	my $rSizeX = int($len*cv('ppc')/10*$fontSize + 2 * $xOffset);
	my $rSizeY = int($fontSize + 2 * $yOffset);
	addToLayer("definitions", "<g id=\"footdef\" width=\"$rSizeX\" height=\"$rSizeY\" >");

	if(cv('footbackground')ne "none"){		my $color = cv('footbackground');
		my $svgString = "fill=\"$color\"";
		drawRect(0, 0, $rSizeX, $rSizeY, 0, $svgString, "definitions");
}
	my $svgString = mwMisc::createTextSVG(cv('elementFontFamily'), cv('elementFont'), undef, undef, $fontSize, $col, undef, undef);
	drawText($xOffset, $fontSize + $yOffset, 0, $text, $svgString, "definitions");

	addToLayer("definitions", "</g>");

	my $posX = $borderDistX; my $posY = $sizeY - $borderDistY;

	addToLayer("footer", "<use x=\"$posX\" y=\"$posY\" xlink:href=\"#footdef\" />");
}
sub drawHead{#
# draws header
#
	my $col = cv('headcolor');	
	my $text = cv('head');	
	my $len = length $text;

	my $xOffset = 20;
	my $yOffset = 20;
	my $fontSize = cv('headsize');		
	my $borderDistX = 60;
	my $borderDistY = 60;

	my $rSizeX = int($len*cv('ppc')/10*$fontSize + 2 * $xOffset);
	my $rSizeY = int($fontSize + 2 * $yOffset);
	addToLayer("definitions", "<g id=\"headdef\" width=\"$rSizeX\" height=\"$rSizeY\" >");

	if(cv('headbackground')ne "none"){		my $color = cv('headbackground');
		my $svgString = "fill=\"$color\"";
		drawRect(0, 0, $rSizeX, $rSizeY, 0, $svgString, "definitions");
}
	my $svgString = mwMisc::createTextSVG(cv('elementFontFamily'), cv('elementFont'), undef, undef, $fontSize, $col, undef, undef);
	drawText($xOffset, $fontSize + $yOffset, 0, $text, $svgString, "definitions");

	addToLayer("definitions", "</g>");

	my $posX = $borderDistX; my $posY = $borderDistY;

	addToLayer("header", "<use x=\"$posX\" y=\"$posY\" xlink:href=\"#headdef\" />");
}

sub fitsPaper{#
# calculates on what paper size the map will fit. sizes are taken from global variables
#

	my $width = $sizeX / 300 * 2.54;
	my $height = $sizeY / 300 * 2.54;
	my $paper = "";

	my @sizes =();
	push @sizes, ["4A0", 168.2, 237.8];
	push @sizes, ["2A0", 118.9, 168.2];
	push @sizes, ["A0", 84.1, 118.9];
	push @sizes, ["A1", 59.4, 84.1];
	push @sizes, ["A2", 42, 59.4];
	push @sizes, ["A3", 29.7, 42];
	push @sizes, ["A4", 21, 29.7];
	push @sizes, ["A5", 14.8, 21];
	push @sizes, ["A6", 10.5, 14.8];
	push @sizes, ["A7", 7.4, 10.5];
	push @sizes, ["none", 0, 0];

	foreach my $size(@sizes){		if((($width<=$size->[1])and($height<=$size->[2]))or(($width<=$size->[2])and($height<=$size->[1]))){			$paper = $size->[0];
	}}
	return($paper, $width, $height);
}
sub getScale{#
# calcs scale of map
#
	my($dpi)= 300;

	my $dist = distance($left, $bottom, $right, $bottom);
	my $inches = $sizeX / $dpi;
	my $cm = $inches * 2.54;
	my $scale = int($dist /($cm/100/1000));
	$scale = int($scale / 100)* 100;

	return($scale);
}
sub gridSquare{#
# returns grid square of given coordinates for directories
#
	my($lon, $lat)= @_;

	my $parts = cv('grid');

	my($x, $y)= convert($lon, $lat);
	my $xi = int($x /($sizeX / $parts))+ 1;
	my $yi = int($y /($sizeX / $parts))+ 1;
	if(($x >= 0)and($x <= $sizeX)and($y >= 0)and($y <= $sizeY)){		return(chr($xi+64). $yi);
}	else{		return undef;
}}

sub getDimensions{	return($sizeX, $sizeY);
}
# ----------------------------------------------------------------------

sub initOneways{#
# write marker defs to svg 
#
	my $color = cv('onewaycolor');

	my @svgOutputDef =();
	for(my $markerSize = 5; $markerSize <= 40; $markerSize++){		push @svgOutputDef, "<marker id=\"Arrow$markerSize\"";
		push @svgOutputDef, "viewBox=\"0 0 10 10\" refX=\"5\" refY=\"5\"";
		push @svgOutputDef, "markerUnits=\"strokeWidth\"";
		push @svgOutputDef, "markerWidth=\"" . $markerSize . "\" markerHeight=\"" . $markerSize . "\"";
		push @svgOutputDef, "orient=\"auto\">";
		push @svgOutputDef, "<path d=\"M 0 4 L 6 4 L 6 2 L 10 5 L 6 8 L 6 6 L 0 6 Z\" fill=\"" . $color .  "\" />";
		push @svgOutputDef, "</marker>";
}

	foreach my $line(@svgOutputDef){		addToLayer("definitions", $line);
}}
sub addOnewayArrows{#
# adds oneway arrows to new pathes
#
	my($wayNodesRef, $direction, $thickness, $layer)= @_;
	my @wayNodes = @$wayNodesRef;
	my($lonRef, $latRef)= mwFile::getNodePointers();

	if($direction == -1){@wayNodes = reverse @wayNodes;}
	my $minDist = cv('onewaysize')* 1.5;
	my $markerSize = cv('onewaySize');

	if(cv('onewayAutoSize')!= 0){		$markerSize = int($thickness / 100 * cv('onewayAutoSize'));
		if($markerSize < 5){$markerSize = 5;}		if($markerSize > 40){$markerSize = 40;}		$minDist = $markerSize * 1.5;
}
	# create new pathes with new nodes
	for(my $i = 0; $i < scalar(@wayNodes)- 1; $i++){		my($x1, $y1)= convert($$lonRef{$wayNodes[$i]}, $$latRef{$wayNodes[$i]});
		my($x2, $y2)= convert($$lonRef{$wayNodes[$i+1]}, $$latRef{$wayNodes[$i+1]});
		my $xn =($x2+$x1)/ 2;
		my $yn =($y2+$y1)/ 2;
		if(sqrt(($x2-$x1)**2+($y2-$y1)**2)> $minDist){			# create path
			# use path
			my $svg = "<path d=\"M $x1 $y1 L $xn $yn L $x2 $y2\" fill=\"none\" marker-mid=\"url(#Arrow$markerSize)\" />";
			
			addToLayer($layer+$thickness/100, $svg);
	}}}
# ----------------------------------------------------------------------------

sub addAreaIcon{#
# initial collection of area icons 
#
	my $fileNameOriginal = shift;
	# print "AREA: $fileNameOriginal\n";
	my $result = open(my $file, "<", $fileNameOriginal);
	close($file);
	if($result){		my($x, $y);
		if(grep /.svg/, $fileNameOriginal){	($x, $y)= mwMisc::sizeSVG($fileNameOriginal);
			if(($x == 0)or($y == 0)){
				$x = 32; $y = 32; 
				print "WARNING: size of file $fileNameOriginal could not be determined. Set to 32px x 32px\n";
		}
	}
		if(grep /.png/, $fileNameOriginal){	($x, $y)= mwMisc::sizePNG($fileNameOriginal);
	}
		if(!defined $areaDef{$fileNameOriginal}){
			my $x1 = $x; # scale area icons 
			my $y1 = $y;
			my $fx = $x1 / $x;
			my $fy = $y1 / $y;
			
			# add defs to svg output
			my $defName = "A" . $areaNum;
			# print "INFO area icon $fileNameOriginal, $defName, $x, $y --- $x1, $y1 --- $fx, $fy --- processed.\n";
			$areaNum++;

			my $svgElement = "<pattern id=\"" . $defName . "\" width=\"" . $x . "\" height=\"" . $y . "\" ";
			$svgElement .= "patternTransform=\"translate(0,0)scale(" . $fx . "," . $fy . ")\" \n";
			$svgElement .= "patternUnits=\"userSpaceOnUse\">\n";
			$svgElement .= "  <image xlink:href=\"" . $fileNameOriginal . "\"/>\n";
			$svgElement .= "</pattern>\n";

			addToLayer("definitions", $svgElement);

			$defName = "#" . $defName;
			$areaDef{$fileNameOriginal}= $defName;
	}}	else{		print "WARNING: area icon $fileNameOriginal not found!\n";
}}
# ----------------------------------------------------------------------------

sub createShield{	my($name, $targetSize)= @_;
	my @a = split /:/, $name;
	my $shieldFileName = $a[1];
	my $shieldText = $a[2];

	if(! defined $createdShields{$name}){		open(my $file, "<", $shieldFileName)or die("ERROR: shield definition $shieldFileName not found.\n");
		my @defText = <$file>;
		close($file);

		# get size
		# calc scaling
		my $sizeX = 0;
		my $sizeY = 0;
		foreach my $line(@defText){			if(grep /<svg/, $line){		($sizeY)=($line =~ /height=\"(\d+)px\"/);
		($sizeX)=($line =~ /width=\"(\d+)px\"/);
				if((!defined $sizeX)or(!defined $sizeY)){					die "ERROR: size of shield in $shieldFileName could not be determined.\n";
			}		}	}		if(($sizeX == 0)or($sizeY == 0)){			die "ERROR: initial size of shield $shieldFileName could not be determined.\n";
	}
		my $scaleFactor = $targetSize / $sizeY;

		$shieldXSize{$name}= int($sizeX * $scaleFactor);
		$shieldYSize{$name}= int($sizeY * $scaleFactor);

		$shieldPathId++;
		my $shieldPathName = "ShieldPath" . $shieldPathId;
		my $shieldGroupName = "ShieldGroup" . $shieldPathId;

		foreach my $line(@defText){			$line =~ s/REPLACEID/$shieldGroupName/;
			$line =~ s/REPLACESCALE/$scaleFactor/g;
			$line =~ s/REPLACEPATH/$shieldPathName/;
			$line =~ s/REPLACELABEL/$shieldText/;
	}
		foreach my $line(@defText){			addToLayer("definitions", $line);
	}
		$createdShields{$name}= $shieldGroupName;
}}
sub getMaxShieldSize{	my $name = shift;
	my $max = $shieldXSize{$name};
	if($shieldYSize{$name}> $max){$max = $shieldYSize{$name};}	return $max;
}
sub getShieldSizes{	my $name = shift;
	my $x = $shieldXSize{$name};
	my $y = $shieldYSize{$name};
	return $x, $y;
}
sub getShieldId{	my $name = shift;
	return $createdShields{$name};
}
# --------------------------------------------------------------------

sub createLegendFile{	my($x, $y, $extension, $group)= @_;

	my $svgName = cv('out');
	$svgName =~ s/\.svg/$extension\.svg/i;	
	my $pngName = $svgName;
	$pngName =~ s/\.svg/\.png/i;
	my $pdfName = $svgName;
	$pdfName =~ s/\.svg/\.pdf/i;


	open(my $file, ">", $svgName)|| die "can't open legend svg output file $svgName\n";

	print $file "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n";
	print $file "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\" >\n";

	my $w = $x / 300 * 2.54; # cm
	my $h = $y / 300 * 2.54;

	my($svg)= "<svg version=\"1.1\" baseProfile=\"full\" xmlns=\"http://www.w3.org/2000/svg\" ";
	$svg .= "xmlns:xlink=\"http://www.w3.org/1999/xlink\" xmlns:ev=\"http://www.w3.org/2001/xml-events\" ";
	$svg .= "width=\"$w" . "cm\" height=\"$h" . "cm\" viewBox=\"0 0 $x $y\">\n";
	print $file $svg;

	print $file "<defs>\n";
	foreach(@{$svgLayer{'definitions'}}){print $file $_, "\n";}	print $file "</defs>\n";

	print $file "<use x=\"0\" y=\"0\" xlink:href=\"$group\" />\n";
	print $file "</svg>\n";
	close $file;

	if(cv('pdf')eq "1"){		print "creating pdf file $pdfName ...\n";
		`inkscape -A $pdfName $svgName`;
}
	if(cv('png')eq "1"){		my $dpi = cv('pngdpi');
		print "creating png file $pngName($dpi dpi)...\n";
		`inkscape --export-dpi=$dpi -e $pngName $svgName`;
}}
sub coordsOut{	my @points = @_;

	my $allOut = 0;

	my $outLeft = 1;
	my $outRight = 1;
	my $outTop = 1;
	my $outBottom = 1;

	for(my $i=0; $i < scalar(@points)- 1; $i += 2){		my $x = $points[$i];
		my $y = $points[$i+1];
		if($x >= 0){$outLeft = 0;}		if($x <= $sizeX){$outRight = 0;}		if($y >= 0){$outBottom = 0;}		if($y <= $sizeY){$outTop = 0;}}
	if(($outLeft)or($outRight)or($outTop)or($outBottom)){$allOut = 1;}
	return $allOut;
}
1;