Radreise-Wiki:Km.pl: Unterschied zwischen den Versionen

Aus Radreise-Wiki
 
(13 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 3: Zeile 3:
  perl km.pl Donau
  perl km.pl Donau


Das Skript berechnet die Kilometrierung und speichert das Ergebnis als Datei im Output-Verzeichis (siehe [[Radreise-Wiki:ini.pl|ini.pl]]). Diese Datei (z.B. "Donau.tx") kann mit einem UTF8-fähigen Editor geöffnet und direkt in das Edit-Fenster des Streckenartikels kopiert werden.
Das Skript berechnet die Kilometrierung des Roadbook und speichert das Ergebnis als Datei im Output-Verzeichnis (siehe [[Radreise-Wiki:ini.pl|ini.pl]]). Die Datei "Donau_new.tx" enthält das neue Roadbook und kann mit einem UTF8-fähigen Texteditor geöffnet und direkt in das Edit-Fenster des Streckenartikels kopiert werden.
 
Wenn man die Variable ''$changePlaceHm = 1'' setzt, werden sämtliche Orts-Höhenmeter über die Höhendaten des Tracks neu berechnet.
 
'''Quellcode des Skripts:'''


  <nowiki>
  <nowiki>
use strict;
use strict;
 
# Encoding Stuff
use Encode qw (encode decode);
use Encode qw(encode decode);
 
my $encoding = 'utf-8';
my $smoothAlt      = 6;
my $encOut;
my $changePlaceHm  =  1;
$encOut   = 'cp1252'; # Windows Ansi
my $changeDistHm   = 1;
$encOut  = 'cp850' ; # DOS Fenster
my $makeRetour    = 0; # not yet implemented
  use URI::Escape qw( uri_escape_utf8 );
my $verbose        = 0;
 
# Default Directories
#==================================
require "ini.pl";
# Default Settings and Subroutines
my ($baseDir, $outDir, $username, $password) = getIni();
push @INC, '.';
require "ini.pl";
my $routeFileName = "";
 
my ($baseDir, $outDir, $username, $password, $encoding, $encAnsi, $encOut) = getIni();
if ($#ARGV != -1) {
 
my $dir_txt  = "$baseDir/text";
$routeFileName = join " ", @ARGV;
my $dir_trk  = "$baseDir/tracks";
 
if ($routeFileName =~ / \($/) {
my ($routeFileName, $routeFileName_e) = get_routeFileName (@ARGV);
 
$routeFileName .= "retour)";
my ($track, $rawTrack) = get_trackfile ($dir_trk, $routeFileName);
}
 
my @track    = @$track;
} else {
my @rawTrack = @$rawTrack;
 
my @content;
#====================
# Glättung der Höhen
open FIN, "$baseDir/RouteList.txt" or die "$! : $baseDir/RouteList.txt";
 
while (<FIN>) { push @content, decode $encoding, $_; }
for (my $j = 1; $j <= $smoothAlt; $j++) {
close (FIN);
for (my $i = 1; $i < $#track ; $i++) {
 
my @content_s = reverse sort @content;
my $avgAlt = ($track[$i-1][2] + $track[$i][2] + $track[$i+1][2]) / 3;
my ($dateTXT, $dateKML, $type, $name, $url) = split " :: ", $content_s[0];
$track[$i][2] = $avgAlt;
}
$routeFileName = $name;
}
}
 
#======================
my $routeFileName_e = encode 'cp1252', $routeFileName;
# Tracklänge berechnen
#===================
my $length = 0;
# Reading Trackfile
 
for (my $i = 0; $i < $#track ; $i++) {
print encode $encOut, "\nReading $routeFileName:\n\n";
 
my $dist = getDistance (  
open FIN, "$baseDir/tracks/$routeFileName_e.txt" or die "$! : $baseDir/tracks/$routeFileName_e.txt";
my $rawTrack = <FIN>;
$track[$i][0],  
close (FIN);
$track[$i][1],
$track[$i+1][0],  
my @rawTrack = split " ", $rawTrack;
$track[$i+1][1]
my @track = ();
);
foreach (@rawTrack) {
$length += $dist / 1000;
}
my ($lon, $lat, $alt) = split ",";
 
#=============================
my @zeile    = ( $lat, $lon, $alt );
# Gesamt-Höhenmeter berechnen
my $ref_zeile = \@zeile;
 
my ($HmSumUp, $HmSumDn) = getHmSum (0, $#track);
push @track, $ref_zeile;
 
}
#=============================
# Ausgabe der Track-Statistik
#==========================
 
# x-fache Glättung der Höhen
my $length_s = sprintf "%0.0f", $length;
my $HmSumUp_s = sprintf "%0.0f", $HmSumUp;
for (my $j = 1; $j <= 12; $j++) {
my $HmSumDn_s = sprintf "%0.0f", $HmSumDn;
for (my $i = 1; $i < $#track ; $i++) {
 
printf "Trackpunkte : %6d pt\n",  $#track + 1;
my $avgAlt = ($track[$i-1][2] + $track[$i][2] + $track[$i+1][2]) / 3;
print encode $encOut, "| Länge = $length_s\n";
print encode $encOut, "| Höhenmeter (auf) = $HmSumUp_s<!-- Glättungsfaktor = $smoothAlt -->\n";
$track[$i][2] = $avgAlt;
print encode $encOut, "| Höhenmeter (ab) = $HmSumDn_s\n";
 
}
# ==============
}
# Get Routefile
 
#=====================
my ($fileContent, $pre_Roadbook, $Roadbook, $post_Roadbook) =  
# Tracklänge berechnen
 
get_routefile ($dir_txt, $routeFileName);
my $length_0 = getDistance (
 
if ($fileContent =~ /ERROR/) {
$track[0][0],           # Erster Punkt : lat
 
$track[0][1],          # Erster Punkt : lon
die "$routeFileName not existent\n";
$track[$#rawTrack][0],  # Letzter Punkt: lat
}
$track[$#rawTrack][1]  # Letzter Punkt: lon
 
);
my @Roadbook = split "\n", $Roadbook;
 
my $length_1 = 0;
# ===============
# Get Placemarks
for (my $i = 0; $i < $#track ; $i++) {
 
my ($PlacemarksRaw, $Placemarks) = get_placemarks (@Roadbook);
my $dist = getDistance (  
 
my @Placemarks = @$PlacemarksRaw;
$track[$i][0],  
 
$track[$i][1],
my @placeName;
$track[$i+1][0],
 
$track[$i+1][1]
my @touriInfo;
);
 
my @geodaten;
$length_1 += $dist;
my @geodaten_lat;
}
my @geodaten_lon;
 
#=============================
my @geodaten_alt;
# Gesamt-Höhenmeter berechnen
my @geodaten_alt_real;
my @geodaten_alt_res;
my ($HmSumUp, $HmSumDn) = getHmSum (0, $#track);
 
my @geodaten_info;
#=============================
my @geodaten_nearest_tp;
# Ausgabe der Track-Statistik
my @geodaten_dist_to_tp;
 
print  "Trackpunkte : ", $#track + 1, "\n";
my @roadInfo;
printf "Luftlinie  : %4.0f km\n", $length_0;
 
printf "Strecke    : %4.0f km\n", $length_1;
my @kilometrierung;
#unless ($length_0) { printf "Ratio      : %6.1f\n",    $length_1 / $length_0; }
 
printf "Hm auf      : %4.0f m\n",  $HmSumUp;
my @kilometrierung_km;
printf "Hm ab      : %4.0f m\n\n",$HmSumDn;
my @kilometrierung_km_real;
my @kilometrierung_km_res;
# ============================
 
# Get $routeFileName Textfile
my @kilometrierung_km_sum;
my @kilometrierung_km_sum_real;
my $ucontent = "";
my @kilometrierung_km_sum_res;
open FILE, "$baseDir/text/$routeFileName_e.txt" or die "$baseDir/text/$routeFileName_e.txt: $!";
 
while (<FILE>) { $ucontent .= $_; }
my @kilometrierung_hmup;
close FILE;
my @kilometrierung_hmup_real;
my $fileContent = decode ($encoding, $ucontent);
my @kilometrierung_hmup_res;
 
# ============
my @kilometrierung_hmup_sum;
# Get Infobox
my @kilometrierung_hmup_sum_real;
my @kilometrierung_hmup_sum_res;
if ( $fileContent =~ /(\{\{Infobox.*?\}\})/s ) {
 
my @kilometrierung_hmdn;
my $infobox  = $1;
my @kilometrierung_hmdn_real;
my @kilometrierung_hmdn_res;
print encode $encOut, "$infobox\n\n";
 
my @kilometrierung_hmdn_sum;
}
my @kilometrierung_hmdn_sum_real;
my @kilometrierung_hmdn_sum_res;
# =============
 
# Get Roadbook
my @rest;
 
my $pre_Roadbook;
# =================================
my $Roadbook;
# Check Placemarks except last one
my $post_Roadbook;
 
for (my $i = 0; $i < $#Placemarks; $i++) {
if ( $fileContent =~ /(.*?== Roadbook ==.*?)(===.*?)(\n== .*)/s ) {
 
my ($placeName, $touriInfo, $geodaten, $roadInfo, $kilometrierung, $rest) = get_placemarkData ($Placemarks[$i]);
$pre_Roadbook  = $1;
 
$Roadbook      = $2;
if ($placeName) {
$post_Roadbook = $3;
 
if ($verbose) { print encode $encOut, "$placeName\n"; }
} else { die "Wrong Roadbook Format\n"; }
#print encode $encOut, "\n";
#print encode $encOut, "  $geodaten\n";
my @Roadbook = split "\n", $Roadbook;
#print encode $encOut, "   $kilometrierung\n";
#print encode $encOut, "\n";
# ===============
 
# Get Placemarks
push @placeName, $placeName;
push @touriInfo, $touriInfo;
my @Placemarks    = ();
push @geodaten, $geodaten;
my $placemark    = "";
push @roadInfo, $roadInfo;
my @PlacemarksRaw = ();
push @kilometrierung, $kilometrierung;
my $placemarkRaw  = "";
push @rest, $rest;
 
foreach my $line (@Roadbook) {
} else { die "ERROR in get_placemarkData\n"; }
 
if ($line =~ /^=== .* ===$/) {
 
# ===============
if ($placemark ne "") {
# Check Geodaten
 
push @Placemarks  , $placemark;  
my ($lat, $lon, $alt, $info) = get_geodaten ($geodaten[$i]);
push @PlacemarksRaw, $placemarkRaw;
 
}
if ($lat) {
 
$placemarkRaw  = "$line\n";
my ($trackPoint, $distance) = getClosestPoint ( $lat, $lon, \@track );
$placemark    =  $line  ;
 
#print encode $encOut, "   $lat\n";
} else {
#print encode $encOut, "  $lon\n";
#print encode $encOut, "   $alt\n";
$placemarkRaw .= "$line\n";
#print encode $encOut, "  $trackPoint\n";
$placemark    .=  $line  ;
#print encode $encOut, "   $distance\n";
}
#print encode $encOut, "\n";
}
 
push @geodaten_lat, $lat;
push @Placemarks  , $placemark;
push @geodaten_lon, $lon;
push @PlacemarksRaw, $placemarkRaw;
push @geodaten_alt, $alt;
push @geodaten_alt_real, sprintf "%.0f", $track[$trackPoint][2];
# =================
push @geodaten_alt_res, $alt;
# Check Placemarks
push @geodaten_info, $info;
push @geodaten_nearest_tp, $trackPoint;
my @PlaceName ;
push @geodaten_dist_to_tp, $distance;
my @TouriInfo ;
 
my @GeoData  ;
} else { die "ERROR in get_geodaten\n"; }
my @TrackPoint;
 
my @Distance  ;
# =====================
my @RoadInfo  ;
# Check Kilometrierung
my @Kilometer ;
 
my @RealKilo  ;
my ($km, $km_sum, $hmup, $hmdn, $hmup_sum, $hmdn_sum) = get_kilometrierung ($kilometrierung[$i]);
 
for (my $i=0; $i<=$#Placemarks; $i++) {
if ($verbose) { print encode $encOut, "$kilometrierung[$i]\n"; }
 
my $placeName;
if ($km ne "x") {
my $touriInfo;
 
my $geoData  ;
#print encode $encOut, "  $km\n";
my $roadInfo ;
#print encode $encOut, "  $sum\n";
my $kilometer;
#print encode $encOut, "  $hmup\n";
my $rest;
#print encode $encOut, "  $hmdn\n";
#print encode $encOut, "\n";
my $lat;
 
my $lon;
push @kilometrierung_km,        $km;
my $alt;
push @kilometrierung_km_res,    $km;
my $info;
 
push @kilometrierung_km_sum,    $km_sum;
my $deltaKilo;
push @kilometrierung_km_sum_res, $km_sum;
my $sumKilo;
 
push @kilometrierung_hmup,      $hmup;
if ( $Placemarks[$i] =~ /
push @kilometrierung_hmup_res,  $hmup;
 
^===\ (.*)\ ===                # placeName
push @kilometrierung_hmdn,      $hmdn;
(.*)                          # touriInfo
push @kilometrierung_hmdn_res,  $hmdn;
{{Geodaten\|(.*)}}            # geoData
 
(.*)                          # roadInfo
push @kilometrierung_hmup_sum,    $hmup_sum;
{{Kilometrierung[Hm]*\|(.*)}}(.*)$ # kilometer
push @kilometrierung_hmup_sum_res, $hmup_sum;
/x ) {
 
push @kilometrierung_hmdn_sum,    $hmdn_sum;
$placeName = $1;
push @kilometrierung_hmdn_sum_res, $hmdn_sum;
$touriInfo = $2;
 
$geoData  = $3;
} else {
$roadInfo  = $4;
print encode $encOut, "ERROR in get_kilometrierung: $placeName[$i]\n";
$kilometer = $5;
die;
$rest      = $6;
}
 
# ===============
}
# Check: geoData
 
# =====================
if ($geoData =~ /^([-]?\d+\.\d+)\|([-]?\d+\.\d+)\|([-]?\d+)\|([^\|]+)$/) {
# Check last Placemark
 
$lat  = $1;
my ($placeName, $touriInfo, $geodaten, $roadInfo) = get_lastPlacemarkData ($Placemarks[$#Placemarks]);
$lon  = $2;
 
$alt  = $3;
if ($placeName) {
$info = $4;
 
#print encode $encOut, "$placeName\n";
} else {
#print encode $encOut, "\n";
print "Error in geoData: $geoData\n";
#print encode $encOut, "  $geodaten\n";
exit;
#print encode $encOut, "\n";
}
 
   
push @placeName, $placeName;
# =================
push @touriInfo, $touriInfo;
# Check: Kilometer
push @geodaten, $geodaten;
   
push @roadInfo, $roadInfo;
if ($kilometer =~ /([\d,]+)\|([\d]+)/) {
push @kilometrierung, "";
push @rest,          "";
$deltaKilo = $1;
 
$sumKilo  = $2;
push @kilometrierung_km,        "";
push @kilometrierung_km_res,    "";
} else {
 
print "Error in kilometer: $kilometer\n";
push @kilometrierung_km_sum,    "";
exit;
push @kilometrierung_km_sum_res, "";
}
 
push @kilometrierung_hmup,      "";
} elsif (( $i == $#Placemarks ) and ( $Placemarks[$i] =~ /
push @kilometrierung_hmup_res,  "";
 
^===\ (.*)\ ===              # placeName
push @kilometrierung_hmdn,      "";
(.*)                        # touriInfo
push @kilometrierung_hmdn_res,  "";
{{Geodaten\|(.*)}}          # geoData
 
(.*)                        # roadInfo
push @kilometrierung_hmup_sum,    "";
/x )) {
push @kilometrierung_hmup_sum_res, "";
 
$placeName = $1;
push @kilometrierung_hmdn_sum,    "";
$touriInfo = $2;
push @kilometrierung_hmdn_sum_res, "";
$geoData  = $3;
 
$roadInfo  = $4;
} else { die "ERROR in get_lastPlacemarkData\n"; }
 
# ===============
# =================================
# Check: geoData
# Check Geodaten of last Placemark
 
if ($geoData =~ /(.*)\|(.*)\|(.*)\|(.*)/) {
my ($lat, $lon, $alt, $info) = get_geodaten ($geodaten[$#geodaten]);
 
$lat  = $1;
if ($lat) {
$lon  = $2;
 
$alt  = $3;
my ($trackPoint, $distance) = getClosestPoint ( $lat, $lon, \@track );
$info = $4;
 
#print encode $encOut, "   $lat\n";
} else {
#print encode $encOut, "  $lon\n";
print "Error in geoData: $geoData\n";
#print encode $encOut, "   $alt\n";
exit;
#print encode $encOut, "  $trackPoint\n";
}
#print encode $encOut, "  $distance\n";
#print encode $encOut, "\n";
# ==================
 
# Kilometer Dummies
push @geodaten_lat, $lat;
push @geodaten_lon, $lon;
$deltaKilo = "  ";
push @geodaten_alt, $alt;
$sumKilo   = " ";
push @geodaten_alt_real, sprintf "%.0f", $track[$trackPoint][2];
push @geodaten_alt_res, $alt;
} elsif ( $Placemarks[$i] =~ /
push @geodaten_info, $info;
push @geodaten_nearest_tp, $trackPoint;
^===\ (.*)\ ===              # placeName
push @geodaten_dist_to_tp, $distance;
(.*)                        # touriInfo
 
{{Geodaten\|(.*)}}          # geoData
} else { die "ERROR in get_geodaten\n"; }
(.*)                        # roadInfo
 
/x ) {
# =========================
# Calculate real Distances
$placeName = $1;
 
$touriInfo = $2;
my $sum_real;
$geoData  = $3;
 
$roadInfo  = $4;
for (my $i=0; $i < $#Placemarks; $i++) {
 
# ===============
my $km_real;
# Check: geoData
 
for (my $j = $geodaten_nearest_tp[$i]; $j < $geodaten_nearest_tp[$i+1] ; $j++) {
if ($geoData =~ /(.*)\|(.*)\|(.*)\|(.*)/) {
 
my $dist = getDistance ( $track[$j][0], $track[$j][1], $track[$j+1][0], $track[$j+1][1] ) / 1000;
$lat  = $1;
 
$lon  = $2;
$km_real += $dist;
$alt  = $3;
}
$info = $4;
 
$sum_real += $km_real;
} else {
 
print "Error in geoData: $geoData\n";
push @kilometrierung_km_real, sprintf "%.1f", $km_real;
exit;
push @kilometrierung_km_sum_real, sprintf "%.0f", $sum_real;
}
}
 
# ==================
push @kilometrierung_km_real, "";
# Kilometer Dummies
push @kilometrierung_km_sum_real, "";
 
$deltaKilo = "x,x";
 
$sumKilo  = "x";
# ==========================
# Calculate real Höhenmeter
} else {
 
my $sum_hmup;
print encode $encoding, "Untreated Error: $Placemarks[$i]\n";
my $sum_hmdn;
exit;
 
}
for (my $i=0; $i < $#Placemarks; $i++) {
 
my ($trackPoint, $distance) = getClosestPoint ( $lat, $lon );
my ($hmup, $hmdn) = getHmSum ($geodaten_nearest_tp[$i], $geodaten_nearest_tp[$i+1]);
 
if ($distance < 200) {
$sum_hmup += $hmup;
$sum_hmdn += $hmdn;
#$distance = "   ";
 
push @kilometrierung_hmup_real, sprintf "%.0f", $hmup;
} else { $distance .= "!!!"; }
push @kilometrierung_hmdn_real, sprintf "%.0f", $hmdn;
push @kilometrierung_hmup_sum_real, sprintf "%.0f", $sum_hmup;
push @PlaceName , $placeName;
push @kilometrierung_hmdn_sum_real, sprintf "%.0f", $sum_hmdn;
push @TouriInfo , $touriInfo;
}
push @GeoData  , sprintf "%10.7f %10.7f", $lat, $lon;
 
push @TrackPoint, sprintf "%5d", $trackPoint;
push @kilometrierung_hmup_real, "";
push @Distance  , sprintf "%3.0f m", $distance;
push @kilometrierung_hmdn_real, "";
push @RoadInfo  , $roadInfo;
push @kilometrierung_hmup_sum_real, "";
push @Kilometer , sprintf "%4s %4s", $deltaKilo, $sumKilo;
push @kilometrierung_hmdn_sum_real, "";
}
 
 
# =========================
# =====================================
# Calculate real Distances
# Check ascending order of TrackPoints
 
my $sum;
for (my $i=0; $i<$#Placemarks; $i++) {
my $HmTotSumUp;
 
my $HmTotSumDn;
if ( $geodaten_nearest_tp[$i] <= $geodaten_nearest_tp[$i+1] ) {
 
for (my $i=0; $i < $#Placemarks; $i++) {
#ok
 
my $length;
} else {
 
for (my $j = $TrackPoint[$i]; $j < $TrackPoint[$i+1] ; $j++) {
print encode $encOut, "ERROR: Wrong TrackPoint Order in:\n";
print encode $encOut, "   $placeName[$i] :: $geodaten_nearest_tp[$i]\n";
my $dist = getDistance ( $track[$j][0], $track[$j][1], $track[$j+1][0], $track[$j+1][1] );
print encode $encOut, "  $placeName[$i+1] :: $geodaten_nearest_tp[$i+1]\n\n";
}
$length += $dist;
}
}
 
# ===================
$sum += $length;
# Summarize all Data
 
my $realKilo = sprintf "%4.1f %4.0f", $length, $sum;
my $output = sprintf "%5s  %3s %4s %5s %5s %5s %5s %5s  %s",
 
$realKilo =~ s/\./,/;
"tp#",
"dist",
if ($Kilometer[$i] eq $realKilo) {
"k",
$realKilo      = "        ";
"k_s",
$Kilometer[$i] = "        ";
"k_r",
}
"k_s_r",
"a",
push @RealKilo, $realKilo;
"a_r",
"place";
my ($HmSumUp, $HmSumDn) = getHmSum ($TrackPoint[$i], $TrackPoint[$i+1]);
 
if ($verbose) { print encode $encOut, "$output\n"; }
printf "%s;%0.0f;%0.0f;%0.0f;%0.0f\n", encode ($encOut, $PlaceName[$i]),$length,$HmSumUp,$HmSumDn,$track[$TrackPoint[$i]][2];
 
for (my $i=0; $i <= $#Placemarks; $i++) {
$HmTotSumUp += $HmSumUp;
 
$HmTotSumDn += $HmSumDn;
my $output = sprintf "%5d %3.0f m %4s %5s %5s %5s %5s %5s  %s",
}
 
$geodaten_nearest_tp[$i],
push @RealKilo, "         ";
$geodaten_dist_to_tp[$i],
$kilometrierung_km[$i],
printf "GesamtHm: %0.0f;%0.0f\n", $HmTotSumUp,$HmTotSumDn;
$kilometrierung_km_sum[$i],
$kilometrierung_km_real[$i],
print "\n";
$kilometrierung_km_sum_real[$i],
$geodaten_alt[$i],
# =====================================
$geodaten_alt_real[$i],
# Check ascending order of TrackPoints
$placeName[$i];
for (my $i=0; $i<$#Placemarks; $i++) {
if ($verbose) { print encode $encOut, "$output\n"; }
}
if ( $TrackPoint[$i] <= $TrackPoint[$i+1] ) {
 
if ($verbose) { print encode $encOut, "\n"; }
#ok
 
# ==================
} else {
# Summarize Changes
 
print encode $encOut, "Error: Wrong TrackPoint Order in:\n";
my $change;
print encode $encOut, "$PlaceName[$i] :: $GeoData[$i] :: $TrackPoint[$i]\n";
 
print encode $encOut, "$PlaceName[$i+1] :: $GeoData[$i+1] :: $TrackPoint[$i+1]\n";
my $output = sprintf "%5s  %3s %4s %5s %5s %5s %5s %5s  %s",
 
#exit(1);
"tp#",
}
"dist",
}
"k",
"k_s",
# =====================
"k_r",
# Show Change Overview
"k_s_r",
"a",
for (my $i=0; $i<=$#Placemarks; $i++) {
"a_r",
"place";
my $s = sprintf "%s %s %s %s %s\n",
 
$TrackPoint[$i], $Distance[$i], $Kilometer[$i],
print encode $encOut, "$output\n";
$RealKilo[$i], substr($PlaceName[$i], 0, 52);
 
for (my $i=0; $i <= $#Placemarks; $i++) {
print encode $encOut, $s;
 
}
$kilometrierung_km_real[$i] =~ s/\./\,/;
print "\n";
 
if ($kilometrierung_km[$i] eq $kilometrierung_km_real[$i]) {
# ======================
 
# Perform Changes on File
$kilometrierung_km[$i] = "";
$kilometrierung_km_real[$i] = "";
my $change = 0;
 
} else {
for (my $i=0; $i<=$#Placemarks; $i++) {
$kilometrierung_km_res[$i] = $kilometrierung_km_real[$i];
if ( $RealKilo[$i] !~ /^\s*$/ ) {
$change = 1;
}
print encode $encOut, "Change: $PlaceName[$i]\n";
 
if ($kilometrierung_km_sum[$i] eq $kilometrierung_km_sum_real[$i]) {
my $deltaKiloNew;
 
my $sumKiloNew;
$kilometrierung_km_sum[$i] = "";
$kilometrierung_km_sum_real[$i] = "";
if ( $RealKilo[$i] =~ /^\s*([0-9,]+)\s+([0-9]+)$/ ) {
 
} else {
$deltaKiloNew = $1;
$sumKiloNew  = $2;
$kilometrierung_km_sum_res[$i] = $kilometrierung_km_sum_real[$i];
$change = 1;
} else {
}
 
print "  No Match: >$RealKilo[$i]<\n";
if ($changePlaceHm) {
exit;
 
}
if ($geodaten_alt[$i] eq $geodaten_alt_real[$i]) {
 
my $deltaKiloOld;
$geodaten_alt[$i] = "";
my $sumKiloOld;
$geodaten_alt_real[$i] = "";
 
if ( $Kilometer[$i] =~ /^\s*([0-9,]+)\s+([0-9]+)$/ ) {
} else {
$deltaKiloOld = $1;
$geodaten_alt_res[$i] = $geodaten_alt_real[$i];
$sumKiloOld  = $2;
$change = 1;  
}
if ($fileContent =~
 
s/{{Kilometrierung\|$deltaKiloOld\|$sumKiloOld}}/{{Kilometrierung\|$deltaKiloNew\|$sumKiloNew}}/s) {
} else {
 
print "  $deltaKiloOld->$deltaKiloNew\n";
$geodaten_alt[$i] = "";
print "   $sumKiloOld->$sumKiloNew\n";
$geodaten_alt_real[$i] = "";
}
$change = 1;
 
if ($changeDistHm) {
} else {
 
if ($kilometrierung_hmdn[$i] eq $kilometrierung_hmdn_real[$i]) {
print "   No Match in km!\n";
 
exit;
$kilometrierung_hmdn[$i] = "";
}
$kilometrierung_hmdn_real[$i] = "";
 
} elsif ( $Kilometer[$i] =~ /^\s*x,x\s+x$/ ) {
} else {
if ($fileContent =~
$kilometrierung_hmdn_res[$i] = $kilometrierung_hmdn_real[$i];
s/=== $PlaceName[$i+1] ===/{{Kilometrierung\|$deltaKiloNew\|$sumKiloNew}}\n\n=== $PlaceName[$i+1] ===/s) {
$change = 1;
}
print "   No Kilometrierung ->$deltaKiloNew\n";
 
print "  No Kilometrierung ->$sumKiloNew\n";
if ($kilometrierung_hmup[$i] eq $kilometrierung_hmup_real[$i]) {
 
$change = 1;
$kilometrierung_hmup[$i] = "";
$kilometrierung_hmup_real[$i] = "";
} else {
 
} else {
print "  No Match! $PlaceName[$i+1]\n{{Kilometrierung\|$deltaKiloNew\|$sumKiloNew}}\n";
#exit;
$kilometrierung_hmup_res[$i] = $kilometrierung_hmup_real[$i];
}
$change = 1;  
}
} else {
 
if ($kilometrierung_hmup_sum[$i] eq $kilometrierung_hmup_sum_real[$i]) {
print "   No Match: >$Kilometer[$i]<\n";
 
exit;
$kilometrierung_hmup_sum[$i] = "";
}
$kilometrierung_hmup_sum_real[$i] = "";
 
}
} else {
}
$kilometrierung_hmup_sum_res[$i] = $kilometrierung_hmup_sum_real[$i];
if ($change) {
$change = 1;  
}
open  FOUT, "> $outDir/${routeFileName_e}_new.tx" or die $!;
 
print FOUT encode ($encoding, $fileContent);
if ($kilometrierung_hmdn_sum[$i] eq $kilometrierung_hmdn_sum_real[$i]) {
close FOUT;
 
$kilometrierung_hmdn_sum[$i] = "";
}
$kilometrierung_hmdn_sum_real[$i] = "";
 
# ==================================
} else {
# Generate Retour-Roadbook with Track
$kilometrierung_hmdn_sum_res[$i] = $kilometrierung_hmdn_sum_real[$i];
my $content;
$change = 1;  
}
$content .= "{{Tour|$routeFileName}}\n\n";
 
$content .= $pre_Roadbook;
} else {
}
for (my $i=$#Placemarks; $i>=0; $i--) {
 
my $output = sprintf "%5d %3.0f m %4s %5s %5s %5s %5s %5s  %s",
my $placemark = $PlacemarksRaw[$i];
 
$geodaten_nearest_tp[$i],
if ( $placemark =~ /(.+{{Geodaten.*?}})/s ) {
$geodaten_dist_to_tp[$i],
$kilometrierung_km[$i],
$placemark = $1;
$kilometrierung_km_sum[$i],
$kilometrierung_km_real[$i],
} else {
$kilometrierung_km_sum_real[$i],
$geodaten_alt[$i],
print "No match in Placemark: $placemark\n";
$geodaten_alt_real[$i],
exit;
$placeName[$i];
}
print encode $encOut, "$output\n";
if ($i > 0) { $placemark .= "\n\n{{Kilometrierung|0,0|0}}\n"; }
}
 
$content .= "$placemark\n";
# ======================
}
# Write Changes to File
 
$content .= $post_Roadbook;
 
if ($change) {
$content =~ s/\n\n\n/\n\n/g;
 
$fileContent = "";
$rawTrack = join " ", reverse @rawTrack;
 
$fileContent .= $pre_Roadbook;
$content .= "\n$routeFileName (retour) :: $routeFileName\_%28retour%29 :: $rawTrack\n";
 
 
open  FOUT, "> $outDir/${routeFileName_e}_ret.tx" or die $!;
for (my $i=0; $i < $#Placemarks; $i++) {
print FOUT encode ($encoding, $content);
 
close FOUT;
$fileContent .= "=== $placeName[$i] ===\n";
$fileContent .= "$touriInfo[$i]\n";
exit;
$fileContent .= "{{Geodaten|$geodaten_lat[$i]|$geodaten_lon[$i]|$geodaten_alt_res[$i]|$geodaten_info[$i]}}\n";
$fileContent .= "$roadInfo[$i]\n";
#==========================================================
 
#==========================================================
if ($kilometrierung[$i] =~ /KilometrierungHm6/) {
 
sub getDistance {
$fileContent .= "{{KilometrierungHm6|$kilometrierung_km_res[$i]|$kilometrierung_hmup_res[$i]|$kilometrierung_hmdn_res[$i]|$kilometrierung_km_sum_res[$i]|$kilometrierung_hmup_sum_res[$i]|$kilometrierung_hmdn_sum_res[$i]}}";
 
use POSIX qw(acos);
} elsif ($kilometrierung[$i] =~ /KilometrierungHm/) {
 
my ($tp1_lat, $tp1_lon, $tp2_lat, $tp2_lon) = @_;
$fileContent .= "{{KilometrierungHm|$kilometrierung_km_res[$i]|$kilometrierung_km_sum_res[$i]|$kilometrierung_hmup_sum_res[$i]|$kilometrierung_hmdn_sum_res[$i]}}";
 
my $PI = 3.1415926;
} else {
 
my $lat1 = $tp1_lat / 180 * $PI;
$fileContent .= "{{Kilometrierung|$kilometrierung_km_res[$i]|$kilometrierung_km_sum_res[$i]}}";
my $lon1 = $tp1_lon / 180 * $PI;
}
my $lat2 = $tp2_lat / 180 * $PI;
 
my $lon2 = $tp2_lon / 180 * $PI;
$fileContent .= "\n$rest[$i]";
}
my $val = sin($lat1) * sin($lat2) +
 
  cos($lat1) * cos($lat2) *
$fileContent .= "=== $placeName[$#Placemarks] ===\n";
  cos($lon2-$lon1);
$fileContent .= "$touriInfo[$#Placemarks]\n";
$fileContent .= "{{Geodaten|$geodaten_lat[$#Placemarks]|$geodaten_lon[$#Placemarks]|$geodaten_alt_res[$#Placemarks]|$geodaten_info[$#Placemarks]}}\n";
if ($val > +1) {  
$fileContent .= "$roadInfo[$#Placemarks]";
$val = +1;  
 
#print "  ACOS-Error: $tp1_lon,$tp1_lat !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
$fileContent .= $post_Roadbook;
}
if ($val < -1) {
open  FOUT, "> $outDir/${routeFileName_e}_new.tx" or die $!;
$val = -1;
print FOUT encode ($encoding, $fileContent);
#print "  ACOS-Error: $tp1_lon,$tp1_lat !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
close FOUT;
}
 
}
my $dist = acos($val) * 6378.137;      # radius of the equator in km
 
exit;
#if (Double.isNaN(dist)) dist = 0;
 
 
return $dist;
#==========================================================
}
#==========================================================
 
#==========================================================
sub getHmSum {
 
sub getClosestPoint {
my ($tp_begin, $tp_end) = @_;
 
my ($tp_lat, $tp_lon) = @_;
if ($tp_end >= $#track) { $tp_end = $#track-1; }
 
my $minDist = 111111111;
my $HmSumUp = 0;
my $point  = -1;
my $HmSumDn = 0;
for (my $i = 0; $i <= $#track ; $i++) {
for (my $i = $tp_begin; $i <= $tp_end ; $i++) {
 
my $dist = getDistance ( $track[$i][0], $track[$i][1], $tp_lat, $tp_lon );
my $alt_0 = $track[$i][2];
my $alt_1 = $track[$i+1][2];
if ($dist < $minDist) {
my $diff  = $alt_1 - $alt_0;
$minDist = $dist;
 
$point  = $i;
if ($diff < 0) { $HmSumDn += $diff * (-1); }
}
if ($diff > 0) { $HmSumUp += $diff * (+1); }
}
 
}
return ($point, $minDist*1000);
 
}
return ($HmSumUp, $HmSumDn);
}
#==========================================================
</nowiki>
 
sub getHmSum {
[[Kategorie: Verwaltungs-Software]]
my ($tp_begin, $tp_end) = @_;
if ($tp_end >= $#track) { $tp_end = $#track-1; }
my $HmSumUp = 0;
my $HmSumDn = 0;
for (my $i = $tp_begin; $i <= $tp_end ; $i++) {
my $alt_0 = $track[$i][2];
my $alt_1 = $track[$i+1][2];
my $diff  = $alt_1 - $alt_0;
if ($diff < 0) { $HmSumDn += $diff * (-1); }
if ($diff > 0) { $HmSumUp += $diff * (+1); }
}
return ($HmSumUp, $HmSumDn);
}
</nowiki>

Aktuelle Version vom 12. Januar 2018, 18:23 Uhr

Das Perl-Skript km.pl wird mit dem Streckennamen als Parameter aufgerufen. Die zugehörige Streckendatei muss bereits im text- und die Trackdatei im track-Verzeichnis vorhanden sein. Beispiel für einen Aufruf: 

perl km.pl Donau

Das Skript berechnet die Kilometrierung des Roadbook und speichert das Ergebnis als Datei im Output-Verzeichnis (siehe ini.pl). Die Datei "Donau_new.tx" enthält das neue Roadbook und kann mit einem UTF8-fähigen Texteditor geöffnet und direkt in das Edit-Fenster des Streckenartikels kopiert werden.

Wenn man die Variable $changePlaceHm = 1 setzt, werden sämtliche Orts-Höhenmeter über die Höhendaten des Tracks neu berechnet.

Quellcode des Skripts: 

use strict;

use Encode qw (encode decode);

my $smoothAlt      =  6;
my $changePlaceHm  =  1;
my $changeDistHm   =  1;
my $makeRetour     =  0; # not yet implemented
my $verbose        =  0;

#==================================
# Default Settings and Subroutines
push @INC, '.';
require "ini.pl";

my ($baseDir, $outDir, $username, $password, $encoding, $encAnsi, $encOut) = getIni();

my $dir_txt   = "$baseDir/text";
my $dir_trk   = "$baseDir/tracks";

my ($routeFileName, $routeFileName_e) = get_routeFileName (@ARGV);

my ($track, $rawTrack) = get_trackfile ($dir_trk, $routeFileName);

my @track    = @$track;
my @rawTrack = @$rawTrack;

#====================
# Glättung der Höhen

for (my $j = 1; $j <= $smoothAlt; $j++) {
	for (my $i = 1; $i < $#track ; $i++) {

		my $avgAlt = ($track[$i-1][2] + $track[$i][2] + $track[$i+1][2]) / 3;
		
		$track[$i][2] = $avgAlt;
	}
}

#======================
# Tracklänge berechnen
	
my $length = 0;

for (my $i = 0; $i < $#track ; $i++) {	

	my $dist = getDistance ( 
	
		$track[$i][0], 
		$track[$i][1], 
		$track[$i+1][0], 
		$track[$i+1][1] 
	);
		
	$length += $dist / 1000;
}

#=============================
# Gesamt-Höhenmeter berechnen

my ($HmSumUp, $HmSumDn) = getHmSum (0, $#track);

#=============================
# Ausgabe der Track-Statistik

my $length_s = sprintf "%0.0f", $length;
my $HmSumUp_s = sprintf "%0.0f", $HmSumUp;
my $HmSumDn_s = sprintf "%0.0f", $HmSumDn;

printf "Trackpunkte : %6d pt\n",   $#track + 1;
print encode $encOut, "| Länge = $length_s\n";
print encode $encOut, "| Höhenmeter (auf) = $HmSumUp_s<!-- Glättungsfaktor = $smoothAlt -->\n";
print encode $encOut, "| Höhenmeter (ab) = $HmSumDn_s\n";

# ==============
# Get Routefile

my ($fileContent, $pre_Roadbook, $Roadbook, $post_Roadbook) = 

	get_routefile ($dir_txt, $routeFileName);

if ($fileContent =~ /ERROR/) {

	die "$routeFileName not existent\n";
}

my @Roadbook = split "\n", $Roadbook;

# ===============
# Get Placemarks

my ($PlacemarksRaw, $Placemarks) = get_placemarks (@Roadbook);

my @Placemarks = @$PlacemarksRaw;

my @placeName;

my @touriInfo;

my @geodaten;
my @geodaten_lat;
my @geodaten_lon;

my @geodaten_alt;
my @geodaten_alt_real;
my @geodaten_alt_res;

my @geodaten_info;
my @geodaten_nearest_tp;
my @geodaten_dist_to_tp;

my @roadInfo;

my @kilometrierung;

my @kilometrierung_km;
my @kilometrierung_km_real;
my @kilometrierung_km_res;

my @kilometrierung_km_sum;
my @kilometrierung_km_sum_real;
my @kilometrierung_km_sum_res;

my @kilometrierung_hmup;
my @kilometrierung_hmup_real;
my @kilometrierung_hmup_res;

my @kilometrierung_hmup_sum;
my @kilometrierung_hmup_sum_real;
my @kilometrierung_hmup_sum_res;

my @kilometrierung_hmdn;
my @kilometrierung_hmdn_real;
my @kilometrierung_hmdn_res;

my @kilometrierung_hmdn_sum;
my @kilometrierung_hmdn_sum_real;
my @kilometrierung_hmdn_sum_res;

my @rest;

# =================================
# Check Placemarks except last one

for (my $i = 0; $i < $#Placemarks; $i++) {

	my ($placeName, $touriInfo, $geodaten, $roadInfo, $kilometrierung, $rest) = get_placemarkData ($Placemarks[$i]);

	if ($placeName) {

		if ($verbose) { print encode $encOut, "$placeName\n"; }
		#print encode $encOut, "\n";
		#print encode $encOut, "   $geodaten\n";
		#print encode $encOut, "   $kilometrierung\n";
		#print encode $encOut, "\n";

		push @placeName, $placeName;
		push @touriInfo, $touriInfo;
		push @geodaten, $geodaten;
		push @roadInfo, $roadInfo;
		push @kilometrierung, $kilometrierung;
		push @rest, $rest;

	} else { die "ERROR in get_placemarkData\n"; }


	# ===============
	# Check Geodaten

	my ($lat, $lon, $alt, $info) = get_geodaten ($geodaten[$i]);

	if ($lat) {

		my ($trackPoint, $distance) = getClosestPoint ( $lat, $lon, \@track );

		#print encode $encOut, "   $lat\n";
		#print encode $encOut, "   $lon\n";
		#print encode $encOut, "   $alt\n";
		#print encode $encOut, "   $trackPoint\n";
		#print encode $encOut, "   $distance\n";
		#print encode $encOut, "\n";

		push @geodaten_lat, $lat;
		push @geodaten_lon, $lon;
		push @geodaten_alt, $alt;
		push @geodaten_alt_real, sprintf "%.0f", $track[$trackPoint][2];
		push @geodaten_alt_res, $alt;
		push @geodaten_info, $info;
		push @geodaten_nearest_tp, $trackPoint;
		push @geodaten_dist_to_tp, $distance;

	} else { die "ERROR in get_geodaten\n"; }

	# =====================
	# Check Kilometrierung

	my ($km, $km_sum, $hmup, $hmdn, $hmup_sum, $hmdn_sum) = get_kilometrierung ($kilometrierung[$i]);

	if ($verbose) { print encode $encOut, "$kilometrierung[$i]\n"; }

	if ($km ne "x") {

		#print encode $encOut, "   $km\n";
		#print encode $encOut, "   $sum\n";
		#print encode $encOut, "   $hmup\n";
		#print encode $encOut, "   $hmdn\n";
		#print encode $encOut, "\n";

		push @kilometrierung_km,         $km;
		push @kilometrierung_km_res,     $km;

		push @kilometrierung_km_sum,     $km_sum;
		push @kilometrierung_km_sum_res, $km_sum;

		push @kilometrierung_hmup,       $hmup;
		push @kilometrierung_hmup_res,   $hmup;

		push @kilometrierung_hmdn,       $hmdn;
		push @kilometrierung_hmdn_res,   $hmdn;

		push @kilometrierung_hmup_sum,     $hmup_sum;
		push @kilometrierung_hmup_sum_res, $hmup_sum;

		push @kilometrierung_hmdn_sum,     $hmdn_sum;
		push @kilometrierung_hmdn_sum_res, $hmdn_sum;

	} else {
		print encode $encOut, "ERROR in get_kilometrierung: $placeName[$i]\n";
		die;
	}

}

# =====================
# Check last Placemark

my ($placeName, $touriInfo, $geodaten, $roadInfo) = get_lastPlacemarkData ($Placemarks[$#Placemarks]);

if ($placeName) {

	#print encode $encOut, "$placeName\n";
	#print encode $encOut, "\n";
	#print encode $encOut, "   $geodaten\n";
	#print encode $encOut, "\n";

	push @placeName, $placeName;
	push @touriInfo, $touriInfo;
	push @geodaten,  $geodaten;
	push @roadInfo,  $roadInfo;
	push @kilometrierung, "";
	push @rest,           "";

	push @kilometrierung_km,         "";
	push @kilometrierung_km_res,     "";

	push @kilometrierung_km_sum,     "";
	push @kilometrierung_km_sum_res, "";

	push @kilometrierung_hmup,       "";
	push @kilometrierung_hmup_res,   "";

	push @kilometrierung_hmdn,       "";
	push @kilometrierung_hmdn_res,   "";

	push @kilometrierung_hmup_sum,     "";
	push @kilometrierung_hmup_sum_res, "";

	push @kilometrierung_hmdn_sum,     "";
	push @kilometrierung_hmdn_sum_res, "";

} else { die "ERROR in get_lastPlacemarkData\n"; }

# =================================
# Check Geodaten of last Placemark

my ($lat, $lon, $alt, $info) = get_geodaten ($geodaten[$#geodaten]);

if ($lat) {

	my ($trackPoint, $distance) = getClosestPoint ( $lat, $lon, \@track );

	#print encode $encOut, "   $lat\n";
	#print encode $encOut, "   $lon\n";
	#print encode $encOut, "   $alt\n";
	#print encode $encOut, "   $trackPoint\n";
	#print encode $encOut, "   $distance\n";
	#print encode $encOut, "\n";

	push @geodaten_lat, $lat;
	push @geodaten_lon, $lon;
	push @geodaten_alt, $alt;
	push @geodaten_alt_real, sprintf "%.0f", $track[$trackPoint][2];
	push @geodaten_alt_res, $alt;
	push @geodaten_info, $info;
	push @geodaten_nearest_tp, $trackPoint;
	push @geodaten_dist_to_tp, $distance;

} else { die "ERROR in get_geodaten\n"; }

# =========================
# Calculate real Distances

my $sum_real;

for (my $i=0; $i < $#Placemarks; $i++) {

	my $km_real;

	for (my $j = $geodaten_nearest_tp[$i]; $j < $geodaten_nearest_tp[$i+1] ; $j++) {

		my $dist = getDistance ( $track[$j][0], $track[$j][1], $track[$j+1][0], $track[$j+1][1] ) / 1000;

		$km_real += $dist;
	}

	$sum_real += $km_real;

	push @kilometrierung_km_real, sprintf "%.1f", $km_real;
	push @kilometrierung_km_sum_real, sprintf "%.0f", $sum_real;
}

push @kilometrierung_km_real, "";
push @kilometrierung_km_sum_real, "";


# ==========================
# Calculate real Höhenmeter

my $sum_hmup;
my $sum_hmdn;

for (my $i=0; $i < $#Placemarks; $i++) {

	my ($hmup, $hmdn) = getHmSum ($geodaten_nearest_tp[$i], $geodaten_nearest_tp[$i+1]);

	$sum_hmup += $hmup;
	$sum_hmdn += $hmdn;

	push @kilometrierung_hmup_real, sprintf "%.0f", $hmup;
	push @kilometrierung_hmdn_real, sprintf "%.0f", $hmdn;
	push @kilometrierung_hmup_sum_real, sprintf "%.0f", $sum_hmup;
	push @kilometrierung_hmdn_sum_real, sprintf "%.0f", $sum_hmdn;
}

push @kilometrierung_hmup_real, "";
push @kilometrierung_hmdn_real, "";
push @kilometrierung_hmup_sum_real, "";
push @kilometrierung_hmdn_sum_real, "";


# =====================================
# Check ascending order of TrackPoints

for (my $i=0; $i<$#Placemarks; $i++) {

	if ( $geodaten_nearest_tp[$i] <= $geodaten_nearest_tp[$i+1] ) {

		#ok

	} else {

		print encode $encOut, "ERROR: Wrong TrackPoint Order in:\n";
		print encode $encOut, "   $placeName[$i] :: $geodaten_nearest_tp[$i]\n";
		print encode $encOut, "   $placeName[$i+1] :: $geodaten_nearest_tp[$i+1]\n\n";
	}
}

# ===================
# Summarize all Data

my $output = sprintf "%5s  %3s %4s %5s %5s %5s %5s %5s  %s",

	"tp#",
	"dist",
	"k",
	"k_s",
	"k_r",
	"k_s_r",
	"a",
	"a_r",
	"place";

if ($verbose) { print encode $encOut, "$output\n"; }

for (my $i=0; $i <= $#Placemarks; $i++) {

	my $output = sprintf "%5d %3.0f m %4s %5s %5s %5s %5s %5s  %s",

		$geodaten_nearest_tp[$i],
		$geodaten_dist_to_tp[$i],
		$kilometrierung_km[$i],
		$kilometrierung_km_sum[$i],
		$kilometrierung_km_real[$i],
		$kilometrierung_km_sum_real[$i],
		$geodaten_alt[$i],
		$geodaten_alt_real[$i],
		$placeName[$i];
	
	if ($verbose) { print encode $encOut, "$output\n"; }
}

if ($verbose) { print encode $encOut, "\n"; }

# ==================
# Summarize Changes

my $change;

my $output = sprintf "%5s  %3s %4s %5s %5s %5s %5s %5s  %s",

	"tp#",
	"dist",
	"k",
	"k_s",
	"k_r",
	"k_s_r",
	"a",
	"a_r",
	"place";

print encode $encOut, "$output\n";

for (my $i=0; $i <= $#Placemarks; $i++) {

	$kilometrierung_km_real[$i] =~ s/\./\,/;

	if ($kilometrierung_km[$i] eq $kilometrierung_km_real[$i]) {

		$kilometrierung_km[$i] = "";
		$kilometrierung_km_real[$i] = "";

	} else {
		
		$kilometrierung_km_res[$i] = $kilometrierung_km_real[$i];
		$change = 1; 
	}

	if ($kilometrierung_km_sum[$i] eq $kilometrierung_km_sum_real[$i]) {

		$kilometrierung_km_sum[$i] = "";
		$kilometrierung_km_sum_real[$i] = "";

	} else {
		
		$kilometrierung_km_sum_res[$i] = $kilometrierung_km_sum_real[$i];
		$change = 1;
	}

	if ($changePlaceHm) {

		if ($geodaten_alt[$i] eq $geodaten_alt_real[$i]) {

			$geodaten_alt[$i] = "";
			$geodaten_alt_real[$i] = "";

		} else {
			
			$geodaten_alt_res[$i] = $geodaten_alt_real[$i];
			$change = 1; 
		}

	} else {

		$geodaten_alt[$i] = "";
		$geodaten_alt_real[$i] = "";
	}

	if ($changeDistHm) {

		if ($kilometrierung_hmdn[$i] eq $kilometrierung_hmdn_real[$i]) {

			$kilometrierung_hmdn[$i] = "";
			$kilometrierung_hmdn_real[$i] = "";

		} else {
			
			$kilometrierung_hmdn_res[$i] = $kilometrierung_hmdn_real[$i];
			$change = 1; 
		}

		if ($kilometrierung_hmup[$i] eq $kilometrierung_hmup_real[$i]) {

			$kilometrierung_hmup[$i] = "";
			$kilometrierung_hmup_real[$i] = "";

		} else {
			
			$kilometrierung_hmup_res[$i] = $kilometrierung_hmup_real[$i];
			$change = 1; 
		}

		if ($kilometrierung_hmup_sum[$i] eq $kilometrierung_hmup_sum_real[$i]) {

			$kilometrierung_hmup_sum[$i] = "";
			$kilometrierung_hmup_sum_real[$i] = "";

		} else {
			
			$kilometrierung_hmup_sum_res[$i] = $kilometrierung_hmup_sum_real[$i];
			$change = 1; 
		}

		if ($kilometrierung_hmdn_sum[$i] eq $kilometrierung_hmdn_sum_real[$i]) {

			$kilometrierung_hmdn_sum[$i] = "";
			$kilometrierung_hmdn_sum_real[$i] = "";

		} else {
			
			$kilometrierung_hmdn_sum_res[$i] = $kilometrierung_hmdn_sum_real[$i];
			$change = 1; 
		}

	} else {
	}

	my $output = sprintf "%5d %3.0f m %4s %5s %5s %5s %5s %5s  %s",

		$geodaten_nearest_tp[$i],
		$geodaten_dist_to_tp[$i],
		$kilometrierung_km[$i],
		$kilometrierung_km_sum[$i],
		$kilometrierung_km_real[$i],
		$kilometrierung_km_sum_real[$i],
		$geodaten_alt[$i],
		$geodaten_alt_real[$i],
		$placeName[$i];
	
	print encode $encOut, "$output\n";
}

# ======================
# Write Changes to File


if ($change) {

	$fileContent = "";

	$fileContent .= $pre_Roadbook;


	for (my $i=0; $i < $#Placemarks; $i++) {

		$fileContent .= "=== $placeName[$i] ===\n";
		$fileContent .= "$touriInfo[$i]\n";
		$fileContent .= "{{Geodaten|$geodaten_lat[$i]|$geodaten_lon[$i]|$geodaten_alt_res[$i]|$geodaten_info[$i]}}\n";
		$fileContent .= "$roadInfo[$i]\n";

		if ($kilometrierung[$i] =~ /KilometrierungHm6/) {

			$fileContent .= "{{KilometrierungHm6|$kilometrierung_km_res[$i]|$kilometrierung_hmup_res[$i]|$kilometrierung_hmdn_res[$i]|$kilometrierung_km_sum_res[$i]|$kilometrierung_hmup_sum_res[$i]|$kilometrierung_hmdn_sum_res[$i]}}";

		} elsif ($kilometrierung[$i] =~ /KilometrierungHm/) {

			$fileContent .= "{{KilometrierungHm|$kilometrierung_km_res[$i]|$kilometrierung_km_sum_res[$i]|$kilometrierung_hmup_sum_res[$i]|$kilometrierung_hmdn_sum_res[$i]}}";

		} else {

			$fileContent .= "{{Kilometrierung|$kilometrierung_km_res[$i]|$kilometrierung_km_sum_res[$i]}}";
		}

		$fileContent .= "\n$rest[$i]";
	}

	$fileContent .= "=== $placeName[$#Placemarks] ===\n";
	$fileContent .= "$touriInfo[$#Placemarks]\n";
	$fileContent .= "{{Geodaten|$geodaten_lat[$#Placemarks]|$geodaten_lon[$#Placemarks]|$geodaten_alt_res[$#Placemarks]|$geodaten_info[$#Placemarks]}}\n";
	$fileContent .= "$roadInfo[$#Placemarks]";

	$fileContent .= $post_Roadbook;
	
	open  FOUT, "> $outDir/${routeFileName_e}_new.tx" or die $!;
	print FOUT encode ($encoding, $fileContent);
	close FOUT;

}

exit;


#==========================================================
#==========================================================

sub getHmSum {

	my ($tp_begin, $tp_end) = @_;

	if ($tp_end >= $#track) { $tp_end = $#track-1; }

	my $HmSumUp = 0;
	my $HmSumDn = 0;
	
	for (my $i = $tp_begin; $i <= $tp_end ; $i++) {

		my $alt_0 = $track[$i][2];
		my $alt_1 = $track[$i+1][2];
		
		my $diff  = $alt_1 - $alt_0;

		if ($diff < 0) { $HmSumDn += $diff * (-1); }
		if ($diff > 0) { $HmSumUp += $diff * (+1); }

	}

	return ($HmSumUp, $HmSumDn);
}
Abgerufen von „http://radreise-wiki.de/index.php?title=Radreise-Wiki:Km.pl&oldid=97659“