# Source code for scamp.quantization

```
"""
Module containing classes and functions related to the quantization of performances. (This includes the
:class:`TimeSignature` class, which also has bearing on musical notation.)
"""
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# This file is part of SCAMP (Suite for Computer-Assisted Music in Python) #
# Copyright © 2020 Marc Evanstein <marc@marcevanstein.com>. #
# #
# This program is free software: you can redistribute it and/or modify it under the terms of #
# the GNU General Public License as published by the Free Software Foundation, either version #
# 3 of the License, or (at your option) any later version. #
# #
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; #
# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. #
# See the GNU General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License along with this program. #
# If not, see <http://www.gnu.org/licenses/>. #
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
from fractions import Fraction
from .utilities import indigestibility, is_multiple, is_x_pow_of_y, round_to_multiple, sum_nested_list, prime_factor, \
SavesToJSON, memoize
from ._metric_structure import MetricStructure
from collections import namedtuple
from .settings import quantization_settings, engraving_settings
from expenvelope import Envelope
from ._dependencies import abjad
from numbers import Number
from typing import Sequence, Union, Tuple, Iterator
import textwrap
##################################################################################################################
# TimeSignature Class
##################################################################################################################
[docs]class TimeSignature(SavesToJSON):
"""
Class representing the time signature of a measure
:param numerator: time signature numerator. Can be a list/tuple of ints, in the case of an additive time signature
:param denominator: time signature denominator
:param beat_lengths: (optional) This is a hint as to how the time signature is divided up into beats. By default,
it is None, meaning that a sensible default will be constructed. Should add up to the length of the time
signature.
:ivar numerator: time signature numerator. Can be a list/tuple of ints, in the case of an additive time signature
:ivar denominator: time signature denominator
:ivar beat_lengths: Representation of how the time signature is divided up into beats. (Affects the quantization
process.)
"""
def __init__(self, numerator: Union[int, Sequence[int]], denominator: int, beat_lengths: Sequence[float] = None):
self.numerator = numerator
# For now, and the foreseeable future, I don't want to deal with time signatures like 4/7
if not is_x_pow_of_y(denominator, 2):
raise ValueError("TimeSignature denominator must be a power of two.")
self.denominator = denominator
self.beat_lengths = beat_lengths if beat_lengths is not None else self._calculate_default_beat_lengths()
def _calculate_default_beat_lengths(self):
if not hasattr(self.numerator, '__len__'):
# not an additive meter
if self.denominator <= 4 or is_multiple(self.numerator, 3):
# if the denominator is 4 or less, we'll use the denominator as the beat
# and if not, but the numerator is a multiple of 3, then we've got a compound meter
if self.denominator > 4:
beat_length = 4.0 / self.denominator * 3
else:
beat_length = 4.0 / self.denominator
num_beats = int(round(self.measure_length() / beat_length))
beat_lengths = [beat_length] * num_beats
else:
# if we're here then the denominator is >= 8 and the numerator is not a multiple of 3
# so we'll do a bunch of duple beats followed by a triple beat if the numerator is odd
duple_beat_length = 4.0 / self.denominator * 2
triple_beat_length = 4.0 / self.denominator * 3
if self.numerator == 1:
# covers the weird cases of 1/8 or 1/16 and such
beat_lengths = [4.0 / self.denominator]
elif self.numerator % 2 == 0:
beat_lengths = [duple_beat_length] * (self.numerator // 2)
else:
beat_lengths = [duple_beat_length] * (self.numerator // 2 - 1) + [triple_beat_length]
else:
# additive meter
if self.denominator <= 4:
# denominator is quarter note or slower, so treat each denominator value as a beat, ignoring groupings
beat_lengths = [4.0 / self.denominator] * sum(self.numerator)
else:
# denominator is eighth or faster, so treat each grouping as a beat
beat_lengths = [4.0 / self.denominator * x for x in self.numerator]
return beat_lengths
[docs] @classmethod
def from_measure_length(cls, measure_length: float) -> 'TimeSignature':
"""
Constructs a TimeSignature of the appropriate measure length.
(Defaults to the simple rather than compound)
:param measure_length: length of the measure in quarter notes
:return: the TimeSignature so constructed
"""
fraction_length = Fraction(measure_length)
numerator, denominator = fraction_length.numerator, fraction_length.denominator * 4
return cls(numerator, denominator)
[docs] @classmethod
def from_string(cls, time_signature_string: str):
"""
Constructs a TimeSignature from its string representation
:param time_signature_string: e.g. "7/8", or "3+5+2/8" in the case of a compound time signature
:return: the TimeSignature so constructed
"""
assert isinstance(time_signature_string, str) and len(time_signature_string.split("/")) == 2
numerator_string, denominator_string = time_signature_string.split("/")
numerator = tuple(int(x) for x in numerator_string.split("+")) \
if "+" in numerator_string else int(numerator_string)
denominator = int(denominator_string)
return cls(numerator, denominator)
[docs] def as_string(self) -> str:
"""
Returns a string representation of the time signature, e.g. "5/4" or "3+2+1/8"
"""
if hasattr(self.numerator, "__len__"):
return "{}/{}".format("+".join(str(x) for x in self.numerator), self.denominator)
else:
return "{}/{}".format(self.numerator, self.denominator)
[docs] def as_tuple(self) -> Tuple:
"""
Returns a tuple representation of the time signature, e.g. (5, 4) or ((3, 2, 1), 8)
"""
return self.numerator, self.denominator
[docs] def measure_length(self) -> float:
"""
Get the length of the measure in quarter notes
"""
if hasattr(self.numerator, "__len__"):
return 4 * sum(self.numerator) / self.denominator
else:
return 4 * self.numerator / self.denominator
def _to_dict(self):
return {
"numerator": self.numerator,
"denominator": self.denominator
}
@classmethod
def _from_dict(cls, json_dict):
return cls(**json_dict)
[docs] def to_abjad(self) -> 'abjad().TimeSignature':
"""
Returns the abjad version of this time signature
"""
return abjad().TimeSignature((self.numerator, self.denominator))
def __eq__(self, other):
return self.numerator == other.numerator and self.denominator == other.denominator
def __repr__(self):
return "TimeSignature({}, {})".format(self.numerator, self.denominator)
##################################################################################################################
# Quantization Schemes
##################################################################################################################
[docs]class BeatQuantizationScheme:
"""
Scheme for making a decision about which divisor to use to quantize a beat
:param length: In quarter-notes
:param divisors: A list of allowed divisors or a list of tuples of (divisor, undesirability). If just
divisors are given, the undesirability for each will be calculated based on its indigestibility.
:param simplicity_preference: ranges 0 - whatever. A simplicity_preference of 0 means all divisions are
treated equally; a 7 is as good as a 4. A simplicity_preference of 1 means that the error for a given
divisor is weighted by that divisor's indigestibility, and a simplicity_preference of 2 means the error
is weighted by the indigestibility squared, etc.
"""
def __init__(self, length: float, divisors: Sequence, simplicity_preference: float = "default"):
# load default if not specified
if simplicity_preference == "default":
simplicity_preference = quantization_settings.simplicity_preference
# actual length of the beat
self.length = float(length)
self.length_as_fraction = Fraction(length).limit_denominator()
assert is_x_pow_of_y(self.length_as_fraction.denominator, 2), \
"Beat length must be some multiple of a power of 2 division of the bar."
# now we populate a self.quantization_divisions with tuples consisting of the allowed divisions and
# their undesirabilities. Undesirability is a factor by which the error in a given quantization option
# is multiplied; the lowest possible undesirability is 1
assert hasattr(divisors, "__len__") and len(divisors) > 0
if isinstance(divisors[0], tuple):
# already (divisor, undesirability) tuples
self.quantization_divisions = divisors
else:
# we've just been given the divisors, and have to figure out the undesirabilities
if len(divisors) == 1:
# there's only one way we're allowed to divide the beat, so just give it undesirability 1, whatever
self.quantization_divisions = list(zip(divisors, [1.0]))
else:
div_indigestibilities = BeatQuantizationScheme._get_divisor_indigestibilities(length, divisors)
self.quantization_divisions = list(zip(
divisors,
BeatQuantizationScheme._get_divisor_undesirabilities(div_indigestibilities, simplicity_preference)
))
[docs] @classmethod
def from_max_divisor(cls, length: float, max_divisor: int,
simplicity_preference: float = "default") -> 'BeatQuantizationScheme':
"""
Takes a max divisor argument instead of a list of allowed divisors.
:param length: In quarter-notes
:param max_divisor: The largest allowable divisor
:param simplicity_preference: Preference for simple divisors (see class description)
"""
return cls(length, range(2, max_divisor + 1), simplicity_preference)
[docs] @classmethod
def from_max_divisor_indigestibility(cls, length: float, max_divisor: int, max_divisor_indigestibility: float,
simplicity_preference: float = "default") -> 'BeatQuantizationScheme':
"""
Takes a max_divisor and max_divisor_indigestibility to determine the list of divisors.
:param length: In quarter-notes
:param max_divisor: The largest allowable divisor
:param max_divisor_indigestibility: sets a hard limit on the indigestibility of divisors that we will consider,
in contrast to simplicity_preference, which simply penalizes indigestible divisors. (See Clarence Barlow's
writing on indigestibility.)
:param simplicity_preference: Preference for simple divisors (see class description)
"""
if simplicity_preference == "default":
simplicity_preference = quantization_settings.simplicity_preference
# look at all possible divisors and the indigestibilities
all_divisors = range(2, max_divisor + 1)
all_indigestibilities = BeatQuantizationScheme._get_divisor_indigestibilities(length, all_divisors)
# keep only those that fall below the max_divisor_indigestibility
quantization_divisions = []
div_indigestibilities = []
for div, div_indigestibility in zip(all_divisors, all_indigestibilities):
if div_indigestibility <= max_divisor_indigestibility:
quantization_divisions.append(div)
div_indigestibilities.append(div_indigestibility)
return cls(length, list(zip(
quantization_divisions,
BeatQuantizationScheme._get_divisor_undesirabilities(div_indigestibilities, simplicity_preference)
)))
@staticmethod
def _get_divisor_indigestibilities(length: float, divisors: Sequence[int]) -> Sequence[float]:
"""
Returns the indigestibilities for a given set of divisors of a given length, taking into account how those
lengths would most naturally divide.
If we write a length as a fraction in simplest terms, its numerator is its most natural division. For instance,
a beat of length 1.5 would be written as a fraction as 3/2, and 3 is the most natural divisor. To get the
indigestibility we consider the indigestibility that results when we divide a given divisor by that numerator
and pull out any common factors.
Example: if length = 1.5, then length_fraction = 3/2. So for a divisor of 6, the relative division is 6/3,
which Fraction automatically reduces to 2/1. On the other hand, a divisor of 2 has relative division 2/3,
which is irreducible thus the div_indigestibility for divisor 6 in this case is indigestibility(2) = 1
and the div_indigestibility for divisor 2 is indigestibility(2) + indigestibility(3) = 3.6667. This is
appropriate for a beat of length 1.5 (compound meter).
Note that there's a little issue here with the divisor of 3, since 3/3 = 1, which has indigestibility 0
Ultimately this would lead to that divisor being chosen no matter what, which is not good. To avoid this
eventuality, when the length fraction numerator is not 1, we add one to all of the divisor indigestibilities
to avoid zeroing things out.
:param length: length of the beat we are looking to divide
:param divisors: list of divisors we are considering for this beat
:return: list of relative indigestibilities corresponding to each divisor
"""
length_fraction = Fraction(length).limit_denominator()
out = []
for div in divisors:
relative_division = Fraction(div, length_fraction.numerator)
divisor_indigestibility = indigestibility(relative_division.numerator) + \
indigestibility(relative_division.denominator)
# ensures not zeroing out of indigestibility as described in the docstring
if length_fraction.numerator > 1:
divisor_indigestibility += 1
out.append(divisor_indigestibility)
return out
@staticmethod
def _get_divisor_undesirabilities(divisor_indigestibilities, simplicity_preference):
return [div ** simplicity_preference for div in divisor_indigestibilities]
def __str__(self):
return "BeatQuantizationScheme({}, {})".format(
self.length, [x[0] for x in sorted(self.quantization_divisions, key=lambda x: x[1])]
)
def __repr__(self):
return "BeatQuantizationScheme(length={}, quantization_divisions={})".format(
self.length, sorted(self.quantization_divisions)
)
[docs]class MeasureQuantizationScheme:
"""
Scheme for quantizing a measure, including beat lengths and which beat divisors to allow.
:param beat_schemes: list of BeatQuantizationSchemes for each beat in the measure
:param time_signature: a TimeSignature or string representing a time signature for this measure
:param beat_groupings: a (potentially nested) list/tuple representing how beats come together to form larger
groupings. For instance, in 4/4 time the beat_groupings will default to (2, 2).
"""
def __init__(self, beat_schemes: Sequence[BeatQuantizationScheme], time_signature: Union[TimeSignature, str],
beat_groupings: Sequence = "auto"):
if isinstance(time_signature, str):
time_signature = TimeSignature.from_string(time_signature)
self.time_signature = time_signature
self.length = time_signature.measure_length()
# this better be true
assert sum([beat_scheme.length for beat_scheme in beat_schemes]) == self.length
self.beat_schemes = beat_schemes
if beat_groupings == "auto":
self.beat_groupings = self._generate_default_beat_groupings()
else:
if sum_nested_list(beat_groupings) != len(beat_schemes):
raise ValueError("Wrong number of beats in beat groupings.")
self.beat_groupings = MetricStructure(*beat_groupings)
[docs] @classmethod
def from_time_signature(cls, time_signature: Union[TimeSignature, str, float], max_divisor: int = "default",
max_divisor_indigestibility: float = "default",
simplicity_preference: float = "default") -> 'MeasureQuantizationScheme':
"""
Constructs a MeasureQuantizationScheme from a time signature.
All beats will follow the same quantization scheme, as dictated by the parameters.
:param time_signature: Either a TimeSignature object or something that can be interpreted as such (e.g. a
string to parse as a time signature, a measure length)
:param max_divisor: the max divisor for all beats in the is measure (see :class:`BeatQuantizationScheme`)
:param max_divisor_indigestibility: the max indigestibility for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
:param simplicity_preference: the simplicity preference for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
"""
# load default settings if not specified (the default simplicity_preference gets loaded
# later in the constructor of BeatQuantizationScheme if nothing is specified here)
if max_divisor == "default":
max_divisor = quantization_settings.max_divisor
if max_divisor_indigestibility == "default":
max_divisor_indigestibility = quantization_settings.max_divisor_indigestibility
# allow for different formulations of the time signature argument
if isinstance(time_signature, str):
time_signature = TimeSignature.from_string(time_signature)
elif isinstance(time_signature, tuple):
time_signature = TimeSignature(*time_signature)
elif isinstance(time_signature, Number):
time_signature = TimeSignature.from_measure_length(time_signature)
assert isinstance(time_signature, TimeSignature)
# now we convert the beat lengths to BeatQuantizationSchemes and construct our object
if max_divisor_indigestibility is None:
# no max_divisor_indigestibility, so just use the max divisor
beat_schemes = [
BeatQuantizationScheme.from_max_divisor(beat_length, max_divisor, simplicity_preference)
for beat_length in time_signature.beat_lengths
]
else:
# using a max_divisor_indigestibility
beat_schemes = [
BeatQuantizationScheme.from_max_divisor_indigestibility(
beat_length, max_divisor, max_divisor_indigestibility, simplicity_preference)
for beat_length in time_signature.beat_lengths
]
return cls(beat_schemes, time_signature)
def _generate_default_beat_groupings(self):
# break it into groups of beats of the same length
last_beat_length = self.beat_schemes[0].length
groups = []
current_group_length = 1
for beat_scheme in self.beat_schemes[1:]:
if beat_scheme.length == last_beat_length:
current_group_length += 1
else:
groups.append(current_group_length)
current_group_length = 1
last_beat_length = beat_scheme.length
groups.append(current_group_length)
# for each group make a metric layer out of the prime-factored length, breaking up large primes
# (also, it's possible for a group to be one beat long, in which case it has empty prime factors. In this
# case, we just need to use a MetricStructure(1)
return MetricStructure(*(
MetricStructure.from_string("*".join(str(x) for x in sorted(prime_factor(group))), True)
if group != 1 else MetricStructure(1)
for group in groups
))
[docs] @memoize
def get_beat_hierarchies(self, subdivision_length: float) -> Sequence[int]:
"""
Generates a list of hierarchies representing how nested a subdivision is within the metric structure.
For instance, if called on a 4/4 measure, with subdivision_length, 0.5, this will return the list
[0, 3, 2, 3, 1, 3, 2, 3], showing that the first subdivision (downbeat) is the strongest, the 5th (3rd beat)
is one level down, etc.
:param subdivision_length: length (in quarter notes) of the subdivision
"""
if not is_x_pow_of_y(subdivision_length, 2):
raise ValueError("Bad subdivision length.")
beat_metric_layers = [
MeasureQuantizationScheme._get_beat_metric_layer(beat_scheme.length, subdivision_length)
for beat_scheme in self.beat_schemes
]
return MeasureQuantizationScheme._inscribe_beats(self.beat_groupings, beat_metric_layers).get_beat_depths()
@staticmethod
def _get_beat_metric_layer(beat_length, subdivision_length):
if not is_multiple(beat_length, subdivision_length):
raise ValueError("Subdivision length does not neatly subdivide beat.")
beat_divisor = int(round(beat_length / subdivision_length))
# first, get the divisor prime factors
divisor_factors = sorted(prime_factor(beat_divisor))
# then get the natural divisors of the beat length from big to small
natural_factors = sorted(prime_factor(Fraction(beat_length).limit_denominator().numerator), reverse=True)
# now for each natural factor
for natural_factor in natural_factors:
# if it's a factor of the divisor
if natural_factor in divisor_factors:
# then pop it and move it to the front
divisor_factors.pop(divisor_factors.index(natural_factor))
divisor_factors.insert(0, natural_factor)
# (Note that we sorted the natural factors from big to small so that the small ones get
# pushed to the front last and end up at the very beginning of the queue)
return MetricStructure.from_string("*".join(str(x) for x in divisor_factors), True)
@staticmethod
def _inscribe_beats(beat_structure: MetricStructure, beat_metric_layers):
"""
Takes a MetricStructure representing the beat structure, and a list of MetricLayers representing the interior
structure of each beat in order, and returns the MetricStructure that combines these two, inscribing the beat
structures into the outer MetricStructure that represents the beat organization.
:param beat_structure: MetricStructure representing the beat structure; each leaf is a beat
:param beat_metric_layers: list of MetricLayers representing how each beat is subdivided
:return: full structure of the measure as a MetricStructure
"""
if len(beat_metric_layers) != beat_structure.num_pulses():
raise ValueError("Wrong number of beat metric layers to inscribe.")
new_groups = []
for group in beat_structure.groups:
if isinstance(group, int):
new_groups.append(MetricStructure(*beat_metric_layers[:group]))
beat_metric_layers = beat_metric_layers[group:]
elif isinstance(group, MetricStructure):
pulses_in_group = group.num_pulses()
new_groups.append(
MeasureQuantizationScheme._inscribe_beats(group, beat_metric_layers[:pulses_in_group]))
beat_metric_layers = beat_metric_layers[pulses_in_group:]
else:
raise ValueError("Bad group.")
return MetricStructure(*new_groups)
def __str__(self):
return "MeasureQuantizationScheme({})".format(self.time_signature.as_string())
def __repr__(self):
return "MeasureQuantizationScheme({}, {})".format(self.beat_schemes, self.time_signature)
[docs]class QuantizationScheme:
"""
Scheme for quantizing a :class:`~scamp.performance.PerformancePart` or :class:`~scamp.performance.Performance`
:param measure_schemes: list of MeasureQuantizationSchemes to use
:param loop: if True, loops through the list of MeasureQuantizationSchemes; if False, keeps reusing the last
MeasureQuantizationScheme given after it reaches the end of the list
"""
def __init__(self, measure_schemes: Sequence[MeasureQuantizationScheme], loop: bool = False):
assert all(isinstance(x, MeasureQuantizationScheme) for x in measure_schemes)
self.measure_schemes = measure_schemes
self.loop = loop
[docs] @classmethod
def from_attributes(cls, time_signature: Union[str, TimeSignature, Sequence] = None,
bar_line_locations: Sequence[float] = None, max_divisor: int = None,
max_divisor_indigestibility: float = None,
simplicity_preference: float = None) -> 'QuantizationScheme':
"""
Constructs a QuantizationScheme from some key attributes.
:param time_signature: either a time signature (represented in string form or as a :class:`TimeSignature`
object), or a list of time signatures. If a list, and the last element of that list is the string "loop",
then the list is repeatedly looped through; if not, the last time signature specified continues to be used.
:param bar_line_locations: a list of locations (in beats since the start of the performance) at which to place
bar lines. Use either this parameter or the time_signature parameter, but not both.
:param max_divisor: the max divisor for all beats in the is measure (see :class:`BeatQuantizationScheme`)
:param max_divisor_indigestibility: the max indigestibility for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
:param simplicity_preference: the simplicity preference for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
"""
if bar_line_locations is not None:
if time_signature is not None:
raise AttributeError("Either time_signature or bar_line_locations may be defined, but not both.")
else:
# since time_signature can be a list of bar lengths, we just convert bar_line_locations to lengths
time_signature = [bar_line_locations[0]] + [bar_line_locations[i+1] - bar_line_locations[i]
for i in range(len(bar_line_locations) - 1)]
elif time_signature is None:
# if both bar_line_locations and time_signature are none, the time signature should be the settings default
time_signature = quantization_settings.default_time_signature
max_divisor = max_divisor if max_divisor is not None else "default"
max_divisor_indigestibility = max_divisor_indigestibility \
if max_divisor_indigestibility is not None else "default"
simplicity_preference = simplicity_preference if simplicity_preference is not None else "default"
if isinstance(time_signature, Sequence) and not isinstance(time_signature, str):
time_signature = list(time_signature)
# make it easy to loop a series of time signatures by adding the string "loop" at the end
loop = False
if isinstance(time_signature[-1], str) and time_signature[-1].lower() == "loop":
time_signature.pop()
loop = True
quantization_scheme = QuantizationScheme.from_time_signature_list(
time_signature, max_divisor=max_divisor, max_divisor_indigestibility=max_divisor_indigestibility,
simplicity_preference=simplicity_preference, loop=loop)
else:
quantization_scheme = QuantizationScheme.from_time_signature(
time_signature, max_divisor=max_divisor, max_divisor_indigestibility=max_divisor_indigestibility,
simplicity_preference=simplicity_preference)
return quantization_scheme
[docs] @classmethod
def from_time_signature(cls, time_signature: Union[str, TimeSignature], max_divisor: int = "default",
max_divisor_indigestibility: float = "default",
simplicity_preference: float = "default") -> 'QuantizationScheme':
"""
Constructs a QuantizationScheme using a single time signature for the whole piece.
:param time_signature: the time signature to use (represented in string form or as a :class:`TimeSignature`
object)
:param max_divisor: the max divisor for all beats in the is measure (see :class:`BeatQuantizationScheme`)
:param max_divisor_indigestibility: the max indigestibility for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
:param simplicity_preference: the simplicity preference for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
"""
return cls.from_time_signature_list(
[time_signature], max_divisor=max_divisor, max_divisor_indigestibility=max_divisor_indigestibility,
simplicity_preference=simplicity_preference
)
[docs] @classmethod
def from_time_signature_list(cls, time_signatures_list: Sequence, loop: bool = False, max_divisor: int = "default",
max_divisor_indigestibility: float = "default",
simplicity_preference: float = "default") -> 'QuantizationScheme':
"""
Constructs a QuantizationScheme using a list of time signatures
:param time_signatures_list: list of time signatures to use (represented in string form or as
:class:`TimeSignature` objects)
:param loop: if True, then the list of time signatures is repeatedly looped through; if not, the last time
signature specified continues to be used.
:param max_divisor: the max divisor for all beats in the is measure (see :class:`BeatQuantizationScheme`)
:param max_divisor_indigestibility: the max indigestibility for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
:param simplicity_preference: the simplicity preference for all beats in the is measure
(see :class:`BeatQuantizationScheme`)
"""
measure_schemes = []
for time_signature in time_signatures_list:
measure_schemes.append(
MeasureQuantizationScheme.from_time_signature(time_signature, max_divisor=max_divisor,
max_divisor_indigestibility=max_divisor_indigestibility,
simplicity_preference=simplicity_preference)
)
return cls(measure_schemes, loop=loop)
[docs] def measure_scheme_iterator(self) -> Iterator[Tuple[MeasureQuantizationScheme, float]]:
"""
Iterates through the measures of this QuantizationScheme, returning tuples of (measure_scheme, start_beat)
"""
t = 0
while self.loop or t == 0:
# if loop is True, then we repeatedly loop through the measure schemes array,
# never reaching the second while loop
for measure_scheme in self.measure_schemes:
yield measure_scheme, t
t += measure_scheme.length
while True:
# if loop is False, then we repeat the last measure scheme
yield self.measure_schemes[-1], t
t += self.measure_schemes[-1].length
[docs] def beat_scheme_iterator(self) -> Iterator[Tuple[BeatQuantizationScheme, float]]:
"""
Iterates through the beats of this QuantizationScheme, returning tuples of (beat_scheme, start_beat)
"""
for measure_scheme, t in self.measure_scheme_iterator():
for beat_scheme in measure_scheme.beat_schemes:
yield beat_scheme, t
t += beat_scheme.length
##################################################################################################################
# Quantization Records
##################################################################################################################
QuantizedBeat = namedtuple("QuantizedBeat", "start_beat start_beat_in_measure length divisor")
QuantizedBeat.__doc__ = """Record of how a beat was quantized (named tuple)
:param start_beat: the start beat of the note relative to the whole performance
:param start_beat_in_measure: the start beat of the note relative to the start of the measure
:param length: the length of the beat in quarter notes
:param divisor: the divisor chosen for the beat
"""
QuantizedMeasure = namedtuple("QuantizedMeasure", "start_beat measure_length beats time_signature beat_depths")
QuantizedMeasure.__doc__ = """Record of how a measure was quantized (named tuple).
:param start_beat: the start beat of the measure relative to the whole performance
:param measure_length: the start beat of the note relative to the start of the measure
:param beats: a list of QuantizedBeat objects
:param time_signature: the :class:`TimeSignature` used for this measure
:param beat_depths: tuple of (length of minimum duple subdivision, list of integers representing the nestedness of each
subdivision).
"""
[docs]class QuantizationRecord(SavesToJSON):
"""
Record of how a :class:`~scamp.performance.PerformancePart` was quantized.
:param quantized_measures: list of quantized measures
:ivar quantized_measures: list of quantized measures
:type quantized_measures: Sequence[QuantizedMeasure]
"""
def __init__(self, quantized_measures: Sequence[QuantizedMeasure]):
self.quantized_measures = quantized_measures
def _to_dict(self):
out = {"quantized_measures": []}
quantized_measures_json_friendly = out["quantized_measures"]
for quantized_measure in self.quantized_measures:
quantized_measure_as_dict = quantized_measure._asdict()
quantized_beats_as_dicts = [beat._asdict() for beat in quantized_measure.beats]
quantized_measure_as_dict["beats"] = quantized_beats_as_dicts
quantized_measures_json_friendly.append(quantized_measure_as_dict)
return out
@classmethod
def _from_dict(cls, json_dict):
quantized_measures = []
for quantized_measure_as_dict in json_dict["quantized_measures"]:
quantized_measure_as_dict["beats"] = [
QuantizedBeat(**quantized_beat_as_dict) for quantized_beat_as_dict in quantized_measure_as_dict["beats"]
]
quantized_measures.append(QuantizedMeasure(**quantized_measure_as_dict))
return cls(quantized_measures)
@property
def measure_lengths(self) -> Sequence[float]:
"""
Tuple of all measure lengths
"""
return tuple(quantized_measure.measure_length for quantized_measure in self.quantized_measures)
@property
def time_signatures(self) -> Sequence[TimeSignature]:
"""
Tuple of the TimeSignature object for each measure
"""
return tuple(quantized_measure.time_signature for quantized_measure in self.quantized_measures)
def __repr__(self):
return "QuantizationRecord([\n{}\n])".format(
textwrap.indent(",\n".join(str(x) for x in self.quantized_measures), " ")
)
##################################################################################################################
# Quantization functions
##################################################################################################################
[docs]def quantize_performance_part(part: 'PerformancePart', quantization_scheme: QuantizationScheme,
onset_weighting: float = "default", termination_weighting: float = "default",
inner_split_weighting: float = "default"):
"""
Quantizes a performance part (in place) and sets its voice_quantization_records
:param part: a PerformancePart
:param quantization_scheme: a QuantizationScheme
:param onset_weighting: How much do we care about accurate onsets
:param termination_weighting: How much do we care about accurate terminations
:param inner_split_weighting: How much do we care about inner segmentation timing (e.g. tuple note lengths)
:return: a QuantizationRecord, detailing all of the time signatures, beat divisions selected, etc.
"""
if not isinstance(quantization_scheme, QuantizationScheme):
raise ValueError("Couldn't understand quantization scheme.")
part.voice_quantization_records = {}
for voice_name, voice in list(part.voices.items()):
quantization_record = _quantize_performance_voice(voice, quantization_scheme,
onset_weighting, termination_weighting, inner_split_weighting)
# make any simultaneous notes in the part chords
_collapse_chords(voice)
# break the voice into a list of non-overlapping voices. If there was no overlap, this has length 1
non_overlapping_voices = _separate_into_non_overlapping_voices(voice)
for i, new_voice in enumerate(non_overlapping_voices):
if i == 0:
# the first of the non-overlapping voices just retains the old voice name
new_voice_name = voice_name
else:
# any extra voice created has to be given a related name
# we follow the pattern 'original_voice', 'original_voice_2', 'original_voice_3', etc.
k = i+1
new_voice_name = voice_name + "_{}".format(str(k))
# in the ridiculous case someone names two voices 'voice' and 'voice_2', and the first one needs to
# be split up, we'll just have to increment to 'voice_3'
while new_voice_name in part.voices:
k += 1
voice_name + "_{}".format(str(k))
part.voices[new_voice_name] = new_voice
part.voice_quantization_records[new_voice_name] = quantization_record
def _quantize_performance_voice(voice, quantization_scheme, onset_weighting="default", termination_weighting="default",
inner_split_weighting="default"):
"""
Quantizes a voice (modifying notes in place) and returns a QuantizationRecord
:param voice: a single voice (list of PerformanceNotes) from a PerformancePart
:param quantization_scheme: a QuantizationScheme
:param onset_weighting: How much do we care about accurate onsets
:param termination_weighting: How much do we care about accurate terminations
:return: QuantizationRecord, detailing all of the time signatures, beat divisions selected, etc.
"""
assert isinstance(quantization_scheme, QuantizationScheme)
if onset_weighting == "default":
onset_weighting = quantization_settings.onset_weighting
if termination_weighting == "default":
termination_weighting = quantization_settings.termination_weighting
if inner_split_weighting == "default":
inner_split_weighting = quantization_settings.inner_split_weighting
if engraving_settings.glissandi.control_point_policy == "split":
for note in voice:
note._divide_length_at_gliss_control_points()
# make list of (note onset time, note) tuples
raw_onsets = [(performance_note.start_beat, performance_note) for performance_note in voice]
# make list of (note termination time, note) tuples
raw_terminations = [(performance_note.start_beat + performance_note.length_sum(), performance_note)
for performance_note in voice]
# make list of (inner split time, note) tuples
raw_inner_splits = []
for performance_note in voice:
if hasattr(performance_note.length, "__len__"):
t = performance_note.start_beat
for length_segment in performance_note.length[:-1]:
t += length_segment
raw_inner_splits.append((t, performance_note))
# sort them
raw_onsets.sort(key=lambda x: x[0])
raw_terminations.sort(key=lambda x: x[0])
raw_inner_splits.sort(key=lambda x: x[0])
beat_scheme_iterator = quantization_scheme.beat_scheme_iterator()
beat_divisors = []
while len(raw_onsets) + len(raw_inner_splits) + len(raw_terminations) > 0:
# First, use all the onsets, inner splits, and terminations in this beat to determine the best divisor
beat_scheme, beat_start = next(beat_scheme_iterator)
assert isinstance(beat_scheme, BeatQuantizationScheme)
beat_end = beat_start + beat_scheme.length
# find the onsets in this beat
onsets_in_this_beat = []
while len(raw_onsets) > 0 and raw_onsets[0][0] < beat_end:
onsets_in_this_beat.append(raw_onsets.pop(0))
# find the terminations in this beat
terminations_in_this_beat = []
while len(raw_terminations) > 0 and raw_terminations[0][0] < beat_end:
terminations_in_this_beat.append(raw_terminations.pop(0))
# find the inner splits in this beat
inner_splits_in_this_beat = []
while len(raw_inner_splits) > 0 and raw_inner_splits[0][0] < beat_end:
inner_splits_in_this_beat.append(raw_inner_splits.pop(0))
if len(onsets_in_this_beat) + len(terminations_in_this_beat) + len(inner_splits_in_this_beat) == 0:
# an empty beat, nothing to see here
beat_divisors.append(None)
continue
best_divisor = _get_best_divisor_for_beat(
beat_scheme, beat_start, onsets_in_this_beat, terminations_in_this_beat, inner_splits_in_this_beat,
onset_weighting, termination_weighting, inner_split_weighting
)
beat_divisors.append(best_divisor)
# Now, quantize all of the notes that start or end in this beat accordingly
division_length = beat_scheme.length / best_divisor
for onset, note in onsets_in_this_beat:
divisions_after_beat_start = round((onset - beat_start) / division_length)
note.start_beat = beat_start + divisions_after_beat_start * division_length
for termination, note in terminations_in_this_beat:
divisions_after_beat_start = round((termination - beat_start) / division_length)
note.end_beat = beat_start + divisions_after_beat_start * division_length
if note.length_sum() <= 0:
# this covers a rare case in which the note has multiple segments, but is getting squeezed by the
# quantization into a length of zero. In this case, dispense with the segments, just make it length 0
if hasattr(note.length, "__len__") > 0:
note.length = 0
# if the quantization collapses the start and end times of a note to the same point,
# adjust so the the note is a single division_length long.
if note.end_beat + division_length <= beat_end:
# if there's room to, just move the end of the note one division forward
note.length += division_length
else:
# otherwise, move the start of the note one division backward
note.start_beat -= division_length
note.length += division_length
# we take note of where all the inner splits quantize to, and then once all of the start
# and end times for the notes are adjusted, we go ahead and put them it.
for inner_split, note in inner_splits_in_this_beat:
divisions_after_beat_start = round((inner_split - beat_start) / division_length)
quantized_split_beat = beat_start + divisions_after_beat_start * division_length
if "split_points" in note.properties.temp:
note.properties.temp["split_points"].append(quantized_split_beat)
else:
note.properties.temp["split_points"] = [quantized_split_beat]
last_note_end_beat = 0
for note in voice:
# now that all the start and end points have been adjusted,
# we implement the quantized split points where applicable
if "split_points" in note.properties.temp:
last_split_point = note.start_beat
new_lengths = []
for split_point in sorted(note.properties.temp["split_points"]):
if round(split_point - last_split_point, 10) > 0:
new_lengths.append(split_point - last_split_point)
last_split_point = split_point
if round(note.end_beat - last_split_point, 10) > 0:
new_lengths.append(note.end_beat - last_split_point)
note.length = tuple(new_lengths)
last_note_end_beat = max(note.end_beat, last_note_end_beat)
# also normalize the pitch envelopes
if isinstance(note.pitch, Envelope):
note.pitch.normalize_to_duration(note.length_sum())
return _construct_quantization_record(beat_divisors, last_note_end_beat, quantization_scheme)
def _collapse_chords(notes):
"""
Modifies a list of PerformanceNotes in place so that simultaneous notes become chords
(i.e. they become PerformanceNotes with a tuple of different values for the pitch.)
:param notes: a list of PerformanceNotes
"""
i = 1
while i < len(notes):
if notes[i - 1].attempt_chord_merger_with(notes[i]):
# if the merger is successful, notes[i] has been incorporated into notes[i-1]
# so we can simply pop notes[i] and not increment
notes.pop(i)
else:
# otherwise, since the merger fails, we simply increment i
i += 1
def _separate_into_non_overlapping_voices(notes, max_overlap=1e-10):
"""
Takes a list of PerformanceNotes and breaks it up into separate voices that don't overlap more than max_overlap
:param notes: a list of PerformanceNotes
:return: a list of voices, each of which is a non-overlapping list of PerformanceNotes
"""
voices = []
# for each note, find the first non-conflicting voice and add it to that
# or create a new voice to add it to if none of the existing voices work
for note in notes:
voice_to_add_to = None
for voice in voices:
# check each voice to see if its last note ends before the note we want to add
if voice[-1].end_beat <= note.start_beat + max_overlap:
voice_to_add_to = voice
break
if voice_to_add_to is None:
voice_to_add_to = []
voices.append(voice_to_add_to)
voice_to_add_to.append(note)
return voices
def _get_best_divisor_for_beat(beat_scheme, beat_start_time, onsets_in_beat, terminations_in_beat, inner_splits_in_beat,
onset_weighting, termination_weighting, inner_split_weighting):
# try out each quantization division of a beat and return the best fit
best_divisor = None
best_error = float("inf")
for divisor, undesirability in beat_scheme.quantization_divisions:
division_length = beat_scheme.length / divisor
total_squared_onset_error = 0
total_squared_termination_error = 0
total_squared_inner_split_error = 0
for onset in onsets_in_beat:
time_since_beat_start = onset[0] - beat_start_time
# squared distance from closest division of the beat
total_squared_onset_error += \
(time_since_beat_start - round_to_multiple(time_since_beat_start, division_length)) ** 2
for termination in terminations_in_beat:
time_since_beat_start = termination[0] - beat_start_time
# squared distance from closest division of the beat
total_squared_termination_error += \
(time_since_beat_start - round_to_multiple(time_since_beat_start, division_length)) ** 2
for inner_split in inner_splits_in_beat:
time_since_beat_start = inner_split[0] - beat_start_time
# squared distance from closest division of the beat
total_squared_inner_split_error += \
(time_since_beat_start - round_to_multiple(time_since_beat_start, division_length)) ** 2
this_div_error_score = undesirability * (termination_weighting * total_squared_termination_error +
onset_weighting * total_squared_onset_error +
inner_split_weighting * total_squared_inner_split_error)
if this_div_error_score < best_error:
best_divisor = divisor
best_error = this_div_error_score
return best_divisor
def _construct_quantization_record(beat_divisors, end_beat, quantization_scheme):
"""
Constructs a QuantizationRecord from the given scheme and divisors
:param beat_divisors: a list of beat divisors resulting from quantization
:param end_beat: This helps us cover the special case in which the last note ends at the very end of a measure.
In this case, it's termination gets quantized in the first beat of the next measure, so we have a beat divisor
in that measure but no actual notes there. By checking if we've hit the end_beat we can avoid constructing
that extra measure.
:param quantization_scheme: the quantization scheme being used
:return: a QuantizationRecord
"""
assert isinstance(beat_divisors, list)
quantized_measures = []
for measure_scheme, t in quantization_scheme.measure_scheme_iterator():
measure_start_beat = t
beats = []
min_duple_subdivision = float("inf")
for beat_scheme in measure_scheme.beat_schemes:
divisor = beat_divisors.pop(0) if len(beat_divisors) > 0 else None
beats.append(
QuantizedBeat(t, t - measure_start_beat, beat_scheme.length, divisor)
)
if divisor is not None:
subdivision_length = beat_scheme.length / divisor
if is_x_pow_of_y(subdivision_length, 2) and subdivision_length < min_duple_subdivision:
min_duple_subdivision = subdivision_length
t += beat_scheme.length
beat_depths = (0.5, measure_scheme.get_beat_hierarchies(0.5)) if min_duple_subdivision == float("inf") \
else (min_duple_subdivision, measure_scheme.get_beat_hierarchies(min_duple_subdivision))
quantized_measure = QuantizedMeasure(measure_start_beat, measure_scheme.length, beats,
measure_scheme.time_signature, beat_depths)
quantized_measures.append(quantized_measure)
if len(beat_divisors) == 0 or t >= end_beat:
return QuantizationRecord(quantized_measures)
```