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 '../';
use NMEA;

my $trace_path = '/home/dpavlin/x/openmoko/gps/';

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

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

my $q = CGI->new;

print $q->header;

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"))[10] <=> (stat("$trace_path/$b"))[10]
                        } @traces
                ],
                -onChange => 'trace_frm.submit()',
        ),
        $q->submit( -value => 'Show trace' ),
        $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/time lat lon speed course/ )
                        ),
                };

        }
        close($fh);

        if ( $#points >= 0 ) {

                my $map = HTML::GoogleMaps->new(
                        key => $map_key,
                        width => '800px',
                        height => '600px',
                );
                #$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;

                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 @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;

                $map->add_polyline( points => [ @poly_points ] ) if @poly_points;

                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 );
                        },
                        array => \@placemarks,
                );

                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>
                });
        
        } else {
                $html .= '<em>No points found for ' . $q->param('trace') . '</em>';
        }

}

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	14	use lib '../';
13			use NMEA;
14
15			my $trace_path = '/home/dpavlin/x/openmoko/gps/';
16
17	dpavlin	13	# http://localhost/
18			my $map_key = 'ABQIAAAAVQ5szt9Jd8ws6vgfVQOEmhT2yXp_ZAY8_ufC3CFXhHIE1NvwkxQ1cKf0DwFJcwtpESJEI0hL8QgtYg';
19
20	dpavlin	14	my @traces;
21			find({ wanted => sub {
22			push @traces, $_ if -f $_;
23			}}, $trace_path);
24	dpavlin	13
25	dpavlin	14	my $q = CGI->new;
26	dpavlin	13
27	dpavlin	14	print $q->header;
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			(stat("$trace_path/$a"))[10] <=> (stat("$trace_path/$b"))[10]
42			} @traces
43			],
44	dpavlin	19	-onChange => 'trace_frm.submit()',
45	dpavlin	14	),
46			$q->submit( -value => 'Show trace' ),
47	dpavlin	23	$q->br,
48	dpavlin	25	'Draw ',
49			$q->popup_menu(
50			-name => 'points_filter',
51			-values => [ 'all', 'every', 'total of' ],
52			),
53			$q->textfield(
54			-name => 'points_count',
55			-value => '',
56			-size => 2,
57	dpavlin	23	-onChange => 'trace_frm.submit()',
58			),
59	dpavlin	25	' points and ',
60	dpavlin	24	$q->popup_menu(
61			-name => 'placemark_filter',
62	dpavlin	25	-values => [ 'total of', 'every' ],
63	dpavlin	24	),
64	dpavlin	23	$q->textfield(
65	dpavlin	25	-name => 'placemark_count',
66	dpavlin	23	-value => 5,
67			-size => 2,
68			-onChange => 'trace_frm.submit()',
69			),
70	dpavlin	24	' placemarks',
71	dpavlin	15	$q->end_form,
72			);
73	dpavlin	13
74	dpavlin	23
75
76	dpavlin	14	if ( my $trace = $q->param('trace') ) {
77			$trace =~ s/\s.+$//;
78	dpavlin	13
79	dpavlin	14	$trace = "$trace_path/$trace";
80	dpavlin	13
81	dpavlin	24	my $center_point;
82			my @points;
83			my @placemarks;
84	dpavlin	13
85	dpavlin	14	open(my $fh, '<', $trace) \|\| die "can't open $trace: $!";
86			while( <$fh> ) {
87	dpavlin	13
88	dpavlin	14	my $hash = NMEA->line( $_ ) \|\| next;
89	dpavlin	13
90	dpavlin	23	my $point = [ $hash->{lon}, $hash->{lat} ];
91			$center_point \|\|= $point;
92	dpavlin	13
93	dpavlin	24	push @points, $point;
94	dpavlin	23
95	dpavlin	24	push @placemarks, {
96			point => $point,
97			html => join('<br/>',
98			map {
99			ucfirst($_) . ': ' . $hash->{$_}
100			} ( qw/time lat lon speed course/ )
101			),
102			};
103	dpavlin	23
104	dpavlin	14	}
105			close($fh);
106	dpavlin	13
107	dpavlin	25	if ( $#points >= 0 ) {
108	dpavlin	13
109	dpavlin	24	my $map = HTML::GoogleMaps->new(
110			key => $map_key,
111			width => '800px',
112			height => '600px',
113			);
114			#$map->center(point => "Zagreb, Hrvatska");
115
116	dpavlin	18	#$map->zoom(10);
117	dpavlin	24	$map->v2_zoom(20);
118	dpavlin	18	$map->controls("large_map_control", "map_type_control");
119			$map->map_type('hybrid');
120	dpavlin	23	$map->center( $center_point ) if $q->param('line') && $center_point;
121	dpavlin	13
122	dpavlin	25	sub filter_array {
123			my $o = {@_};
124			my ( $count, $filter, $code ) =
125			( $o->{count}, $o->{filter}, $o->{code} ) ;
126			confess "no CODE?" unless ref($code) eq 'CODE';
127			my @array = @{ $o->{array} };
128	dpavlin	23
129	dpavlin	25	warn "count: $count filter: $filter\n";
130	dpavlin	24
131	dpavlin	25	my $code_calls = 0;
132
133			if ( $count && $filter =~ m/every/ ) {
134			foreach my $o ( 0 .. $#array ) {
135			next unless $o % $count == 0;
136			$code->( $array[$o] );
137			$code_calls++;
138	dpavlin	24	}
139	dpavlin	25	} elsif ( $count && $filter =~ m/total/ ) {
140	dpavlin	24	# total of
141	dpavlin	25	if ( $count < 2 ) {
142			# first
143			if ( $array[0]) {
144			$code->( $array[0] );
145			$code_calls++;
146			};
147			# last
148			if ( $count > 1 && $#array > 0 ) {
149			$code->( $array[$#array] );
150			$code_calls++;
151			};
152			return $code_calls;
153			}
154
155			my $d = $#array / ( $count - 1 );
156			foreach my $p ( 0 .. $count - 1 ) {
157	dpavlin	24	my $o = int($p * $d);
158	dpavlin	25	die "no element $p at $o from total of ",$#array + 1 unless $array[$o];
159			$code->( $array[$o] );
160			$code_calls++;
161	dpavlin	24	}
162	dpavlin	25	} else {
163			# show every
164			foreach my $e ( @array ) {
165			$code->( $e );
166			$code_calls++;
167			}
168	dpavlin	24	}
169	dpavlin	25	return $code_calls;
170	dpavlin	24	}
171
172	dpavlin	25	my @poly_points;
173			my $points = filter_array(
174			count => $q->param('points_count'),
175			filter => $q->param('points_filter'),
176			code => sub {
177			my $point = shift;
178			push @poly_points, $point;
179			},
180			array => \@points,
181			);
182
183			die "hum?" unless $#poly_points == $points - 1;
184
185			$map->add_polyline( points => [ @poly_points ] ) if @poly_points;
186
187			my $placemarks = filter_array(
188			count => $q->param('placemark_count'),
189			filter => $q->param('placemark_filter'),
190			code => sub {
191			my $placemark = shift;
192			$map->add_marker( %$placemark, noformat => 1 );
193			},
194			array => \@placemarks,
195			);
196
197	dpavlin	18	my ( $map_div, $map_script );
198			( $head, $map_div, $map_script ) = $map->render;
199
200	dpavlin	25	$html .= join('',
201			$#points + 1, ' points from <tt>', $q->param('trace'), '</tt> showing ',
202			$points ? $points . ' points' . ( $placemarks ? ' and ' : '' ) : '',
203	dpavlin	24	$placemarks ? $placemarks . ' placemarks' : '',
204			qq{
205	dpavlin	14	$map_div
206			$map_script
207			<a href="http://aprs.gids.nl/nmea/">GPS - NMEA sentence information</a>
208	dpavlin	18	});
209
210			} else {
211			$html .= '<em>No points found for ' . $q->param('trace') . '</em>';
212			}
213	dpavlin	13
214			}
215
216			print qq{
217	dpavlin	15	<html>
218			<head>
219			<title>Read GPS - NMEA sentence and display it on GoogleMaps</title>
220			$head
221			</head>
222			<body>
223			$html
224	dpavlin	13	</body>
225			</html>
226			};