Source code for clockblocks.tempo_envelope

"""
Module defining the :class:`TempoEnvelope` class for describing a time-varying tempo, as well as the
:class:`MetricPhaseTarget` class, which specifies a goal arrival point within the beat (or meter) cycle.
"""

#  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  #
#  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 expenvelope import Envelope, EnvelopeSegment
from copy import deepcopy
from .utilities import snap_float_to_nice_decimal, current_clock
import logging
import math
from typing import Union, Sequence, Tuple


[docs]class TempoEnvelope(Envelope): r""" A subclass of :class:`~expenvelope.envelope.Envelope` that is specifically designed for representing changing tempo curves. The underlying envelope represents beat length as a function of the current beat. A TempoEnvelopes also has a notion of the current beat and time and has methods for advancing time. :param levels: levels of the curve segments (i.e. tempo values) in the units specified by the `units` argument :param durations: durations of the curve segments in the units specified by the `duration_units` argument :param curve_shapes: see :func:`~expenvelope.envelope.Envelope.from_levels_and_durations` :param units: one of "tempo", "rate" or "beat length", determining how we interpret the levels given :param duration_units: either "beats" or "time", determining how we interpret the durations given """ def __init__(self, levels: Sequence = (60,), durations: Sequence[float] = (), curve_shapes: Sequence[Union[float, str]] = None, units: str = "tempo", duration_units: str = "beats"): if units not in ("tempo", "rate", "beatlength"): raise ValueError("Units must be either \"tempo\" or \"rate\" or \"beatlength\".") if duration_units not in ("beats", "time"): raise ValueError("Duration units must be either \"beats\" or \"time\".") super(TempoEnvelope, self).__init__( TempoEnvelope.convert_units(levels, units, "beatlength"), durations, curve_shapes, 0 ) if duration_units == "time": self.convert_durations_to_times() self._t = 0.0 self._beat = 0.0 ################################################################################################################## # Class Methods ##################################################################################################################
[docs] @classmethod def from_levels_and_durations(cls, levels: Sequence = (0, 0), durations: Sequence[float] = (0,), curve_shapes: Sequence[Union[float, str]] = None, units: str = "tempo", duration_units: str = "beats") -> 'TempoEnvelope': """ Constructs a TempoEnvelope from the given levels, durations and curve shapes, using the specified units. :param levels: levels of the curve segments (i.e. tempo values) in the units specified by the `units` argument :param durations: durations of the curve segments in the units specified by the `duration_units` argument :param curve_shapes: see :func:`~expenvelope.envelope.Envelope.from_levels_and_durations` :param units: one of "tempo", "rate" or "beat length", determining how we interpret the levels given :param duration_units: either "beats" or "time", determining how we interpret the durations given :return: a TempoEnvelope, constructed accordingly """ return cls(levels, durations, curve_shapes, units=units, duration_units=duration_units)
[docs] @classmethod def from_levels(cls, levels: Sequence[float], length: float = 1.0, units: str = "tempo", duration_units: str = "beats") -> 'TempoEnvelope': """ Constructs a TempoEnvelope from the given levels and total length, using the specified units. :param levels: levels of the curve segments (i.e. tempo values) in the units specified by the `units` argument :param length: total length of the tempo curve, in the units specified by the `duration_units` argument :param units: one of "tempo", "rate" or "beat length", determining how we interpret the levels given :param duration_units: either "beats" or "time", determining how we interpret the durations given :return: a TempoEnvelope, constructed accordingly """ assert duration_units in ("beats", "time"), "Duration units must be either \"beats\" or \"time\"." return cls( *TempoEnvelope._levels_and_length_to_levels_durations_and_curves(levels, length), units=units, duration_units=duration_units )
[docs] @classmethod def from_list(cls, constructor_list: Sequence, units: str = "tempo", duration_units: str = "beats") -> 'TempoEnvelope': """ Construct a TempoEnvelope from a list that can take a number of formats :param constructor_list: see :func:`~expenvelope.envelope.Envelope.from_list` :param units: one of "tempo", "rate" or "beat length", determining how we interpret the levels given :param duration_units: either "beats" or "time", determining how we interpret the durations given :return: a TempoEnvelope, constructed accordingly """ assert hasattr(constructor_list, "__len__") if hasattr(constructor_list[0], "__len__"): # we were given levels and durations, and possibly curvature values if len(constructor_list) == 2: if hasattr(constructor_list[1], "__len__"): # given levels and durations return cls.from_levels_and_durations(constructor_list[0], constructor_list[1], units=units, duration_units=duration_units) else: # given levels and the total length return cls.from_levels(constructor_list[0], length=constructor_list[1], units=units, duration_units=duration_units) elif len(constructor_list) >= 3: # given levels, durations, and curvature values return cls.from_levels_and_durations(constructor_list[0], constructor_list[1], constructor_list[2], units=units, duration_units=duration_units) else: # just given levels return cls.from_levels(constructor_list, units=units, duration_units=duration_units)
[docs] @classmethod def from_points(cls, *points, units: str = "tempo", duration_units: str = "beats") -> 'TempoEnvelope': """ Construct an envelope from a list of (beat/time, tempo/rate/beat length) pairs. Units are defined by the `units` and `duration_units` parameters. :param points: list of points, each of which is of the form (time, value) or (time, value, curve_shape) :param units: one of "tempo", "rate" or "beat length", determining how we interpret the tempo values :param duration_units: either "beats" or "time", determining how we interpret the time values :return: a TempoEnvelope, constructed accordingly """ levels, durations, curve_shapes, offset = TempoEnvelope._unwrap_points(*points) if offset != 0: raise ValueError("TempoEnvelope must start from beat/time zero; when constructing from points, the " "first point must be of the form (0, [start tempo], [optional curve shape]).") return cls(levels, durations, curve_shapes, units=units, duration_units=duration_units)
[docs] @classmethod def from_function(cls, function, domain_start=0, domain_end=1, resolution_multiple=2, key_point_precision=100, key_point_iterations=5, units: str = "tempo", duration_units: str = "beats") -> 'TempoEnvelope': """ Constructs a TempoEnvelope that approximates an arbitrary function. The domain of the function is in units defined by the `duration_units` parameter, and the range is in units defined by the `units` parameter. :param function: A function from beat/time to tempo/rate/beat length, as defined by the `duration_units` and `units` parameters. :param domain_start: see :func:`~expenvelope.envelope.Envelope.from_function` :param domain_end: see :func:`~expenvelope.envelope.Envelope.from_function` :param resolution_multiple: see :func:`~expenvelope.envelope.Envelope.from_function` :param key_point_precision: see :func:`~expenvelope.envelope.Envelope.from_function` :param key_point_iterations: see :func:`~expenvelope.envelope.Envelope.from_function` :param units: one of "tempo", "rate" or "beat length", determining how we interpret the function output :param duration_units: either "beats" or "time", determining how we interpret the function input :return: a TempoEnvelope, constructed accordingly """ assert duration_units in ("beats", "time"), "Duration units must be either \"beats\" or \"time\"." converted_function = (lambda x: TempoEnvelope.convert_units(function(x), units, "beatlength")) \ if units.lower().replace(" ", "") != "beatlength" else function out_envelope = super().from_function(converted_function, domain_start, domain_end, resolution_multiple, key_point_precision, key_point_iterations) if duration_units == "time": return out_envelope.convert_durations_to_times() else: return out_envelope
################################################################################################################## # Properties ##################################################################################################################
[docs] def time(self): """ The current time. Time is found by integrating under the beatlength curve: seconds/beat * beats = seconds. """ return self._t
[docs] def beat(self): """ The current beat. """ return self._beat
@property def beat_length(self): """ The current beat length. """ return self.value_at(self._beat) @beat_length.setter def beat_length(self, beat_length): self.truncate() self.append_segment(beat_length, 0) def _bring_up_to_date(self, beat: float = None) -> 'TempoEnvelope': beat = self.beat() if beat is None else beat # brings us up-to-date by adding a constant segment in case we haven't had a segment for a while if self.length() < beat: # no explicit segments have been made for a while, insert a constant segment to bring us up to date self.append_segment(self.end_level(), beat - self.length()) return self
[docs] def truncate(self, beat: float = None) -> 'TempoEnvelope': """ Removes all segments after beat (which defaults to the current beat) and adds a constant segment if necessary to being us up to that beat. :param beat: the beat that we are truncating the tempo envelope after :return: self, for chaining purposes """ beat = self.beat() if beat is None else beat self.remove_segments_after(beat) self._bring_up_to_date(beat) return self
[docs] def beat_length_at(self, beat: float, from_left: bool = False) -> float: """ Get the beat length at the given beat. If the beat length jumps at the given beat, the default is to return the beat length after the jump, though this can be overridden with the `from_left` argument. :param beat: the beat at which to get the beat length :param from_left: whether to evaluate from the right or left-hand side of the beat in question """ return self.value_at(beat, from_left)
@property def rate(self): """ The current rate in beats/second """ return 1 / self.beat_length @rate.setter def rate(self, rate): self.beat_length = 1/rate
[docs] def rate_at(self, beat: float, from_left: bool = False) -> float: """ Get the beat rate (in beats/second) at the given beat. If the rate jumps at the given beat, the default is to return the rate after the jump, though this can be overridden with the `from_left` argument. :param beat: the beat at which to get the rate :param from_left: whether to evaluate from the right or left-hand side of the beat in question """ return 1 / self.beat_length_at(beat, from_left)
@property def tempo(self): """ The current tempo in beats/minute """ return self.rate * 60 @tempo.setter def tempo(self, tempo): self.rate = tempo / 60
[docs] def tempo_at(self, beat: float, from_left: bool = False) -> float: """ Get the tempo (in beats/minute) at the given beat. If the tempo jumps at the given beat, the default is to return the tempo after the jump, though this can be overridden with the `from_left` argument. :param beat: the beat at which to get the tempo :param from_left: whether to evaluate from the right or left-hand side of the beat in question """ return self.rate_at(beat, from_left) * 60
################################################################################################################## # Tempo Changes ##################################################################################################################
[docs] def set_beat_length_target(self, beat_length_target: float, duration: float, curve_shape: float = 0, metric_phase_target: Union[float, 'MetricPhaseTarget', Tuple] = None, duration_units: str = "beats", truncate: bool = True) -> None: """ Set a target beat length for this TempoEnvelope to reach in duration beats/seconds (with the unit defined by duration_units). :param beat_length_target: The beat length we want to reach :param duration: How long until we reach that beat length :param curve_shape: > 0 makes change happen later, < 0 makes change happen sooner :param metric_phase_target: This argument lets us align the arrival at the given beat length with a particular part of the parent beat (time), or, if we specified "time" as our duration units, it allows us to align the arrival at that specified time with a particular part of this clock's beat. This argument takes either a float in [0, 1), a MetricPhaseTarget object, or a tuple of arguments to the MetricPhaseTarget constructor :param duration_units: one of ("beats", "time"); defines whether the duration is in beats or in seconds. :param truncate: Whether or not to truncate this TempoEnvelope to the current beat before setting this target. """ if duration_units not in ("beats", "time"): raise ValueError("Argument duration_units must be either \"beat\" or \"time\".") if metric_phase_target is not None: metric_phase_target = MetricPhaseTarget.interpret(metric_phase_target) # truncate removes any segments that extend into the future if truncate: self.remove_segments_after(self.beat()) # add a flat segment up to the current beat if needed self._bring_up_to_date() self._add_segment(beat_length_target, duration, curve_shape, metric_phase_target, duration_units)
def _add_segment(self, beat_length_target: float, duration: float, curve_shape: float = 0, metric_phase_target: Union[float, 'MetricPhaseTarget', Tuple] = None, duration_units: str = "beats") -> None: """ The guts of adding a new segment, minus argument checking and truncating/bringing up to date. """ if duration_units == "beats": extension_into_future = self.length() - self.beat() if duration < extension_into_future: raise ValueError("Duration to target must extend beyond the last existing target.") self.append_segment(beat_length_target, duration - extension_into_future, curve_shape) if metric_phase_target is not None: if not self._adjust_segment_end_time_to_metric_phase_target(self.segments[-1], metric_phase_target): logging.warning("Metric phase target {} was not reachable".format(metric_phase_target)) else: # units == "time", so we need to figure out how many beats are necessary time_extension_into_future = self.integrate_interval(self.beat(), self.length()) if duration < time_extension_into_future: raise ValueError("Duration to target must extend beyond the last existing target.") # normalized_time = how long the curve would take if it were one beat long normalized_time = EnvelopeSegment( 0, 1, self.value_at(self.length()), beat_length_target, curve_shape ).integrate_segment(0, 1) desired_curve_length = duration - time_extension_into_future self.append_segment(beat_length_target, desired_curve_length / normalized_time, curve_shape) if metric_phase_target is not None: if not self._adjust_segment_end_beat_to_metric_phase_target(self.segments[-1], metric_phase_target): logging.warning("Metric phase target {} was not reachable".format(metric_phase_target))
[docs] def set_beat_length_targets(self, beat_length_targets: Sequence[float], durations: Sequence[float], curve_shapes: Sequence[float] = None, metric_phase_targets: Sequence[Union[float, 'MetricPhaseTarget', Tuple]] = None, duration_units: str = "beats", truncate: bool = True) -> None: """ Same as set_beat_length_target, except that you can set multiple targets at once by providing lists to each of the arguments. :param beat_length_targets: list of the target beat_lengths :param durations: list of segment durations (in beats or seconds, as defined by duration_units) :param curve_shapes: list of segment curve_shapes (or none to not set curve shape) :param metric_phase_targets: list of metric phase targets for each segment (or None to ignore metric phase) :param duration_units: one of ("beats", "time"); defines whether the duration is in beats or in seconds/parent beats. :param truncate: Whether or not to truncate this TempoEnvelope to the current beat before setting these targets. """ num_targets = len(beat_length_targets) if duration_units not in ("beats", "time"): raise ValueError("Argument duration_units must be either \"beat\" or \"time\".") curve_shapes = [0] * num_targets if curve_shapes is None else curve_shapes if len(durations) != num_targets: raise ValueError("Inconsistent number of targets and durations.") if len(curve_shapes) != num_targets: raise ValueError("Inconsistent number of targets and curve_shapes.") if metric_phase_targets is not None and len(metric_phase_targets) != num_targets: raise ValueError("Inconsistent number of metric phase targets and curve_shapes.") # truncate removes any segments that extend into the future if truncate: self.remove_segments_after(self.beat()) # add a flat segment up to the current beat if needed self._bring_up_to_date() if metric_phase_targets is None: # no segments have phase targets, so it's simple for beat_length_target, duration, curve_shape in zip(beat_length_targets, durations, curve_shapes): self._add_segment(beat_length_target, duration, curve_shape, None, duration_units) else: metric_phase_targets = [(MetricPhaseTarget.interpret(x) if x is not None else None) for x in metric_phase_targets] # This is used to adjust metric phase, if desired. We keep track of all the segments # we've added since we last adjusted the metric phase. segments_to_adjust = [] # We also keep track of the start and end beat/time of the current group of segments so that # we don't have to recalculate it all the time current_group_start_beat = current_group_end_beat = self.end_time() current_group_start_time = current_group_end_time = \ self.time() + self.integrate_interval(self.beat(), self.end_time()) for beat_length_target, duration, curve_shape, metric_phase_target in \ zip(beat_length_targets, durations, curve_shapes, metric_phase_targets): if metric_phase_target is None: # no metric phase target for this segment, but some segments do have metric phase targets # so we add it to our list of segments to adjust when we next have to adjust to a target self._add_segment(beat_length_target, duration, curve_shape, metric_phase_target, duration_units) added_segment = self.segments[-1] segments_to_adjust.append(added_segment) current_group_end_beat += added_segment.duration current_group_end_time += added_segment.integrate_segment(added_segment.start_time, added_segment.end_time) else: # if we're here then there is a metric phase target for the end of this segment if len(segments_to_adjust) == 0: # if we haven't built up any segments to adjust, then just add this one segment, # adjusting it in the process self._add_segment(beat_length_target, duration, curve_shape, metric_phase_target, duration_units) added_segment = self.segments[-1] current_group_end_beat += added_segment.duration current_group_end_time += added_segment.integrate_segment(added_segment.start_time, added_segment.end_time) current_group_start_beat = current_group_end_beat current_group_start_time = current_group_end_time continue # Otherwise, we add the segment without adjusting it in the process... self._add_segment(beat_length_target, duration, curve_shape, None, duration_units) added_segment = self.segments[-1] segments_to_adjust.append(added_segment) current_group_end_beat += added_segment.duration current_group_end_time += added_segment.integrate_segment(added_segment.start_time, added_segment.end_time) # ...and then we try to reach the target by adjusting all of the segments since the last adjustment success = False # did we successfully adjust? if duration_units == "beats": for goal_end_time in metric_phase_target.get_nearest_matching_times(current_group_end_time): # try both the nearest matching time before and after goal_time_duration = goal_end_time - current_group_start_time if self._adjust_segments_time_duration(segments_to_adjust, goal_time_duration): # if one of them works, declare success and break current_group_end_time = goal_end_time # reset the end time based on the adjustment success = True break elif duration_units == "time": for goal_end_beat in metric_phase_target.get_nearest_matching_beats(current_group_end_beat): # try both the nearest matching beat before and after # first, squeeze/stretch all the segments to take up an appropriate number of beats proportional_adjustment = (goal_end_beat - current_group_start_beat) / \ (current_group_end_beat - current_group_start_beat) b = current_group_start_beat for segment in segments_to_adjust: old_dur = segment.duration segment.start_time = b segment.end_time = b = b + proportional_adjustment * old_dur # then try to re-adjust to get back to the original end time if self._adjust_segments_time_duration(segments_to_adjust, current_group_end_time - current_group_start_time): # if it works, declare success and break current_group_end_beat = goal_end_beat # reset the end beat based on the adjustment success = True break if not success: logging.warning("Metric phase target {} was not reachable.".format(metric_phase_target)) else: # If it did succeed, clear the segments_to_adjust. We don't want to be adjusting any of the # segments that we just adjusted, since they would get messed up. segments_to_adjust.clear() # also reset the group start and end beat/time current_group_start_beat = current_group_end_beat current_group_start_time = current_group_end_time
[docs] def set_rate_target(self, rate_target: float, duration: float, curve_shape: float = 0, metric_phase_target: Union[float, 'MetricPhaseTarget', Tuple] = None, duration_units: str = "beats", truncate: bool = True) -> None: """ Set a target beat rate for this TempoEnvelope to reach in duration beats/seconds (with the unit defined by duration_units). :param rate_target: The beat rate we want to reach :param duration: How long until we reach that beat rate :param curve_shape: > 0 makes change happen later, < 0 makes change happen sooner :param metric_phase_target: This argument lets us align the arrival at the given beat length with a particular part of the parent beat (time), or, if we specified "time" as our duration units, it allows us to align the arrival at that specified time with a particular part of this clock's beat. This argument takes either a float in [0, 1), a MetricPhaseTarget object, or a tuple of arguments to the MetricPhaseTarget constructor :param duration_units: one of ("beats", "time"); defines whether the duration is in beats or in seconds. :param truncate: Whether or not to truncate this TempoEnvelope to the current beat before setting this target. """ self.set_beat_length_target(1 / rate_target, duration, curve_shape, metric_phase_target, duration_units, truncate)
[docs] def set_rate_targets(self, rate_targets: Sequence[float], durations: Sequence[float], curve_shapes: Sequence[float] = None, metric_phase_targets: Sequence[Union[float, 'MetricPhaseTarget', Tuple]] = None, duration_units: str = "beats", truncate: bool = True) -> None: """ Same as set_rate_target, except that you can set multiple targets at once by providing lists to each of the arguments. :param rate_targets: list of the target beat rates :param durations: list of segment durations (in beats or seconds, as defined by duration_units) :param curve_shapes: list of segment curve_shapes (or none to not set curve shape) :param metric_phase_targets: list of metric phase targets for each segment (or None to ignore metric phase) :param duration_units: one of ("beats", "time"); defines whether the duration is in beats or in seconds/parent beats. :param truncate: Whether or not to truncate this TempoEnvelope to the current beat before setting these targets. """ self.set_beat_length_targets([1 / x for x in rate_targets], durations, curve_shapes, metric_phase_targets, duration_units, truncate)
[docs] def set_tempo_target(self, tempo_target: float, duration: float, curve_shape: float = 0, metric_phase_target: Union[float, 'MetricPhaseTarget', Tuple] = None, duration_units: str = "beats", truncate: bool = True) -> None: """ Set a target tempo for this TempoEnvelope to reach in duration beats/seconds (with the unit defined by duration_units). :param tempo_target: The tempo we want to reach :param duration: How long until we reach that tempo :param curve_shape: > 0 makes change happen later, < 0 makes change happen sooner :param metric_phase_target: This argument lets us align the arrival at the given beat length with a particular part of the parent beat (time), or, if we specified "time" as our duration units, it allows us to align the arrival at that specified time with a particular part of this clock's beat. This argument takes either a float in [0, 1), a MetricPhaseTarget object, or a tuple of arguments to the MetricPhaseTarget constructor :param duration_units: one of ("beats", "time"); defines whether the duration is in beats or in seconds. :param truncate: Whether or not to truncate this TempoEnvelope to the current beat before setting this target. """ self.set_beat_length_target(60 / tempo_target, duration, curve_shape, metric_phase_target, duration_units, truncate)
[docs] def set_tempo_targets(self, tempo_targets: Sequence[float], durations: Sequence[float], curve_shapes: Sequence[float] = None, metric_phase_targets: Sequence[Union[float, 'MetricPhaseTarget', Tuple]] = None, duration_units: str = "beats", truncate: bool = True) -> None: """ Same as set_tempo_target, except that you can set multiple targets at once by providing lists to each of the arguments. :param tempo_targets: list of the target tempos :param durations: list of segment durations (in beats or seconds, as defined by duration_units) :param curve_shapes: list of segment curve_shapes (or none to not set curve shape) :param metric_phase_targets: list of metric phase targets for each segment (or None to ignore metric phase) :param duration_units: one of ("beats", "time"); defines whether the duration is in beats or in seconds/parent beats. :param truncate: Whether or not to truncate this TempoEnvelope to the current beat before setting these targets. """ self.set_beat_length_targets([60 / x for x in tempo_targets], durations, curve_shapes, metric_phase_targets, duration_units, truncate)
# ----------------------------------------- Metric Phase adjustments --------------------------------------------- # These two methods are for just adjusting a single segment's metric phase in beat or time. # They are used when adding single segments that we want to adjust the phase of def _adjust_segment_end_time_to_metric_phase_target(self, segment, metric_phase_target): # this is confusing; segment.start_time and segment.end_time are really the start and end *beats* segment_start_time = self.time() + self.integrate_interval(self.beat(), segment.start_time) segment_end_time = segment_start_time + segment.integrate_segment(segment.start_time, segment.end_time) for new_end_time in metric_phase_target.get_nearest_matching_times(segment_end_time): try: segment.set_curvature_to_desired_integral(new_end_time - segment_start_time) return True except ValueError: pass return False @staticmethod def _adjust_segment_end_beat_to_metric_phase_target(segment, metric_phase_target): # this is how long the segment currently takes; we want to end up with this being the same original_integral = segment.integrate_segment(segment.start_time, segment.end_time) for new_end_beat in metric_phase_target.get_nearest_matching_beats(segment.end_time): try: # shrink the segment segment.end_time = new_end_beat # and then try to change the curvature to return to the original time duration segment.set_curvature_to_desired_integral(original_integral) return True except ValueError: pass return False # These methods are used when we want to adjust the metric phase at the end of a group of segments.
[docs] def adjust_metric_phase_at_beat(self, beat: float, metric_phase_target: Union[float, 'MetricPhaseTarget', Tuple]) -> bool: """ Sets the goal (time) metric phase at the given beat. So, for instance, if we called ``adjust_metric_phase_at_beat(5, 0.5)``, this would mean that we want to be at time 1.5, 2.5, 3.5 etc. at beat 5. If we called ``adjust_metric_phase_at_beat(7, 1.25, 3)``, this would mean that at beat 7, we would want to be at time 1.25, 4.25, 7.25, etc. :param beat: The beat at which to have the given phase in time :param metric_phase_target: either a :class:`MetricPhaseTarget`, or the argument to construct one :return: True, if the adjustment is possible, False if not """ if beat > self.length() or beat <= self.beat(): raise ValueError("Cannot adjust metric phase before current beat or beyond the end of the TempoEnvelope") metric_phase_target = MetricPhaseTarget.interpret(metric_phase_target) # what's the current time at the beat? time_at_beat = self.time() + self.integrate_interval(self.beat(), beat) # try to adjust that to one of the nearby target phases for good_phase_time in metric_phase_target.get_nearest_matching_times(time_at_beat): if self.adjust_time_at_beat(beat, good_phase_time): # the adjustment worked (returned true), so return True to say that we succeeded return True # if we get here, neither adjustment was possible, so we failed. Return false. return False
[docs] def adjust_time_at_beat(self, beat_to_adjust: float, desired_time: float) -> bool: """ Adjusts the curvature of segments from now until beat so that we reach it at desired_time, if possible. If not possible, leaves the TempoCurve unchanged and returns False :param beat_to_adjust: the beat at which we want to be at a particular time :param desired_time: the time we want to be at :return: True if the adjustment worked, False if it's impossible """ assert self.beat() < beat_to_adjust <= self.length() # make a copy of the original segments lists to fall back on in case we fail back_up = deepcopy(self.segments) self.insert_interpolated(self.beat()) self.insert_interpolated(beat_to_adjust) adjustable_segments = self.segments[self._get_index_of_segment_at(self.beat(), right_most=True): self._get_index_of_segment_at(beat_to_adjust, left_most=True) + 1] goal_total_time = desired_time - self.time() result = TempoEnvelope._adjust_segments_time_duration(adjustable_segments, goal_total_time) if result == "no change": # it worked, but we didn't have to change anything # no there's no need for the interpolations self.segments = back_up return True elif result: # it worked, return True return True else: # the adjustment failed, so return to the old segments before interpolation # and return false to signal the failure self.segments = back_up return False
@staticmethod def _adjust_segments_time_duration(which_segments: Sequence[EnvelopeSegment], goal_total_time: float): """ Adjusts the total time that the segments take without changing the total beats :param which_segments: which segments to adjust. :param goal_total_time: the total time we want them to take :return: True if it's possible, False if not, and "no change" in the off-chance that no change was needed """ # ranges of how long each segment could take by adjusting curvature segment_time_ranges = [segment.get_integral_range() for segment in which_segments] # range of how long the entire thing could take total_time_range = (sum(x[0] for x in segment_time_ranges), sum(x[1] for x in segment_time_ranges)) # check if it's even possible to get to the desired time by simply adjusting curvatures if not total_time_range[0] < goal_total_time < total_time_range[1]: # if not return False return False # how long each segment currently takes segment_times = [segment.integrate_segment(segment.start_time, segment.end_time) for segment in which_segments] # how long all the segments take total_time = sum(segment_times) # on the off-chance that it already works perfectly, return "no change" to indicate that it worked, # but that it was totally unnecessary if goal_total_time == total_time: return "no change" # if we've reached this point, we're ready to make the adjustments # delta_time is how much of an adjustment we need total delta_time = goal_total_time - total_time # we distribute this total adjustment between the segments based on how much room they have to move # in the direction we want them to move. Longer segments and segments with more room to wiggle do the # majority of the adjusting. if delta_time < 0: weightings = [segment_time - segment_time_range[0] for segment_time, segment_time_range in zip(segment_times, segment_time_ranges)] else: weightings = [segment_time_range[1] - segment_time for segment_time, segment_time_range in zip(segment_times, segment_time_ranges)] weightings_sum = sum(weightings) segment_adjustments = [weighting / weightings_sum * delta_time for weighting in weightings] for segment, segment_time, segment_adjustment in zip(which_segments, segment_times, segment_adjustments): segment.set_curvature_to_desired_integral(segment_time + segment_adjustment) return True
[docs] def adjust_metric_phase_at_time(self, target_time: float, metric_phase_target: Union[float, 'MetricPhaseTarget', Tuple]) -> bool: """ Sets the goal (beat) metric phase at the given time. So, for instance, if we called ``adjust_metric_phase_at_time(5, 0.5)``, this would mean that at time 5 we want to be at beat 1.5, 2.5, 3.5 etc. If we called ``adjust_metric_phase_at_time(7, 1.25, 3)``, this would mean that at time 7, we would want to be at beat 1.25, 4.25, 7.25, etc. :param target_time: The time at which to have the given phase in beat :param metric_phase_target: either a MetricPhaseTarget, or the argument to construct one :return: True, if the adjustment is possible, False if not """ envelope_end_time = self.time() + self.integrate_interval(self.beat(), self.end_time()) if target_time > envelope_end_time or target_time <= self.time(): raise ValueError("Cannot adjust metric phase before current beat or beyond the end of the TempoEnvelope") metric_phase_target = MetricPhaseTarget.interpret(metric_phase_target) # what's the current beat at the time? beat_at_time = self.beat() + self.get_beat_wait_from_time_wait(target_time - self.time()) # try to adjust that to one of the nearby target phases for good_phase_beat in metric_phase_target.get_nearest_matching_beats(beat_at_time): if self.adjust_beat_at_time(target_time, good_phase_beat): # the adjustment worked (returned true), so return True to say that we succeeded return True # if we get here, neither adjustment was possible, so we failed. Return false. return False
[docs] def adjust_beat_at_time(self, time_to_adjust: float, desired_beat: float) -> bool: """ Adjusts the curvature of segments from now until the specified time so that we reach it at desired_beat, if possible. If not possible, leaves the TempoCurve unchanged and returns False. :param time_to_adjust: the time at which we want to be at a particular beat :param desired_beat: the beat we want to be at :return: True if the adjustment worked, False if it's impossible """ envelope_end_time = self.time() + self.integrate_interval(self.beat(), self.end_time()) assert self.time() < time_to_adjust <= envelope_end_time # make a copy of the original segments lists to fall back on in case we fail back_up = deepcopy(self.segments) current_beat_at_adjust_point = self.beat() + self.get_beat_wait_from_time_wait(time_to_adjust - self.time()) start_beat = self.insert_interpolated(self.beat()) # if the insertion does nothing because it's too close to an existing point, it will return the existing point current_beat_at_adjust_point = self.insert_interpolated(current_beat_at_adjust_point) adjustable_index_start = self._get_index_of_segment_at(self.beat(), right_most=True) adjustable_index_end = self._get_index_of_segment_at(current_beat_at_adjust_point, left_most=True) + 1 adjustable_segments = self.segments[adjustable_index_start: adjustable_index_end] # first we squeeze or stretch all the segments so that we reach the right beat at the end of the last one delta_beat = desired_beat - current_beat_at_adjust_point proportional_length_adjustment = (desired_beat - start_beat) / (current_beat_at_adjust_point - start_beat) b = adjustable_segments[0].start_time for segment in adjustable_segments: old_dur = segment.duration segment.start_time = b segment.end_time = b = b + proportional_length_adjustment * old_dur for segment in self.segments[adjustable_index_end:]: segment.start_time += delta_beat segment.end_time += delta_beat # now that we squeezed or stretched so as to be at the correct moment in the curve, on the correct beat # see if we can adjust the curvature of the segments so that the time at that moment is unchanged if self.adjust_time_at_beat(desired_beat, time_to_adjust): # if it works, return True return True else: # otherwise, revert and return false self.segments = back_up return False
################################################################################################################## # Advancing Time ##################################################################################################################
[docs] def get_wait_time(self, beats: float) -> float: """ Get the amount of time it would take to wait the specified number of beats starting at the current point in the TempoEnvelope. :param beats: how many beats to wait :return: how much time that will take """ return self.integrate_interval(self._beat, self._beat + beats)
[docs] def advance(self, beats: float) -> Tuple[float, float]: """ Advance the current beat/time in the envelope by the given number of beats. :param beats: how many beats to advance by :return: tuple of delta beats, delta time """ wait_time = self.get_wait_time(beats) self._beat = snap_float_to_nice_decimal(self._beat + beats) self._t = snap_float_to_nice_decimal(self._t + wait_time) return beats, wait_time
[docs] def get_beat_wait_from_time_wait(self, seconds: float) -> float: """ Get the amount of beats we would have to wait to wait for the given number of seconds, starting at the current point in the TempoEnvelope. :param seconds: how many seconds to wait :return: how many beats that would correspond to """ beat_to_get_to = self.get_upper_integration_bound(self._beat, seconds, max_error=0.00000001) return beat_to_get_to - self._beat
[docs] def advance_time(self, seconds: float): """ Advance the current beat/time in the envelope by the given number of seconds. :param seconds: how many seconds to advance by :return: tuple of delta beats, delta time """ beats = self.get_beat_wait_from_time_wait(seconds) self.advance(beats) return beats, seconds
[docs] def go_to_beat(self, b: float) -> 'TempoEnvelope': """ Jump straight to the given beat in this TempoEnvelope :param b: the beat to jump to :return: self, for chaining purposes """ self._beat = snap_float_to_nice_decimal(b) self._t = snap_float_to_nice_decimal(self.integrate_interval(0, b)) return self
################################################################################################################## # Conversion Utilities ##################################################################################################################
[docs] @staticmethod def convert_units(values: Union[float, Sequence[float]], input_units: str, output_units: str) -> Union[float, Sequence[float]]: """ Utility method to convert values between unites of tempo, rate and beat length. :param values: a list of values in terms of the input_units :param input_units: current units of the given values (either "tempo", "rate", or "beat length") :param output_units: desired units to convert to (either "tempo", "rate", or "beat length") :return: the list of values, converted to output units """ in_units = input_units.lower().replace(" ", "") out_units = output_units.lower().replace(" ", "") assert in_units in ("tempo", "rate", "beatlength") and out_units in ("tempo", "rate", "beatlength"), \ "Invalid value of {} for units. Must be \"tempo\", \"rate\" or \"beat length\"".format(input_units) if in_units == out_units: return values else: convert_input_to_beat_length = (lambda x: 1 / x) if in_units == "rate" \ else (lambda x: 60 / x) if in_units == "tempo" else (lambda x: x) convert_beat_length_to_output = (lambda x: 1 / x) if out_units == "rate" \ else (lambda x: 60 / x) if out_units == "tempo" else (lambda x: x) if hasattr(values, "__len__"): return tuple(convert_beat_length_to_output(convert_input_to_beat_length(x)) for x in values) else: return convert_beat_length_to_output(convert_input_to_beat_length(values))
[docs] def convert_durations_to_times(self): """ Warps this tempo_curve so that all of the locations of key points get re-interpreted as times instead of beat locations. For instance, a tempo curve where the rate hovers around 2 will see a segment of length 3 get stretched into a segment of length 6, since if it's supposed to take 3 seconds, it would take 6 beats. Pretty confusing, but when we want to construct a tempo curve specifying the *times* that changes occur rather than the beats, we can first construct it as though the durations were in beats, then call this function to warp it so that the durations are in time. :return: self, altered accordingly """ # this is a little confusing, like everything else about this function, but it represents the start beat of # the curve, which gets scaled inversely to the initial beat length, since a long initial beat length means # it won't take that many beats to get to the desired time. t = self.start_time() / self.start_level() for segment in self.segments: """ The following has been condensed into a single statement for efficiency: actual_time_duration = segment.integrate_segment(segment.start_time, segment.end_time) # the segment duration is currently in beats, but it also represents the duration we would like # the segment to have in time. so the scale factor is desired time duration / actual time duration scale_factor = segment.duration / actual_time_duration # here's we're scaling the duration to now last as long in time as it used to in beats modified_segment_length = scale_factor * segment.duration """ modified_segment_length = segment.duration ** 2 / segment.integrate_segment(segment.start_time, segment.end_time) segment.start_time = t t = segment.end_time = t + modified_segment_length return self
################################################################################################################## # Other Utilities ##################################################################################################################
[docs] def show_plot(self, title=None, resolution=25, show_segment_divisions=True, units="tempo", x_range=None, y_range=None): """ Shows a plot of this TempoEnvelope using matplotlib. :param title: A title to give the plot. :param resolution: number of points to use per envelope segment :param show_segment_divisions: Whether or not to place dots at the division points between envelope segments :param units: one of "tempo", "rate" or "beat length", determining the units of the y-axis :param x_range: min and max value shown on the x-axis :param y_range: min and max value shown on the y-axis """ # if we're past the end of the envelope, we want to plot that as a final constant segment # bring_up_to_date adds that segment, but we don't want to modify the original envelope, so we deepcopy env_to_plot = deepcopy(self)._bring_up_to_date() if self.end_time() < self.beat() else self try: import matplotlib.pyplot as plt except ImportError: raise ImportError("Could not find matplotlib, which is needed for plotting.") fig, ax = plt.subplots() x_values, y_values = env_to_plot._get_graphable_point_pairs(resolution) ax.plot(x_values, TempoEnvelope.convert_units(y_values, "beat length", units)) if show_segment_divisions: ax.plot(env_to_plot.times, TempoEnvelope.convert_units(env_to_plot.levels, "beat length", units), 'o') plt.xlabel("Beat") plt.ylabel("Tempo" if units == "tempo" else "Rate" if units == "rate" else "Beat Length") if x_range is not None: plt.xlim(x_range) if y_range is not None: plt.ylim(y_range) ax.set_title('Graph of TempoEnvelope' if title is None else title) plt.show()
def __repr__(self): return "TempoEnvelope({}, {}, {})".format( TempoEnvelope.convert_units(self.levels, "beatlength", "tempo"), self.durations, self.curve_shapes)
[docs]class MetricPhaseTarget: """ Class representing a particular point in a (beat or measure) cycle. :param phase_or_phases: Where we are in the cycle. :param divisor: Length of the cycle (defaults to one beat, meaning that this specifies where we are in the beat) :param relative: Whether or not the start of the cycle is measured relative to the current beat/time or to the start of the clock. """ def __init__(self, phase_or_phases: Union[float, Sequence[float]], divisor: float = 1, relative: bool = False): self.phases = (phase_or_phases, ) if not hasattr(phase_or_phases, "__len__") else phase_or_phases if not all(0 <= x < divisor for x in self.phases): raise ValueError("One or more phases out of range for divisor.") self.divisor = divisor self.relative = relative
[docs] @classmethod def interpret(cls, value: Union[float, Sequence]) -> 'MetricPhaseTarget': """ Interpret a tuple or just a number as a MetricPhaseTarget. E.g. we want the user to be able to hand in a tuple like (0.5, 3) and have it get interpreted as a target of 0.5 with divisor 3. :param value: either a tuple (which becomes the constructor arguments), a MetricPhaseTarget (which is passed through unchanged), or a number which is treated as the phase with other args as defaults. :return: A MetricPhaseTarget, interpreted from the argument """ if isinstance(value, MetricPhaseTarget): return value elif hasattr(value, "__len__"): return MetricPhaseTarget(*value) else: return MetricPhaseTarget(value)
def _get_nearest_matches(self, t: float, offset: float = 0) -> Tuple[float, float]: floored_value = math.floor(t / self.divisor) * self.divisor closest_below = None closest_above = None min_dist_below = float("inf") min_dist_above = float("inf") for base_multiple in (floored_value - self.divisor, floored_value, floored_value + self.divisor): for remainder in self.phases: remainder = (remainder + offset) % self.divisor this_value = base_multiple + remainder if this_value < t and t - this_value < min_dist_below: closest_below = this_value min_dist_below = t - this_value elif this_value >= t and this_value - t < min_dist_above: closest_above = this_value min_dist_above = this_value - t # return the closest above and below in order of closeness return (closest_below, closest_above) if min_dist_below <= min_dist_above else (closest_above, closest_below)
[docs] def get_nearest_matching_beats(self, beat: float) -> Tuple[float, float]: """ Get the nearest beats below and above the given beat with the correct metric phase :param beat: the beat to search around :return: tuple of nearest beat below, nearest beat above """ if self.relative: return self._get_nearest_matches(beat, current_clock().beat()) else: return self._get_nearest_matches(beat)
[docs] def get_nearest_matching_times(self, time: float) -> Tuple[float, float]: """ Get the nearest times below and above the given time with the correct metric phase :param time: the time to search around :return: tuple of nearest time below, nearest time above """ if self.relative: return self._get_nearest_matches(time, current_clock().time()) else: return self._get_nearest_matches(time)
def __repr__(self): return "MetricPhaseTarget({}{}{})".format( str(self.phases[0]) if hasattr(self.phases, "__len__") else self.phases, (", " + str(self.divisor)) if self.divisor != 1 else "", ", True" if self.relative else "", )