File Coverage

blib/lib/Geo/GoogleMaps/FitBoundsZoomer.pm

Criterion	Covered	Total	%
statement	97	97	100.0
branch	36	46	78.2
condition	20	26	76.9
subroutine	13	13	100.0
pod	3	3	100.0
total	169	185	91.3

package Geo::GoogleMaps::FitBoundsZoomer;

use 5.10.0;

use strict;
use warnings;

our $VERSION = '1.03';

use Carp;
use List::Util qw(min max);

use constant ZOOM_LIMIT    => 20;
use constant PI => 3.141592653589793;

sub new {
    my ($class, %params) = @_;

    my $points      = delete $params{points};
    my $map_width   = delete $params{width};
    my $map_height  = delete $params{height};
    my $zoom_limit  = delete $params{zoom_limit} // ZOOM_LIMIT;

    bless {
        points      => $points,
        width       => $map_width,
        height      => $map_height,
        zoom_limit  => $zoom_limit
    }, $class;
}

# returns max zoom for a min bounding box
sub max_bounding_zoom {
    my $self = shift;

    if ( @_ || ! defined $self->{max_bounding_zoom} ) {

        if ( @_ ) {
            my %params = @_;

            undef $self->{map_center};
            my @all_params = ('points', 'width', 'height', 'zoom_limit');
            $self->{$_} = delete $params{$_} // $self->{$_} for @all_params;

        }

        foreach ('points', 'width', 'height') {
            croak "No map $_ parameter! Usage: max_bounding_zoom( points => \$points, width => \$map_width, height => \$map_height )"
                                                                                                                    unless defined $self->{$_};
        }

        croak "At least one point must be provided!"        unless @{$self->{points}}   > 0;
        croak "Map width must be a positive number!"        unless $self->{width}       > 0;
        croak "Map height must be a positive number!"       unless $self->{height}      > 0;
        croak "Zoom limit must be greater of equal to 0!"   unless $self->{zoom_limit}  >= 0;

        $self->{bounds} = $self->_get_bounds();
        $self->{max_bounding_zoom} = $self->_zoom_level( $self->{bounds} );

    }

    croak "Insufficient data to calculate maximum zoom! Usage: max_bounding_zoom( points => \$points, width => \$map_width, height => \$map_height )"
                unless defined $self->{max_bounding_zoom};

    return $self->{max_bounding_zoom};
}

# returns center of the rectangular bounding box
sub bounding_box_center {
    my $self = shift;

    croak "Map data not initialized! max_bounding_zoom needs to be called first. Usage: max_bounding_zoom( points => \$points, width => \$map_width, height => \$map_height )"
                if !$self->{points} || !$self->{bounds};

    if ( ! $self->{map_center} ) {
        my $center;
        my $bounds = $self->{bounds};

        my ($blp, $trp) = ($bounds->{blp}, $bounds->{trp});

        $center->{lat}  = ( ($trp->{lat}  - $blp->{lat})  / 2 ) + $blp->{lat};
        $center->{long} = ( ($trp->{long} - $blp->{long}) / 2 ) + $blp->{long};

        $self->{map_center} = $center;
    }

    return $self->{map_center};
}

# returns a bounding box (bottom left and top right point) for coordinates
sub _get_bounds {
    my $self = shift;

    my $blp = { 'lat' =>  90, 'long' =>  180 }; # bottom left point
    my $trp = { 'lat' => -90, 'long' => -180 }; # top right point

    my $points = $self->{points}
                    or croak "Cannot calculate map bounds without points!";

    foreach my $point (@$points) {

        my ($lat, $lng) = ($point->{lat}, $point->{long});

        $blp->{'lat'}    = min ($blp->{'lat'}, $lat);
        $trp->{'lat'}    = max ($trp->{'lat'}, $lat);
        $blp->{'long'}   = min ($blp->{'long'}, $lng);
        $trp->{'long'}   = max ($trp->{'long'}, $lng);
    }

    croak "Point latitude out of bounds ( < -90 or > 90 )"       unless ( -90  <= $blp->{'lat'}  && $blp->{'lat'}  <= 90 );
    croak "Point latitude out of bounds ( < -90 or > 90 )"       unless ( -90  <= $trp->{'lat'}  && $trp->{'lat'}  <= 90 );
    croak "Point longitude out of bounds ( < -180 or > 180 )"    unless ( -180 <= $blp->{'long'} && $blp->{'long'} <= 180 );
    croak "Point longitude out of bounds ( < -180 or > 180 )"    unless ( -180 <= $trp->{'long'} && $trp->{'long'} <= 180 );

    return { 'blp' => $blp, 'trp' => $trp };
}

# returns max bounding zoom level given a set of points, map width and height
sub _zoom_level {
	my ($self, $bounds) = @_;

    croak "Map bounds not set!" if !$bounds;

    my ($width, $height) = ($self->{width}, $self->{height});

    croak "Map width not set!"   unless defined $width;
    croak "Map height not set!"  unless defined $height;

    my $zoom_limit = $self->{zoom_limit};

    my ($blp, $trp) = ($bounds->{blp}, $bounds->{trp});

	foreach my $zoom_level (reverse (0 .. $zoom_limit)) {
		my $blpxl = $self->_coord2pix($blp->{lat}, $blp->{long}, $zoom_level);
		my $trpxl = $self->_coord2pix($trp->{lat}, $trp->{long}, $zoom_level);

		$blpxl->{x} -= (2**($zoom_level + 8)) if ( $blpxl->{x} > $trpxl->{x} );
		my $delta={ x => abs($trpxl->{x} - $blpxl->{x}), y => abs($trpxl->{y} - $blpxl->{y}) };
        return $zoom_level if ( ($delta->{x} <= $width) && ($delta->{y} <= $height) );
	}
	return 0;
}

# returns an X,Y pixel cordinate from $lat, $lng coordinates for a given zoom level
sub _coord2pix {
	#values hash is the output of google_magic™ for a given zoom level
	my ($self, $lat, $lng, $zoom ) = @_;

    croak "Latitude not set!"    unless defined $lat;
    croak "Longitude not set!"   unless defined $lng;
    croak "Zoom not set!"        unless defined $zoom;

    my $center_point = 2**($zoom + 7);
    my $total_pixels = $center_point*2;
    my $pixels_per_lng_degree = $total_pixels / 360;
    my $pixels_per_lng_radian = $total_pixels / (2 * PI);
    my $siny = min ( max( sin( $lat*(PI/180) ), -0.99999999 ), 0.99999999 );

    my $coord;
    $coord->{x} = $center_point + $lng * $pixels_per_lng_degree;
    $coord->{y} = $center_point - 0.5 * log((1+$siny)/(1-$siny)) * $pixels_per_lng_radian;

    return $coord;
}

1; # end of Geo::GoogleMaps::FitBoundsZoomer

__END__