def mk_simple_conversion( mode: modes.Mode, funcs: tuple, subfunctions_per_interpol: tuple ) -> old.JICadence: """Expect real functions (with applied modulation), not symbolic functions""" def get_from_func_pitch(func) -> ji.JIPitch: p = func(mode) if p.set_val_border(2).primes == (3,): # 3 * 9 doesn't exist in current tuning return p.normalize(2) - ji.r(2, 1) else: return mel.TheEmptyPitch def filter_subfunc_pitch(pitch) -> ji.JIPitch: if pitch == ji.r(1, 1): pitch += ji.r(2, 1) if pitch in SITER_BARUNG.pitches: return pitch else: return mel.TheEmptyPitch res = [] for func0, func1, subfuncline in zip(funcs, funcs[1:], subfunctions_per_interpol): fp = get_from_func_pitch(func0) subfunc_pitches = list( (filter_subfunc_pitch(p),) for p in subfuncline.convert_signifiers2pitches(mode, func0, func1)[:-1] ) if fp: subfunc_pitches[0] = subfunc_pitches[0] + (fp,) for h in subfunc_pitches: h = tuple(p for p in h if p) res.append(h) return old.JICadence([old.Chord(ji.JIHarmony(h), 1) for h in res])
def mk_loop_cadence_with_tuk(loopsize: int, meter: metre.Metre) -> old.JICadence: size = meter.size loop_amount = size // loopsize rest = size % loopsize harmony0 = ji.JIHarmony([ji.r(3, 2)]) harmony1 = ji.JIHarmony([ji.r(1, 1)]) basic_cadence = [old.Chord(harmony0, 0.5) ] + [old.Chord(harmony1, 1) for i in range(loopsize - 1)] basic_cadence.append(old.Chord(harmony1, 0.5)) print(old.JICadence(basic_cadence).duration) cadence = [basic_cadence for i in range(loop_amount)] cadence = functools.reduce(operator.add, cadence) if rest: cadence.append(old.Chord(harmony0, rest)) return old.JICadence(cadence)
def mk_siter_cadence( self, siter_panerus_pitch, gender, previous_signified: int, previous_side_prime: int, current_signified: int, current_side_prime: int, following_signified: int, following_side_prime: int, stresses, ) -> old.JICadence: siter_pitches = self.siter_style.convert2interpolation( gender, previous_signified, previous_side_prime, current_signified, current_side_prime, following_signified, following_side_prime, stresses, ) siter_pitches = tuple(ji.JIHarmony([p]) for p in siter_pitches) siter_pitches = (ji.JIHarmony(siter_panerus_pitch), ) + siter_pitches return old.JICadence([old.Chord(h, 1) for h in siter_pitches])
def mk_simple_conversion(mode: modes.Mode, compounds_per_function: tuple, funcs: tuple) -> old.JICadence: def define_gong(mode) -> ji.JIPitch: gong_pitch = ji.r( functools.reduce(operator.mul, (mode.x, mode.y, mode.z)), 1) if not mode.gender: gong_pitch = gong_pitch.inverse() return gong_pitch.normalize(2) - ji.r(4, 1) def get_pitch(f) -> ji.JIPitch: p = f(mode) if p.set_val_border(2).primes == ( 3, ): # 3 * 9 doesn't exist in current tuning return mel.TheEmptyPitch else: return f(mode).normalize() - ji.r(2, 1) gong = define_gong(mode) pitches = tuple(get_pitch(f) for f in funcs) pitches = ((gong, p) if f.gong else (p, ) for f, p in zip(funcs, pitches)) return old.JICadence([ old.Chord(ji.JIHarmony(tuple(pi for pi in p if pi)), delay) for p, delay in zip(pitches, compounds_per_function) ])
def create_cadence( self, stresses: tuple, does_siter_play: tuple, gender: bool, previous_signified: int, current_signified: int, following_signified: int, previous_side_prime: int, current_side_prime: int, following_side_prime: int, ) -> old.JICadence: amount_hits = len(stresses) + 1 main_prime = current_signified side_prime = current_side_prime if amount_hits == 1: pattern = (self.pattern["silent"](gender, main_prime, side_prime), ) elif amount_hits == 2: pattern = tuple(self.pattern[p](gender, main_prime, side_prime) for p in ("silent", "to_gong_last")) else: beginning = ("to_gong_first", "to_gong_second") ending = ("to_gong_last", ) left = amount_hits - sum((len(beginning), len(ending))) cycle = itertools.cycle(("to_gong_middle0", "to_gong_middle1")) middle = tuple(next(cycle) for n in range(left)) pattern = tuple(self.pattern[p](gender, main_prime, side_prime) for p in beginning + middle + ending) cadence = functools.reduce(operator.add, pattern) return old.JICadence(cadence)
def return_cadence_and_instrument_for_complex(idx, tf, time_lv, is_sutained, cadences, instruments, is_full_or_not_per_sec): def detect_correct_instrument_for_empty_section( idx, is_full_or_not_per_sec): for is_full_or_not in is_full_or_not_per_sec[idx + 1:]: if is_full_or_not[0]: return instruments[1] elif is_full_or_not[1]: return instruments[2] for is_full_or_not in reversed(is_full_or_not_per_sec[:idx]): if is_full_or_not[0]: return instruments[1] elif is_full_or_not[1]: return instruments[2] return instruments[0] if all(is_full_or_not_per_sec[idx]): return cadences[0], instruments[0] elif all(tuple(not b for b in is_full_or_not_per_sec[idx])): i = detect_correct_instrument_for_empty_section( idx, is_full_or_not_per_sec) return old.JICadence([old.Rest(tf.size)]), i else: if cadences[0]: return cadences[0], instruments[1] else: return cadences[1], instruments[2]
def create_cadence( self, stresses: tuple, does_siter_play: tuple, gender: bool, previous_signified: int, current_signified: int, following_signified: int, previous_side_prime: int, current_side_prime: int, following_side_prime: int, ) -> old.JICadence: chord0 = old.Chord(ji.JIHarmony([]), 1) pattern = self.detect_pattern( stresses, does_siter_play, gender, previous_signified, current_signified, following_signified, previous_side_prime, current_side_prime, following_side_prime, ) final_cadence = [chord0] for idx, pat in enumerate(pattern): pat = list(pat) final_cadence += pat return old.JICadence(final_cadence)
def convert2cadence(self, tempo_factors_per_unit: tuple, delays: tuple) -> old.JICadence: """ """ def return_item_and_sizes(element, lv=0) -> tuple: if type(element) == ji.JIHarmony or element == mel.TheEmptyPitch: return ((element, lv), ) else: ret = tuple([]) for tup in (return_item_and_sizes(it, lv + 1) for it in element): ret += tup return ret divisions_per_elements = int(tempo.TempoLine.divisions_per_element) cadence = [] unit_count = 0 for meter in self.__structure: for compound in meter: for unit in compound: delay = delays[unit_count] if delay: if cadence: cadence[-1].delay += delay.duration cadence[-1].duration += delay.duration else: cadence.append(old.Rest(delay.duration)) factors = tempo_factors_per_unit[unit_count] abstract_delays = [] harmonies = [] for element in unit: item_and_size_pairs = return_item_and_sizes(element) for pair in item_and_size_pairs: harmonies.append(pair[0]) de = int(divisions_per_elements * (1 / (2**pair[1]))) abstract_delays.append(de) real_delays = tuple( itertools.accumulate([0] + abstract_delays)) real_delays = tuple( sum(factors[idx0:idx1]) for idx0, idx1 in zip(real_delays, real_delays[1:])) for h, de in zip(harmonies, real_delays): if h: cadence.append(old.Chord(h, de)) else: cadence.append(old.Rest(de)) unit_count += 1 cadence = old.JICadence(cadence).discard_rests() return cadence
def load_cadence(name: str, pitch=None, rhythm=None): if not pitch: pitch = sw.translate_from_file("pitch/{0}".format(name)) if not rhythm: with open("rhythm/{0}".format(name), "r") as rhythm: rhythm = " ".join(rhythm.read().splitlines()) rhythm = rhythm.split(" ") rhythm = tuple(float(n) for n in rhythm if n) return old.JICadence([old.Chord(p, r) for p, r in zip(pitch, rhythm)])
def mk_loop_cadence(loopsize: int, meter: metre.Metre) -> old.JICadence: size = meter.size loop_amount = size // loopsize rest = size % loopsize harmony = ji.JIHarmony([ji.r(3, 2)]) cadence = [old.Chord(harmony, loopsize) for i in range(loop_amount)] if rest: cadence.append(old.Chord(harmony, rest)) return old.JICadence(cadence)
def __call__(self, gender: bool, main_prime: int, side_prime: int) -> old.JICadence: pitches = sw.translate( self.__line, decodex={ self.main: str(main_prime), self.side: str(side_prime) }, inverse=not gender, ) return old.JICadence( [old.Chord(h, r) for h, r in zip(pitches, self.__rhythms)])
def __call__(self, gender: bool, main_prime: int, side_prime: int) -> old.JICadence: if not main_prime: main_prime = 3 if not side_prime: side_prime = 5 not_current_main_primes = tuple(p for p in (3, 5, 7) if p != main_prime) if len(not_current_main_primes) == 3: not_current_main_primes = (5, 7) if not_current_main_primes[0] == side_prime: not_current_main_primes = tuple(reversed(not_current_main_primes)) not_current_side_primes = tuple(p for p in (3, 5, 7) if p != side_prime) if len(not_current_side_primes) == 3: not_current_side_primes = (5, 7) if not_current_side_primes[0] == main_prime: not_current_side_primes = tuple(reversed(not_current_side_primes)) if main_prime == 9: tranformed_mp = 3 else: tranformed_mp = main_prime if side_prime == 9: tranformed_sp = 3 else: tranformed_sp = side_prime pitches = sw.translate( self.line, decodex={ self.main: str(main_prime), self.side: str(side_prime), self.not_current_main_prime0: str(not_current_main_primes[0]), self.not_current_main_prime1: str(not_current_main_primes[1]), self.not_current_side_prime0: str(not_current_side_primes[0]), self.not_current_side_prime1: str(not_current_side_primes[1]), self.transformed_main_prime: str(tranformed_mp), self.transformed_side_prime: str(tranformed_sp), }, inverse=not gender, ) return old.JICadence( [old.Chord(h, r) for h, r in zip(pitches, self.rhythms)])
def create_cadence( self, stresses: tuple, does_siter_play: tuple, gender: bool, previous_signified: int, current_signified: int, following_signified: int, previous_side_prime: int, current_side_prime: int, following_side_prime: int, ) -> old.JICadence: usize = len(stresses) + 1 cadence = self.pattern[usize](gender, current_signified, current_side_prime) return old.JICadence(cadence)
def mk_mdc_gong_and_tong(cadence, timeflow) -> tuple: cadence_gong, cadence_tong = [], [] for chord in cadence: hg, ht = [], [] for p in chord.pitch: if p < ji.r(1, 2): hg.append(p) else: ht.append(p) cadence_gong.append(old.Chord(ji.JIHarmony(hg), chord.delay)) cadence_tong.append(old.Chord(ji.JIHarmony(ht), chord.delay)) cadences = tuple( old.JICadence(c).discard_rests() for c in (cadence_gong, cadence_tong)) return tuple( MDC.mk_mdc_by_cadence(c, timeflow, Score.TIME_LV_PER_INSTRUMENT[0], False) for c in cadences)
def convert_modulation_pattern( gender: bool, main_prime: int, side_prime: int, next_main_prime: int, next_side_prime: int, pattern: tuple, with_header: bool, ): header, body, tail = pattern cadence = old.JICadence([]) if with_header: cadence += header(gender, main_prime, side_prime) cadence += body(gender, main_prime, side_prime) cadence += tail(gender, next_main_prime, next_side_prime) return cadence
def create_cadence( self, stresses: tuple, does_siter_play: tuple, gender: bool, previous_signified: int, current_signified: int, following_signified: int, previous_side_prime: int, current_side_prime: int, following_side_prime: int, ) -> old.JICadence: usize = (len(stresses) + 1) * 2 amount_pattern = usize / self.loopsize assert int(amount_pattern) == amount_pattern cadence = tuple( self.get_pattern(gender, current_signified, current_side_prime) for i in range(int(amount_pattern))) return old.JICadence(cadence)
def create_cadence( self, stresses: tuple, does_siter_play: tuple, gender: bool, previous_signified: int, current_signified: int, following_signified: int, previous_side_prime: int, current_side_prime: int, following_side_prime: int, ) -> old.JICadence: if self.apply_with_header_if_header_exist: cadence = old.JICadence([]) else: cadence = old.JICadence([old.Chord(ji.JIHarmony([]), 0.5)]) divided_stresses = self.divide_stresses(stresses) amount_divisions = len(divided_stresses) is_with_modulation = current_signified != following_signified for idx, division in enumerate(divided_stresses): if idx == 0 and self.apply_with_header_if_header_exist: add_header = True else: add_header = False amount_stresses = len(division) is_with_resolution = not all(tuple(not s for s in division)) conditions_for_modulation = ( is_with_modulation, not is_with_resolution, idx + 1 == amount_divisions, ) if all(conditions_for_modulation): pattern = self.pattern[1][amount_stresses] cadence += self.convert_modulation_pattern( gender, current_signified, current_side_prime, following_signified, following_side_prime, pattern, add_header, ) else: pattern_idx = int(amount_stresses) if is_with_resolution: add_tail = True else: pattern_idx += 1 add_tail = False pattern = self.pattern[0][pattern_idx] cadence += self.convert_resolution_pattern( gender, current_signified, current_side_prime, pattern, add_header, add_tail, ) return old.JICadence(cadence)
def return_gender_dependent_instrument(cadence, mode) -> tuple: if mode.gender: return (cadence, old.JICadence([])) else: return (old.JICadence([]), cadence)