File Coverage

blib/lib/Math/Shape/Point.pm

Criterion	Covered	Total	%
statement	95	95	100.0
branch	18	18	100.0
condition	12	15	80.0
subroutine	22	22	100.0
pod	16	16	100.0
total	163	166	98.1

package Math::Shape::Point;
$Math::Shape::Point::VERSION = '1.05';
use strict;
use warnings;
use 5.008;
use Math::Trig ':pi';
use Regexp::Common;
use Carp 'croak';

# ABSTRACT: a 2d point object in cartesian space with utility angle methods


sub new {
    croak 'Incorrect number of arguments for new()' unless @_ == 4;
    my ($class, $x, $y, $r) = @_;
    my $self =  bless { x => $x,
                        y => $y,
                        r => 0,
                      },
                      $class;
    $self->rotate($r);
    return $self;
}


sub get_location { [$_[0]->{x}, $_[0]->{y}] }



sub set_location {
    my ($self, $x, $y) = @_;
    $self->{x} = $x;
    $self->{y} = $y;
    1;
}


sub get_direction {
    return $_[0]->{r};
}


sub set_direction {
    $_[0]->{r} = $_[0]->normalize_radian($_[1]);
    1;
}


sub advance {
    $_[0]->{x} += int(sin($_[0]->{r}) * $_[1]);
    $_[0]->{y} += int(cos($_[0]->{r}) * $_[1]);
    1;
}


sub retreat {
    $_[0]->{x} -= int(sin($_[0]->{r}) * $_[1]);
    $_[0]->{y} -= int(cos($_[0]->{r}) * $_[1]);
    1;
}


sub move_left {
    $_[0]->{x} += int(sin( $_[0]->{r} - pip2 ) * $_[1]);
    $_[0]->{y} += int(cos( $_[0]->{r} - pip2 ) * $_[1]);
    1;
}


sub move_right {
    $_[0]->{x} += int(sin( $_[0]->{r} + pip2 ) * $_[1]);
    $_[0]->{y} += int(cos( $_[0]->{r} + pip2 ) * $_[1]);
    1;
}


sub rotate {
    $_[0]->{r} = $_[0]->normalize_radian($_[0]->{r} + $_[1]);
    1;
}


sub rotate_about_point {
    my ($self, $origin, $r) = @_;

    my $nr = $self->normalize_radian($r);
#    $nr = $nr > 0 ? pi2 - $nr
#                  : abs $nr;

    my $s = sin $nr;
    my $c = cos $nr;

    $self->{x} -= $origin->{x};
    $self->{y} -= $origin->{y};

    # rotate point
    my $xnew = $self->{x} * $c - $self->{y} * $s;
    my $ynew = $self->{x} * $s + $self->{y} * $c;

    # translate point back:
    $self->{x} = int $xnew + $origin->{x};
    $self->{y} = int $ynew + $origin->{y};

    $self->rotate($r);
    1;
}


sub get_distance_to_point {
    sqrt ( abs($_[0]->{x} - $_[1]->{x}) ** 2 + abs($_[0]->{y} - $_[1]->{y}) ** 2);
}


sub get_angle_to_point {
    my ($self, $p) = @_;

    # check points are not at the same location
    if ($self->get_location->[0] == $p->get_location->[0]
        && $self->get_location->[1] == $p->get_location->[1])
    {
        croak 'Error: points are at the same location';
    }

    my $atan = atan2($p->{y} - $self->{y}, $p->{x} - $self->{x});

    if ($atan <= 0) { # lower half
        return abs($atan) + pip2 + $self->get_direction;
    }
    elsif ($atan <= pip2)  { # upper right quadrant
        return abs($atan - pip2) + $self->get_direction;
    }
    else { # upper left quadrant
        return pi2 - $atan + pip2 + $self->get_direction;
    }
}


sub get_direction_to_point {
    my ($self, $p) = @_;
    my $angle = $self->get_angle_to_point($p);
    if    ($angle > 0 - pip4  && $angle <= pip4)      { return 'front' }
    elsif ($angle > pip4      && $angle <= pi - pip4) { return 'right' }
    elsif ($angle > pi - pip4 && $angle <= pi + pip4) { return 'back'  }
    return 'left';
}


sub normalize_radian {
    my ($self, $radians) = @_;

    my $pi_ratio = $radians / pi2;
    $pi_ratio < 1
        ? $radians
        : $radians - pi2 * int $pi_ratio;
}


sub print_coordinates {
    my $self = shift;

    print "Coordinates x: $self->{x}, y: $self->{y}, r: $self->{r}\n";

    # print grid
    my $min_x = $self->{x} + -10;
    my $max_x = $self->{x} + 10;
    my $min_y = $self->{y} + -10;
    my $max_y = $self->{y} + 10;

    print '   ';
    for ($min_x..$max_x) { printf "%3s", $_ }
    printf "%3s", "x\n";
    for my $y (reverse $min_y..$max_y) {
        printf "%3s", $y;
        for my $x ($min_x..$max_x) {
               if ($self->{x} == $x && $self->{y} == $y) { printf "%3s", '@' }
             else { printf "%3s", '.' }
        }
        print "\n";
    }
    printf "%3s", "y\n";
    1;
}

1;

__END__