maps/web/googlemap.cgi

#!/usr/bin/perl

use warnings;
use strict;

use HTML::GoogleMaps;
use CGI;
use CGI::Carp qw/fatalsToBrowser/;
use File::Find;
use Data::Dump qw/dump/;

use lib '../lib';
use blib;
use NMEA;
use KML;

my $trace_path = '../nmea/';

# http://localhost/
my $map_key = 'ABQIAAAAVQ5szt9Jd8ws6vgfVQOEmhT2yXp_ZAY8_ufC3CFXhHIE1NvwkxQ1cKf0DwFJcwtpESJEI0hL8QgtYg';

my @traces;
find({ wanted => sub {
        push @traces, $_ if -f $_;
}}, $trace_path);

my $q = CGI->new;

my $head = '';
my $html = join('', qq{
<h1>Select GPS NMEA dump</h1>
        },
        $q->start_form( -id => 'trace_frm' ),
        $q->popup_menu(
                -name => 'trace', 
                -values => [
                        map {
                                "$_ (" . (stat("$trace_path/$_"))[7] . " bytes)"
                        }
                        sort {
                                (stat("$trace_path/$a"))[9] <=> (stat("$trace_path/$b"))[9]
                        } @traces
                ],
                -onChange => 'trace_frm.submit()',
        ),
        $q->submit(
                -name => 'show',
                -value => 'Show trace'
        ),
        ' Export to ',
        $q->submit(
                -name => 'export',
                -value => 'KML'
        ),
        $q->br,
        'Draw ',
        $q->popup_menu(
                -name => 'points_filter',
                -values => [ 'all', 'every', 'total of' ],
        ),
        $q->textfield(
                -name => 'points_count',
                -value => '',
                -size => 2,
                -onChange => 'trace_frm.submit()',
        ),
        ' points and ',
        $q->popup_menu(
                -name => 'placemark_filter',
                -values => [ 'total of', 'every' ],
        ),
        $q->textfield(
                -name => 'placemark_count',
                -value => 5,
                -size => 2,
                -onChange => 'trace_frm.submit()',
        ),
        ' placemarks',
        $q->end_form,
);


if ( my $trace = $q->param('trace') ) {
        $trace =~ s/\s.+$//;

        $trace = "$trace_path/$trace";

        my $center_point;
        my @points;
        my @placemarks;

        open(my $fh, '<', $trace) || die "can't open $trace: $!";
        while( <$fh> ) {

                my $hash = NMEA->line( $_ ) || next;

                my $point = [ $hash->{lon}, $hash->{lat} ];
                $center_point ||= $point;

                push @points, $point;

                push @placemarks, {
                        point => $point,
                        html => join('<br/>',
                                map {
                                        ucfirst($_) . ': ' . $hash->{$_}
                                } ( qw/number time lat lon speed course/ )
                        ),
                        %$hash,
                };

        }
        close($fh);

        if ( $#points >= 0 ) {

                sub filter_array {
                        my $o = {@_};
                        my (     $count,      $filter,      $code  ) =
                           ( $o->{count}, $o->{filter}, $o->{code} ) ;
                        confess "no CODE?" unless ref($code) eq 'CODE';
                        my @array = @{ $o->{array} };

                        warn "count: $count filter: $filter\n";

                        my $code_calls = 0;

                        if ( $count && $filter =~ m/every/ ) {
                                foreach my $o ( 0 .. $#array ) {
                                        next unless $o % $count == 0;
                                        $code->( $array[$o] );
                                        $code_calls++;
                                }
                        } elsif ( $count && $filter =~ m/total/ ) {
                                # total of
                                if ( $count < 2 ) {
                                        # first
                                        if ( $array[0]) {
                                                $code->( $array[0] );
                                                $code_calls++;
                                        };
                                        # last
                                        if ( $count > 1 && $#array > 0 ) {
                                                $code->( $array[$#array] );
                                                $code_calls++;
                                        };
                                        return $code_calls;
                                }

                                my $d = $#array / ( $count - 1 );
                                foreach my $p ( 0 .. $count - 1 ) {
                                        my $o = int($p * $d);
                                        die "no element $p at $o from total of ",$#array + 1 unless $array[$o];
                                        $code->( $array[$o] );
                                        $code_calls++;
                                }
                        } else {
                                # show every
                                foreach my $e ( @array ) {
                                        $code->( $e );
                                        $code_calls++;
                                }
                        }
                        return $code_calls;
                }

                my $map = HTML::GoogleMaps->new(
                        key => $map_key,
                        width => '800px',
                        height => '600px',
                );

                my @poly_points;
                my $points = filter_array(
                        count => $q->param('points_count'), 
                        filter => $q->param('points_filter'),
                        code => sub {
                                my $point = shift;
                                push @poly_points, $point;
                        },
                        array => \@points,
                );

                die "hum?" unless $#poly_points == $points - 1;

                my @filtered_placemarks;

                my $placemarks = filter_array(
                        count => $q->param('placemark_count'), 
                        filter => $q->param('placemark_filter'),
                        code => sub {
                                my $placemark = shift;
                                $map->add_marker( %$placemark, noformat => 1 );
                                push @filtered_placemarks, $placemark;
                        },
                        array => \@placemarks,
                );

                if ( my $export = $q->param('export') ) {
                        if ( $export eq 'KML' ) {
                                print $q->header(
                                        -type => 'application/xhtml+xml',
                                ),
                                KML->output( placemarks => \@filtered_placemarks );
                                exit;
                        } else {
                                die "unknown export format $export";
                        }
                }


                #$map->center(point => "Zagreb, Hrvatska");

                #$map->zoom(10);
                $map->v2_zoom(20);
                $map->controls("large_map_control", "map_type_control");
                $map->map_type('hybrid');
                $map->center( $center_point ) if $q->param('line') && $center_point;

                $map->add_polyline( points => [ @poly_points ] ) if @poly_points;
        
                my ( $map_div, $map_script );
                ( $head, $map_div, $map_script ) = $map->render;

                $html .= join('',
$#points + 1, ' points from <tt>', $q->param('trace'), '</tt> showing ',
        $points ? $points . ' points' . ( $placemarks ? ' and ' : '' ) : '',
        $placemarks ? $placemarks . ' placemarks' : '',
        qq{
$map_div
$map_script
<a href="http://aprs.gids.nl/nmea/">GPS - NMEA sentence information</a>
                });

                my $stats = NMEA->stats;
                $html .= '<table>';
                foreach my $n ( keys %$stats ) {
                        $html .= "<tr><td>$n</td><td>" . $stats->{$n} . "</td></tr>";
                }
                $html .= '</table>';
        
        } else {
                $html .= '<em>No points found for ' . $q->param('trace') . '</em>';
        }

}

print $q->header;
print qq{
<html>
<head>
<title>Read GPS - NMEA sentence and display it on GoogleMaps</title>
$head
</head>
<body>
$html
</body>
</html>
};
1	dpavlin	13	#!/usr/bin/perl
2
3			use warnings;
4			use strict;
5
6			use HTML::GoogleMaps;
7	dpavlin	14	use CGI;
8	dpavlin	13	use CGI::Carp qw/fatalsToBrowser/;
9	dpavlin	14	use File::Find;
10	dpavlin	13	use Data::Dump qw/dump/;
11
12	dpavlin	27	use lib '../lib';
13			use blib;
14	dpavlin	14	use NMEA;
15	dpavlin	30	use KML;
16	dpavlin	14
17	dpavlin	27	my $trace_path = '../nmea/';
18	dpavlin	14
19	dpavlin	13	# http://localhost/
20			my $map_key = 'ABQIAAAAVQ5szt9Jd8ws6vgfVQOEmhT2yXp_ZAY8_ufC3CFXhHIE1NvwkxQ1cKf0DwFJcwtpESJEI0hL8QgtYg';
21
22	dpavlin	14	my @traces;
23			find({ wanted => sub {
24			push @traces, $_ if -f $_;
25			}}, $trace_path);
26	dpavlin	13
27	dpavlin	14	my $q = CGI->new;
28	dpavlin	13
29	dpavlin	15	my $head = '';
30			my $html = join('', qq{
31	dpavlin	14	<h1>Select GPS NMEA dump</h1>
32			},
33	dpavlin	19	$q->start_form( -id => 'trace_frm' ),
34	dpavlin	14	$q->popup_menu(
35			-name => 'trace',
36			-values => [
37			map {
38			"$_ (" . (stat("$trace_path/$_"))[7] . " bytes)"
39			}
40			sort {
41	dpavlin	27	(stat("$trace_path/$a"))[9] <=> (stat("$trace_path/$b"))[9]
42	dpavlin	14	} @traces
43			],
44	dpavlin	19	-onChange => 'trace_frm.submit()',
45	dpavlin	14	),
46	dpavlin	30	$q->submit(
47			-name => 'show',
48			-value => 'Show trace'
49			),
50			' Export to ',
51			$q->submit(
52			-name => 'export',
53			-value => 'KML'
54			),
55	dpavlin	23	$q->br,
56	dpavlin	25	'Draw ',
57			$q->popup_menu(
58			-name => 'points_filter',
59			-values => [ 'all', 'every', 'total of' ],
60			),
61			$q->textfield(
62			-name => 'points_count',
63			-value => '',
64			-size => 2,
65	dpavlin	23	-onChange => 'trace_frm.submit()',
66			),
67	dpavlin	25	' points and ',
68	dpavlin	24	$q->popup_menu(
69			-name => 'placemark_filter',
70	dpavlin	25	-values => [ 'total of', 'every' ],
71	dpavlin	24	),
72	dpavlin	23	$q->textfield(
73	dpavlin	25	-name => 'placemark_count',
74	dpavlin	23	-value => 5,
75			-size => 2,
76			-onChange => 'trace_frm.submit()',
77			),
78	dpavlin	24	' placemarks',
79	dpavlin	15	$q->end_form,
80			);
81	dpavlin	13
82	dpavlin	23
83
84	dpavlin	14	if ( my $trace = $q->param('trace') ) {
85			$trace =~ s/\s.+$//;
86	dpavlin	13
87	dpavlin	14	$trace = "$trace_path/$trace";
88	dpavlin	13
89	dpavlin	24	my $center_point;
90			my @points;
91			my @placemarks;
92	dpavlin	13
93	dpavlin	14	open(my $fh, '<', $trace) \|\| die "can't open $trace: $!";
94			while( <$fh> ) {
95	dpavlin	13
96	dpavlin	14	my $hash = NMEA->line( $_ ) \|\| next;
97	dpavlin	13
98	dpavlin	23	my $point = [ $hash->{lon}, $hash->{lat} ];
99			$center_point \|\|= $point;
100	dpavlin	13
101	dpavlin	24	push @points, $point;
102	dpavlin	23
103	dpavlin	24	push @placemarks, {
104			point => $point,
105			html => join('<br/>',
106			map {
107			ucfirst($_) . ': ' . $hash->{$_}
108	dpavlin	27	} ( qw/number time lat lon speed course/ )
109	dpavlin	24	),
110	dpavlin	30	%$hash,
111	dpavlin	24	};
112	dpavlin	23
113	dpavlin	14	}
114			close($fh);
115	dpavlin	13
116	dpavlin	25	if ( $#points >= 0 ) {
117	dpavlin	13
118	dpavlin	25	sub filter_array {
119			my $o = {@_};
120			my ( $count, $filter, $code ) =
121			( $o->{count}, $o->{filter}, $o->{code} ) ;
122			confess "no CODE?" unless ref($code) eq 'CODE';
123			my @array = @{ $o->{array} };
124	dpavlin	23
125	dpavlin	25	warn "count: $count filter: $filter\n";
126	dpavlin	24
127	dpavlin	25	my $code_calls = 0;
128
129			if ( $count && $filter =~ m/every/ ) {
130			foreach my $o ( 0 .. $#array ) {
131			next unless $o % $count == 0;
132			$code->( $array[$o] );
133			$code_calls++;
134	dpavlin	24	}
135	dpavlin	25	} elsif ( $count && $filter =~ m/total/ ) {
136	dpavlin	24	# total of
137	dpavlin	25	if ( $count < 2 ) {
138			# first
139			if ( $array[0]) {
140			$code->( $array[0] );
141			$code_calls++;
142			};
143			# last
144			if ( $count > 1 && $#array > 0 ) {
145			$code->( $array[$#array] );
146			$code_calls++;
147			};
148			return $code_calls;
149			}
150
151			my $d = $#array / ( $count - 1 );
152			foreach my $p ( 0 .. $count - 1 ) {
153	dpavlin	24	my $o = int($p * $d);
154	dpavlin	25	die "no element $p at $o from total of ",$#array + 1 unless $array[$o];
155			$code->( $array[$o] );
156			$code_calls++;
157	dpavlin	24	}
158	dpavlin	25	} else {
159			# show every
160			foreach my $e ( @array ) {
161			$code->( $e );
162			$code_calls++;
163			}
164	dpavlin	24	}
165	dpavlin	25	return $code_calls;
166	dpavlin	24	}
167
168	dpavlin	30	my $map = HTML::GoogleMaps->new(
169			key => $map_key,
170			width => '800px',
171			height => '600px',
172			);
173
174	dpavlin	25	my @poly_points;
175			my $points = filter_array(
176			count => $q->param('points_count'),
177			filter => $q->param('points_filter'),
178			code => sub {
179			my $point = shift;
180			push @poly_points, $point;
181			},
182			array => \@points,
183			);
184
185			die "hum?" unless $#poly_points == $points - 1;
186
187	dpavlin	30	my @filtered_placemarks;
188	dpavlin	25
189			my $placemarks = filter_array(
190			count => $q->param('placemark_count'),
191			filter => $q->param('placemark_filter'),
192			code => sub {
193			my $placemark = shift;
194			$map->add_marker( %$placemark, noformat => 1 );
195	dpavlin	30	push @filtered_placemarks, $placemark;
196	dpavlin	25	},
197			array => \@placemarks,
198			);
199
200	dpavlin	30	if ( my $export = $q->param('export') ) {
201			if ( $export eq 'KML' ) {
202			print $q->header(
203			-type => 'application/xhtml+xml',
204			),
205			KML->output( placemarks => \@filtered_placemarks );
206			exit;
207			} else {
208			die "unknown export format $export";
209			}
210			}
211
212
213			#$map->center(point => "Zagreb, Hrvatska");
214
215			#$map->zoom(10);
216			$map->v2_zoom(20);
217			$map->controls("large_map_control", "map_type_control");
218			$map->map_type('hybrid');
219			$map->center( $center_point ) if $q->param('line') && $center_point;
220
221			$map->add_polyline( points => [ @poly_points ] ) if @poly_points;
222
223	dpavlin	18	my ( $map_div, $map_script );
224			( $head, $map_div, $map_script ) = $map->render;
225
226	dpavlin	25	$html .= join('',
227			$#points + 1, ' points from <tt>', $q->param('trace'), '</tt> showing ',
228			$points ? $points . ' points' . ( $placemarks ? ' and ' : '' ) : '',
229	dpavlin	24	$placemarks ? $placemarks . ' placemarks' : '',
230			qq{
231	dpavlin	14	$map_div
232			$map_script
233			<a href="http://aprs.gids.nl/nmea/">GPS - NMEA sentence information</a>
234	dpavlin	18	});
235	dpavlin	29
236			my $stats = NMEA->stats;
237			$html .= '<table>';
238			foreach my $n ( keys %$stats ) {
239			$html .= "<tr><td>$n</td><td>" . $stats->{$n} . "</td></tr>";
240			}
241			$html .= '</table>';
242	dpavlin	18
243			} else {
244			$html .= '<em>No points found for ' . $q->param('trace') . '</em>';
245			}
246	dpavlin	13
247			}
248
249	dpavlin	30	print $q->header;
250	dpavlin	13	print qq{
251	dpavlin	15	<html>
252			<head>
253			<title>Read GPS - NMEA sentence and display it on GoogleMaps</title>
254			$head
255			</head>
256			<body>
257			$html
258	dpavlin	13	</body>
259			</html>
260			};