summaryrefslogtreecommitdiff
path: root/phonology.py
blob: 1853523c5c7bd1203bfed0907276ecbeb316bc2e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
from cadence import *
from numpy import array
from numpy.random import choice, seed

class Phonology(object):
	"""weighted repository of rhythmic, harmonic and gestural features"""

	def __init__(self, footprints=[], functions=[], paths=[]):
		self.footprints = footprints
		self.functions = functions
		self.paths = paths

	def print(self):
		features = {
			'footprints': self.footprints,
			'functions': self.functions,
			'paths': self.paths,
		}
		print("\nPhonology")
		pprint(features)
		print()

	def addFootprintRule(self, footprintRule, weight=1):
		self.footprints.append((footprintRule, weight))

	def addFunctionRule(self, functionRule, weight=1):
		self.functions.append((functionRule, weight))

	def addPathRule(self, pathRule, weight=1):
		self.paths.append((pathRule, weight))

	def makeCadence(self, label=''): # (duration=None, harmonicFilter=None)
		""" assemble bundle of features from phonology rules """
		cadence = Cadence(label=label)
		cadence.footprint = self.makeFootprint()
		cadence.function = self.makeFunction()
		cadence.path = self.makePath()
		return cadence

	def makeFootprint(self):
		# select footprint rule
		weights = array([rule[1] for rule in self.functions])
		normalized_weights = weights.astype(float) / weights.sum()
		footprintChoices = array(self.footprints)
		index = choice(len(footprintChoices), p=normalized_weights)
		footprintRule = footprintChoices[index][0]

		# select feature value from range where necessary
		footprint = []
		for footRule in footprintRule:
			foot = {}
			# each foot option is composite
			footChoices = array(footRule['foot'])
			index = choice(len(footChoices))
			foot['foot'] = list(footChoices[index])
			# other feature options aren't
			foot['span'] = choice(footRule['span'])
			foot['gait'] = choice(footRule['gait'])
			# timing options are per note:
			foot['step'] = []
			for steps in footRule['step']:
				foot['step'].append( choice(steps) )
			footprint.append(foot)

		return footprint


	def makeFunction(self):
		# select function rule
		weights = array([rule[1] for rule in self.functions])
		normalized_weights = weights.astype(float) / weights.sum()
		functionChoices = array(self.functions)
		index = choice(len(functionChoices), p=normalized_weights)
		functionRule = functionChoices[index][0]

		# select value from range for each feature
		function = {}
		function['address'] = choice(functionRule['address'])
		function['transposition'] = choice(functionRule['transposition'])

		return function


	def makePath(self):

		# select path rule
		weights = array([rule[1] for rule in self.paths])
		normalized_weights = weights.astype(float) / weights.sum()
		pathChoices = array(self.paths)
		index = choice(len(pathChoices), p=normalized_weights)
		pathRule = pathChoices[index][0]


		# select value from range for each feature
		path = {}
		path['range'] = choice(pathRule['range'])
		path['figure'] = choice(pathRule['figure'])
		path['tilt'] = choice(pathRule['tilt'])

		return path