def test_merge(self):
ordered_list = [(10, 100), (5, 20), (7, 70), (2, 50)]
om = OrderedMap(ordered_list)
sup = [(3, 60), (15, 2)]
om.merge(sup)
self.assertTrue(3 in om.keys())
self.assertTrue(om.get(3) == 60)
self.assertTrue(15 in om.keys())
self.assertTrue(om.get(15) == 2)
self.assertTrue(5 in om.keys())
sup = {3: 60, 15: 2}
om.merge(sup)
self.assertTrue(3 in om.keys())
self.assertTrue(om.get(3) == 60)
self.assertTrue(15 in om.keys())
self.assertTrue(om.get(15) == 2)
self.assertTrue(5 in om.keys())
sup = OrderedMap({3: 60, 15: 2})
om.merge(sup)
self.assertTrue(3 in om.keys())
self.assertTrue(om.get(3) == 60)
self.assertTrue(15 in om.keys())
self.assertTrue(om.get(15) == 2)
self.assertTrue(5 in om.keys())
def test_get(self):
ordered_list = [(10, 100), (5, 20), (7, 70), (2, 50)]
om = OrderedMap(ordered_list)
a = om.get(5)
assert a == 20
from structure.time_signature import TimeSignature
from timemodel.time_signature_event import TimeSignatureEvent
tse = TimeSignatureEvent(TimeSignature(3, Duration(1, 4)), Position(0))
d = OrderedMap([(tse.time, tse)])
x = d.get(0)
assert x == tse
def __init__(self,
anchor_pitch=DiatonicPitch.parse('A:0'),
anchor_value=9,
pitch_unit=1):
"""
Constructor,
"""
self.__anchor_pitch = anchor_pitch
if not isinstance(self.anchor_pitch, DiatonicPitch):
raise Exception('Anchor is not a DiatonicPitch')
self.__anchor_value = anchor_value
self.__pitch_unit = pitch_unit
anchor_index = self.anchor_pitch.chromatic_distance
base_value = anchor_value - anchor_index * pitch_unit
self.value_to_pitch = OrderedMap()
self.pitch_to_value = dict()
for i in range(ChromaticScale.chromatic_start_index(),
ChromaticScale.chromatic_end_index() + 1):
pitch = DiatonicFoundation.map_to_diatonic_scale(i)[0]
value = base_value + i * pitch_unit
self.value_to_pitch.insert(value, pitch)
self.pitch_to_value[pitch] = value
PitchRangeInterpreter.__init__(self)
def _setup(self, transition_points):
self.__transition_points = sorted(transition_points,
key=lambda x: x[0])
self.__domain_start = self.__transition_points[0][0]
self.__domain_end = self.__transition_points[
len(self.__transition_points) - 1][0]
self.ordered_map = OrderedMap(self.transition_points)
def test_remove(self):
ordered_list = [(10, 100), (5, 20), (7, 70), (2, 50)]
om = OrderedMap(ordered_list)
assert 5 in om
assert om.get(5) == 20
om.remove_key(5)
assert 5 not in om
def test_ceil(self):
ordered_list = [(10, 100), (5, 20), (7, 70), (2, 50)]
om = OrderedMap(ordered_list)
answers = [2, 5, 5, 5, 7, 7, 10, 10, 10, None, None]
for i in range(1, 12):
key = om.ceil(i)
self.assertTrue(key == answers[i - 1])
mapto = None if key is None else om[key]
print('find {0} is {1} --> {2}'.format(i, key, mapto))
def test_floor(self):
ordered_list = [(10, 100), (5, 20), (7, 70), (2, 50)]
om = OrderedMap(ordered_list)
answers = [2, 2, 2, 5, 5, 7, 7, 7, 10, 10]
for i in range(2, 12):
key = om.floor(i)
self.assertTrue(key == answers[i - 2])
mapto = om[key]
print('find {0} is {1} --> {2}'.format(i, key, mapto))
def _reset_hc_list(self, hc_list):
p = Position(0)
new_ordered_map = OrderedMap()
for hc in hc_list:
hc.position = p
new_ordered_map.insert(p, hc)
p += hc.duration
self.ordered_map = new_ordered_map
self._wnt_duration = Duration(p.position)
def test_insert(self):
ordered_list = [(10, 100), (5, 20), (7, 70), (2, 50)]
om = OrderedMap(ordered_list)
om.insert(6, 60)
keys = om.keys()
last_key = -1
for k in keys:
print(k, om[k])
self.assertTrue(last_key < k)
last_key = k
def _setup(self, transition_points):
self.__transition_points = sorted(transition_points, key=lambda x: x[0])
self.__domain_start = self.__transition_points[0][0]
self.__domain_end = self.__transition_points[len(self.__transition_points) - 1][0]
lin_segs = []
for i in range(0, len(self.transition_points) - 1):
lin_segs.append((self.transition_points[i][0],
LinearSegment(self.transition_points[i], self.transition_points[i + 1])))
self.ordered_map = OrderedMap(lin_segs)
def _build_search_trees(self):
ts_mt_list = []
ts_time_list = []
tempo_mt_list = []
tempo_time_list = []
for element in self.element_list:
if element.is_tempo:
tempo_mt_list.append((element.position, element.element))
tempo_time_list.append((element.position_time, element.element))
else:
ts_mt_list.append((element.position, element.element))
ts_time_list.append((element.position_time, element.element))
self.ts_mt_map = OrderedMap(ts_mt_list) # whole note time --> TimeSignature
self.ts_time_map = OrderedMap(ts_time_list) # actual time --> TimeSignature
self.tempo_mt_map = OrderedMap(tempo_mt_list) # whole note time to Tempo
self.tempo_time_map = OrderedMap(tempo_time_list) # actual time to Tempo
# Build an ordered map, mapping BeatPosition --> time signature.
ts_bp_list = []
(position, ts) = ts_mt_list[0]
prior_pickup = 0
measure_tally = 0
if self.pickup.duration > 0:
num_beats = self.pickup.duration / ts.beat_duration.duration
ts_bp_list.append((BeatPosition(0, ts.beats_per_measure - num_beats), ts))
prior_pickup = num_beats
else:
ts_bp_list.append((BeatPosition(0, Fraction(0, 1)), ts))
for i in range(1, len(ts_mt_list)):
(position, ts) = ts_mt_list[i]
(prior_position, prior_ts) = ts_mt_list[i - 1]
num_beats = (position - prior_position).duration / prior_ts.beat_duration.duration - prior_pickup
num_measures = int(num_beats / prior_ts.beats_per_measure) + (1 if prior_pickup > 0 else 0)
measure_tally += num_measures
prior_pickup = 0
ts_bp_list.append((BeatPosition(measure_tally, 0), ts))
self.ts_bp_map = OrderedMap(ts_bp_list) # beat position --> TimeSignature
def test_order(self):
ordered_list = [(10, 100), (5, 20), (7, 70), (2, 50)]
om = OrderedMap(ordered_list)
keys = om.keys()
last_key = -1
for k in keys:
print(k, om[k])
self.assertTrue(last_key < k)
last_key = k
ordered_list = [(Fraction(2, 3), 200), (Fraction(1, 10), 10),
(Fraction(1, 2), 50), (Fraction(1, 8), 20)]
om = OrderedMap(ordered_list)
keys = om.keys()
last_key = -1
for k in keys:
print(k, om[k])
self.assertTrue(last_key < k)
last_key = k
ordered_list = [(Position(2, 3), 200), (Position(1, 10), 10),
(Position(1, 2), 50), (Position(1, 8), 20)]
om = OrderedMap(ordered_list)
keys = om.keys()
last_key = -Fraction(1, 1)
for k in keys:
print(k, om[k])
self.assertTrue(last_key < k.position)
last_key = k.position
ordered_list = [(Duration(2, 3), 200), (Duration(1, 10), 10),
(Duration(1, 2), 50), (Duration(1, 8), 20)]
om = OrderedMap(ordered_list)
keys = om.keys()
last_key = -Fraction(1, 1)
for k in keys:
print(k, om[k])
self.assertTrue(last_key < k.duration)
last_key = k.duration
def class_init():
if DynamicsHelper.NAME_MAP is not None:
return
DynamicsHelper.NAME_MAP = {
Dynamics.PPPP: 'pianissississimo',
Dynamics.PPP: 'pianississimo0',
Dynamics.PP: 'pianissimo',
Dynamics.P: 'piano',
Dynamics.MP: 'mezzo piano',
Dynamics.MF: 'messo forte',
Dynamics.F: 'forte',
Dynamics.FF: 'fortissimo',
Dynamics.FFF: 'fortississimo',
Dynamics.FFFF: 'fortissississimo',
}
DynamicsHelper.DYNAMICS_VALUE_MAP = {
Dynamics.PPPP: 16,
Dynamics.PPP: 24,
Dynamics.PP: 33,
Dynamics.P: 49,
Dynamics.MP: 64,
Dynamics.MF: 80,
Dynamics.F: 96,
Dynamics.FF: 112,
Dynamics.FFF: 120,
Dynamics.FFFF: 127,
}
DynamicsHelper.DYNAMICS_LIST = [
Dynamics.PPPP,
Dynamics.PPP,
Dynamics.PP,
Dynamics.P,
Dynamics.MP,
Dynamics.MF,
Dynamics.F,
Dynamics.FF,
Dynamics.FFF,
Dynamics.FFFF,
]
DynamicsHelper.DEFAULT_DYNAMICS = Dynamics.MP
DynamicsHelper.DEFAULT_DYNAMICS_VELOCITY = DynamicsHelper.DYNAMICS_VALUE_MAP[
DynamicsHelper.DEFAULT_DYNAMICS]
DynamicsHelper.REVERSE_DYNAMICS_VELOCITY_MAP = OrderedMap({
value: key
for (key, value) in DynamicsHelper.DYNAMICS_VALUE_MAP.items()
})
def __init__(self, event_list=None):
"""
Constructor.
Args:
event_list: Any of None, a single Event, or a list of Events.
"""
self.ordered_map = OrderedMap()
self._successor = {}
self._predecessor = {}
self.__first = None
self.__last = None
if event_list:
self.add(event_list)
def _compute_cue_tone(old_cue_tone, tonality):
from misc.ordered_map import OrderedMap
tones = tonality.annotation[:-1]
s = OrderedMap({v.placement: tones.index(v) for v in tones})
least_index = s[min(pl for pl in s.keys())]
nearest_pl = s.floor(old_cue_tone.placement)
if nearest_pl is None:
return tones[-1 if least_index == 0 else least_index -
1], tones[least_index]
if nearest_pl == old_cue_tone.placement:
return tones[s[nearest_pl]], None
nearest_idx = s[nearest_pl]
return tones[nearest_idx], tones[nearest_idx +
1 if nearest_idx != len(tones) -
1 else 0]
def _compute_neighbor_tones(cue_tone, tone_list):
# Find from tone_list, a tone1, tone2 with tone1<=tone<=tone2 with nearest proximity/
from misc.ordered_map import OrderedMap
# s : placement -> index over all tones in tone_list
s = OrderedMap({v.placement: tone_list.index(v) for v in tone_list})
# least_index == index of tone in tone_list mapped by least placement.
least_index = s[min(pl for pl in s.keys())]
# nearest_pl = s's placement key that is just below cue_tones placement
nearest_pl = s.floor(cue_tone.placement)
if nearest_pl is None:
return tone_list[-1 if least_index == 0 else least_index - 1], tone_list[least_index]
if nearest_pl == cue_tone.placement:
return tone_list[s[nearest_pl]], None
nearest_idx = s[nearest_pl]
return tone_list[nearest_idx], tone_list[nearest_idx + 1 if nearest_idx != len(tone_list) - 1 else 0]
def __init__(self,
tonality,
anchor_pitch=None,
anchor_value=None,
pitch_unit=1):
"""
Constructor.
:param tonality: The tonality being mapped to.
:param anchor_pitch: A DiatonicPitch, in combo with anchor_value is a sample of the mapping.
:param anchor_value: A numeric value that maps to anchor_pitch.
:param pitch_unit: In the linear map of value to pitches, pitch_unit is the distance between mapping values.
"""
self.__tonality = tonality
self.__pitch_scale = PitchScale(self.tonality,
PitchRange.create('A:0',
'C:8')).pitch_scale
self.anchor_pitch = self.pitch_scale[0] if anchor_pitch is None else \
DiatonicPitch.parse(anchor_pitch) if isinstance(anchor_pitch, str) else anchor_pitch
anchor_index = self.pitch_scale.index(self.anchor_pitch)
if anchor_index == -1:
raise Exception(
'Anchor pitch \'{0}\' not found in pitch scale for tonality \'{1}\''
.format(self.anchor_pitch, self.tonality))
self.__pitch_unit = pitch_unit
self.anchor_value = anchor_value if anchor_value is not None else anchor_index * self.pitch_unit
# base value should map to beginning of pitch scale!
# recall that pitch unit maps to each pitch, making the scalar scale linear in value!
base_value = anchor_value - anchor_index * pitch_unit
self.value_to_pitch = OrderedMap()
self.pitch_to_value = dict()
for i in range(0, len(self.pitch_scale)):
pitch = self.pitch_scale[i]
value = base_value + i * pitch_unit
self.value_to_pitch.insert(value, pitch)
self.pitch_to_value[pitch] = value
PitchRangeInterpreter.__init__(self)
def __init__(self):
"""
Constructor.
"""
self.ordered_map = OrderedMap()
self._wnt_duration = Duration(0)
def clear(self):
self.ordered_map = OrderedMap()
self._wnt_duration = Duration(0)
