This is my Perl Module Google::Travel::Matrix, which will be an interface to the Google Distance Matrix API. I will use this for calculating distance and travel times between multiple locations.

Google Distance Matrix API Interface


This module provides an interface with the Google Distance Matrix API. It will return the distance between given locations in JSON format.
It will accept one or many “Origin” addresses in String, Array or Hash format.It will also accept many Destination addresses. The Google Matrix configuration attributes can be set here, but it may be easier just to accept the defaults that I built in unless you have other specific requirements.
I used the Perl Moose Object framework as it does a really great job of helping set up the configuration attributes using Moose Types and coercion. It will also make it easier for me to build my sub classes.
The module is available here on GitHub, Google::Travel::Matrix

=head2 get_all_elements
 Given the Google Distance Matrix output as a scalar reference to a Perl data
 structure, returns an ArrayRef of Matrix elements or undef.
 If no Google Output data passed, then it will create one using the Origin and
 destination addresses;
 It would be a good idea to check that the Google Matrix Return is 'OK' before calling
 this method.

sub get_all_elements {
    my $self = shift;
    my $matrix = shift || $self->get_google_matrix_data_as_scalar_ref();

    my $google_status = $self->get_matrix_status_message($matrix);

    if ( ( not $google_status ) || ( $google_status ne $VALID_REQ ) ) {

        $log->debug( 'Google return status message is: '
              . ( $google_status // 'No Google Status' ) );
        return $FAIL;

    #------ Preserve the Original address sent to Google
    #       as it may be needed later.
    #       Yet again,  this is something I would prefer 
    #       to put into a Child Class
    my $original_origins      = $self->_get_array_of_origins();
    my $original_destinations = $self->_get_array_of_destinations();

    #------ Get each combination for the origin destination addresses
    my $origin_ct = 0;
    my @elements_array;
    foreach my $origin_addr ( @{ $self->get_matrix_origin_addresses($matrix) } )
        my $original_origin_addr = $original_origins->[ $origin_ct++ ];
        $log->debug( 'Original origin address is : ' . $original_origin_addr );

        #---Get results for current origination address
        my $row = shift @{ $matrix->{rows} };

        #------ Match origination address with all destination addresses
        my $dest_ct = 0;
        foreach my $destination_addr (
            @{ $self->get_matrix_destination_addresses($matrix) } )

            my $original_destination_addr =
              $original_destinations->[ $dest_ct++ ];

            $log->debug( 'Original destination address is : '
                  . $original_destination_addr );

           #----- get the result for the current Origination -> Destination pair
            my $element = shift @{ $row->{elements} };

            push @elements_array,
                origin_address               => $origin_addr,
                destination_address          => $destination_addr,
                original_origin_address      => $original_origin_addr,
                original_destination_address => $original_destination_addr,
                element_status               => $element->{status},
                element_duration_text        => $element->{duration}{text},
                element_duration_value       => $element->{duration}{value},
                element_distance_text        => $element->{distance}{text},
                element_distance_value       => $element->{distance}{value},
        'Array of all elements returned by Google:  ' . dump @elements_array );
    return \@elements_array;

This is far from being a completed masterpiece, but for now it will get me what I need. I intentionally didn’t allow for receiving the data in XML format, as Google recommends JSON format.I may add XML processing at a later date.I may even consider refactoring it from Moose to Moo, to make it lighter and nimbler.
I also plan to create a subclass class to Google::Travel::Time that will do the actual conversion from distance to a travel time acceptable to the NYC moving and storage industry. Until then, I don’t consider this module to be CPAN worthy.

Leave a Reply

Your email address will not be published. Required fields are marked *

Protected by WP Anti Spam