File Coverage

blib/lib/Music/MelodicDevice/Inversion.pm

Criterion	Covered	Total	%
statement	59	59	100.0
branch	12	16	75.0
condition			n/a
subroutine	13	13	100.0
pod	2	2	100.0
total	86	90	95.5

package Music::MelodicDevice::Inversion;
our $AUTHORITY = 'cpan:GENE';

# ABSTRACT: Apply melodic inversion to a series of notes

our $VERSION = '0.0501';

use Data::Dumper::Compact qw(ddc);
use List::SomeUtils qw(first_index);
use Music::Note;
use Music::Scales qw(get_scale_MIDI is_scale);
use Moo;
use strictures 2;
use namespace::clean;

use constant OCTAVES => 10;


has scale_note => (
    is      => 'ro',
    isa     => sub { die "$_[0] is not a valid note" unless $_[0] =~ /^[A-G][#b]?$/ },
    default => sub { 'C' },
);


has scale_name => (
    is      => 'ro',
    isa     => sub { die "$_[0] is not a valid scale name" unless is_scale($_[0]) },
    default => sub { 'chromatic' },
);

has _scale => (
    is        => 'lazy',
    init_args => undef,
);

sub _build__scale {
    my ($self) = @_;

    my @scale = map { get_scale_MIDI($self->scale_note, $_, $self->scale_name) } -1 .. OCTAVES - 1;
    print 'Scale: ', ddc(\@scale) if $self->verbose;

    return \@scale;
}


has verbose => (
    is      => 'ro',
    isa     => sub { die "$_[0] is not a valid boolean" unless $_[0] =~ /^[01]$/ },
    default => sub { 0 },
);


sub intervals {
    my ($self, $notes) = @_;

    my @pitches;

    for my $note (@$notes) {
        my ($i, $pitch) = $self->_find_pitch($note);
        push @pitches, $i;
    }
    print 'Pitches: ', ddc(\@pitches) if $self->verbose;

    my @intervals;
    my $last;

    for my $pitch (@pitches) {
        if (defined $last) {
            push @intervals, $pitch - $last;
        }
        $last = $pitch;
    }
    print 'Intervals: ', ddc(\@intervals) if $self->verbose;

    return \@intervals;
}


sub invert {
    my ($self, $note, $notes) = @_;

    my $named = $note =~ /[A-G]/ ? 1 : 0;

    my @inverted = ($note);

    my $intervals = $self->intervals($notes);

    for my $interval (@$intervals) {
        # Find the note that is the opposite interval away from the original note
        (my $i, $note) = $self->_find_pitch($note);
        my $pitch = $self->_scale->[ $i - $interval ];

        $note = $named
            ? Music::Note->new($pitch, 'midinum')->format('ISO')
            : $pitch;

        push @inverted, $note;
    }

    print 'Inverted: ', ddc(\@inverted) if $self->verbose;

    return \@inverted;
}

sub _find_pitch {
    my ($self, $pitch) = @_;

    $pitch = Music::Note->new($pitch, 'ISO')->format('midinum')
        if $pitch =~ /[A-G]/;

    my $i = first_index { $_ eq $pitch } @{ $self->_scale };

    return $i, $pitch;
}

1;

__END__