def init_filters_and_variables(self):
self.num_filters = 3
self.num_variables = 1 + self.num_filters
self.fourier_1d_0 = Fourier1D.Fourier1D(self.size[0],
self.size_cutoff_k_vectors)
self.fourier_dim = self.fourier_1d_0.fourier_dim
#
# We might be able to slowly tune this down
#
self.heaviside_bandwidth = 0.05
self.heaviside_1 = heaviside.Heaviside(self.heaviside_bandwidth)
scale_real_min = np.real(self.permittivity_bounds[0])
scale_real_max = np.real(self.permittivity_bounds[1])
scale_real_2 = scale.Scale([scale_real_min, scale_real_max])
scale_imag_min = np.imag(self.permittivity_bounds[0])
scale_imag_max = np.imag(self.permittivity_bounds[1])
scale_imag_2 = scale.Scale([scale_imag_min, scale_imag_max])
self.scale_2 = [scale_real_2, scale_imag_2]
# Initialize the filter chain
self.filters = [self.fourier_1d_0, self.heaviside_1, self.scale_2]
self.update_filters(0)
#
# This will init the variable as complex datatype, which is good for the fourier representation
#
self.init_variables_(self.fourier_dim)
def setup():
led_pins = {
'RED': 16,
'GREEN': 20,
'BLUE': 21,
}
segment_pins = {
'SEGMENTS': [
11, # 7seg 11
4, # 7seg 7
23, # 7seg 4
8, # 7seg 2
7, # 7seg 1
10, # 7seg 10
18, # 7seg 5
25, # 7seg 3 (decimal point)
],
'DIGITS': [
22, # 1
27, # 2
17, # 3
24, # 4
],
}
os.makedirs(DATA_DIR, exist_ok=True)
scale = scale_util.Scale(data_dir=DATA_DIR)
rgb = rgb_util.Rgb(led_pins)
ssegment = ssegment_util.SevenSegment(segment_pins)
coach = water_coach.WaterCoach(scale, rgb, ssegment)
return scale, rgb, ssegment, coach
def init_filters_and_variables(self):
self.num_filters = 2
self.num_variables = 1 + self.num_filters
x_dimension_idx = 0
y_dimension_idx = 1
z_dimension_idx = 2
z_voxel_layers = self.size[2]
self.layering_z_0 = layering.Layering(z_dimension_idx,
self.num_z_layers, [0, 1],
self.spacer_height_voxels, 0.0)
# alpha = 8
# self.blur_half_width = blur_half_width_voxels
#
# This notation is slightly confusing, but it is meant to be the
# direction you blur when you are on the layer corresponding to x-
# or y-layering. So, if you are layering in x, then you blur in y
# and vice versa.
#
# self.max_blur_xy_1 = square_blur.SquareBlur(
# alpha,
# [self.blur_half_width, self.blur_half_width, 0])
scale_min = self.permittivity_bounds[0]
scale_max = self.permittivity_bounds[1]
self.scale_1 = scale.Scale([scale_min, scale_max])
# Initialize the filter chain
self.filters = [self.layering_z_0, self.scale_1]
self.init_variables()
def __init__(self,
rythm=4,
breve_value=4,
name='',
keynote=pitch.Pitch.C4,
mode=scale.Mode.M,
nscale=None,
modulations=None,
comments=None):
"""If nscale is set, keynote and mode are discarded
If modulations is set, nscale is also discarded.
"""
self._stave = []
self.rythm = rythm
self.breve_value = breve_value
self.title = name
self.comments = comments if comments else {}
if modulations is not None:
self.modulations = modulations
first = modulations[0]
self.keynote = first.key
self.scale = first.scale
elif nscale is None:
self.keynote = keynote
self.mode = mode
self.scale = scale.Scale(keynote, mode)
else:
self.scale = nscale
self.keynote = nscale.keynote
self.mode = nscale.mode
def init_filters_and_variables(self):
self.num_filters = 5
self.num_variables = 1 + self.num_filters
# Start the sigmoids at weak strengths
self.sigmoid_beta = 0.0625
self.sigmoid_eta = 0.5
self.sigmoid_0 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
self.sigmoid_3 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
x_dimension_idx = 0
y_dimension_idx = 1
z_dimension_idx = 2
z_voxel_layers = self.size[2]
self.layering_z_1 = layering.Layering(z_dimension_idx,
self.num_z_layers)
alpha = 8
self.blur_half_width = blur_half_width_voxels
#
# This notation is slightly confusing, but it is meant to be the
# direction you blur when you are on the layer corresponding to x-
# or y-layering. So, if you are layering in x, then you blur in y
# and vice versa.
#
self.max_blur_xy_2 = square_blur.SquareBlur(
alpha, [self.blur_half_width, self.blur_half_width, 0])
scale_real_min = np.real(self.permittivity_bounds[0])
scale_real_max = np.real(self.permittivity_bounds[1])
scale_real_4 = scale.Scale([scale_real_min, scale_real_max])
scale_imag_min = np.imag(self.permittivity_bounds[0])
scale_imag_max = np.imag(self.permittivity_bounds[1])
scale_imag_4 = scale.Scale([scale_imag_min, scale_imag_max])
self.scale_4 = [scale_real_4, scale_imag_4]
# Initialize the filter chain
self.filters = [
self.sigmoid_0, self.layering_z_1, self.max_blur_xy_2,
self.sigmoid_3, self.scale_4
]
self.init_variables()
def relative_modulation(s: stave.Stave):
"""Modulation allowed only if it is the relative one"""
sc = scale.Scale(s.keynote, s.mode)
relative = sc.relative(scale.Mode.m_full)
for n in s:
if n.pitch not in sc and n.pitch not in relative:
error.warn("It is forbidden to modulate outside the relative key",
n)
def test_eq():
ns1 = NS(scale0, P.A3)
ns2 = NS(scale0, P.A3)
assert ns1.__eq__(ns2)
ns3 = NS(scale0, P.A4)
assert not ns3.__eq__(ns2)
with pytest.raises(ValueError):
other_scale_ns = NS(scale.Scale(P.A5, Mode.m), P.A3)
ns1 == other_scale_ns
def init_filters_and_variables(self): self.num_filters = 2 self.num_variables = 1 + self.num_filters self.layering_y_0 = layering.Layering(self.y_dimension_idx, self.num_y_layers) scale_real_min = np.real( self.permittivity_bounds[0] ) scale_real_max = np.real( self.permittivity_bounds[1] ) scale_real_1 = scale.Scale([scale_real_min, scale_real_max]) scale_imag_min = np.imag( self.permittivity_bounds[0] ) scale_imag_max = np.imag( self.permittivity_bounds[1] ) scale_imag_1 = scale.Scale([scale_imag_min, scale_imag_max]) self.scale_1 = [ scale_real_1, scale_imag_1 ] self.update_filters( 0 ) self.init_variables()
def rule_12(s: stave.Stave):
"""On ne doit moduler qu'aux tons relatifs"""
sc = scale.Scale(s.keynote, s.mode)
relative = sc.relative(scale.Mode.m_full)
for bar in s.barIter():
note = bar[0]
if note.pitch not in sc:
if note.pitch not in relative:
raise error.CompositionError(
"It is forbidden to modulate outside the relative key",
bar)
def init_filters_and_variables(self):
self.num_filters = 3
self.num_variables = 1 + self.num_filters
self.layering_y_0 = layering.Layering(self.y_dimension_idx,
self.num_y_layers)
blur_alpha = 8.0
self.blur_horizontal_1 = generic_blur_2d.make_rectangular_blur(
blur_alpha, np.abs(self.dilate_size_voxels), 0)
scale_real_min = np.real(self.permittivity_bounds[0])
scale_real_max = np.real(self.permittivity_bounds[1])
scale_real_2 = scale.Scale([scale_real_min, scale_real_max])
scale_imag_min = np.imag(self.permittivity_bounds[0])
scale_imag_max = np.imag(self.permittivity_bounds[1])
scale_imag_2 = scale.Scale([scale_imag_min, scale_imag_max])
self.scale_2 = [scale_real_2, scale_imag_2]
self.update_filters(0)
self.init_variables()
def init_filters_and_variables(self):
self.num_filters = 4
self.num_variables = 1 + self.num_filters
self.fourier_1d_0 = Fourier1D.Fourier1D(
self.size[0], self.feature_size_cutoff_voxels)
self.fourier_dim = self.fourier_1d_0.fourier_dim
self.ramp_1 = ramp.Ramp()
# Start the sigmoid at weak strengths
self.sigmoid_beta = 0.0625
self.sigmoid_eta = 0.5
self.sigmoid_2 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
scale_real_min = np.real(self.permittivity_bounds[0])
scale_real_max = np.real(self.permittivity_bounds[1])
scale_real_3 = scale.Scale([scale_real_min, scale_real_max])
scale_imag_min = np.imag(self.permittivity_bounds[0])
scale_imag_max = np.imag(self.permittivity_bounds[1])
scale_imag_3 = scale.Scale([scale_imag_min, scale_imag_max])
self.scale_3 = [scale_real_3, scale_imag_3]
# Initialize the filter chain
self.filters = [
self.fourier_1d_0, self.ramp_1, self.sigmoid_2, self.scale_3
]
self.update_filters(0)
#
# This will init the variable as complex datatype, which is good for the fourier representation
#
self.init_variables_(self.fourier_dim)
def init_filters_and_variables(self):
self.num_filters = 2 #5
self.num_variables = 1 + self.num_filters
# Start the sigmoids at weak strengths
self.sigmoid_beta = 0.5 * 0.0625
self.sigmoid_eta = 0.5
self.sigmoid_0 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
self.scale_1 = scale.Scale(self.permittivity_bounds)
# Initialize the filter chain
self.filters = [self.sigmoid_0, self.scale_1]
self.update_filters(0)
self.init_variables()
def init_filters_and_variables(self):
self.num_filters = 6
self.num_variables = 1 + self.num_filters
# Start the sigmoids at weak strengths
self.sigmoid_beta = 0.0625
self.sigmoid_eta = 0.5
self.sigmoid_0 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
self.sigmoid_2 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
x_dimension_idx = 0
y_dimension_idx = 1
z_dimension_idx = 2
alpha = 8
# I truly dislike this silent parameter passing, like truly scarily bad coding
self.blur_half_width = max_blur_filter_half_width
# This notation is slightly confusing, but it is meant to be the
# direction you blur when you are on the layer corresponding to x-
# or y-layering. So, if you are layering in x, then you blur in y
# and vice versa.
self.max_blur_xy_1 = square_blur.SquareBlur(
alpha, [self.blur_half_width, self.blur_half_width, 0])
self.gaussian_blur_3 = GaussianBlur(gaussian_blur_filter_sigma)
z_voxel_layers = self.size[2]
self.layering_z_4 = layering.Layering(z_dimension_idx,
self.num_z_layers, [0, 1],
self.spacer_height_voxels, 0.0)
scale_min = self.permittivity_bounds[0]
scale_max = self.permittivity_bounds[1]
self.scale_5 = scale.Scale([scale_min, scale_max])
# Initialize the filter chain
self.filters = [
self.sigmoid_0, self.max_blur_xy_1, self.sigmoid_2,
self.gaussian_blur_3, self.layering_z_4, self.scale_5
]
self.init_variables()
def init_filters_and_variables(self): self.num_filters = 3 self.num_variables = 1 + self.num_filters # Start the sigmoids at weak strengths self.sigmoid_beta = 0.0625 self.sigmoid_eta = 0.5 self.sigmoid_1 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta) x_dimension_idx = 0 y_dimension_idx = 1 z_dimension_idx = 2 z_voxel_layers = self.size[2] self.layering_z = layering.Layering( z_dimension_idx, self.num_z_layers, [ 0, 1 ], self.spacer_height_voxels, 0.0 ) scale_min = self.permittivity_bounds[0] scale_max = self.permittivity_bounds[1] self.scale_2 = scale.Scale([scale_min, scale_max]) self.init_variables()
def init_filters_and_variables(self):
self.num_filters = 5
self.num_variables = 1 + self.num_filters
# Start the sigmoids at weak strengths
self.sigmoid_beta = 0.0625
self.sigmoid_eta = 0.5
self.sigmoid_1 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
self.sigmoid_3 = sigmoid.Sigmoid(self.sigmoid_beta, self.sigmoid_eta)
x_dimension_idx = 0
y_dimension_idx = 1
z_dimension_idx = 2
z_voxel_layers = self.size[2]
self.layering_z_0 = layering.Layering(z_dimension_idx,
self.num_z_layers)
alpha = 12
self.blur_half_width = blur_half_width_voxels
self.max_blur_xy_2 = generic_blur_2d.make_square_blur(
alpha, self.blur_half_width)
scale_min = self.permittivity_bounds[0]
scale_max = self.permittivity_bounds[1]
self.scale_4 = scale.Scale([scale_min, scale_max])
# Initialize the filter chain
self.filters = [
self.layering_z_0, self.sigmoid_1, self.max_blur_xy_2,
self.sigmoid_3, self.scale_4
]
self.init_variables()
self.update_permittivity()
def toScale(self):
#Opens a window using code from scale.py
self.slideWindow = scale.Scale()
self.slideWindow.show()
def create_scales(pos, width=512, height=512):
min_, max_ = extent(pos)
scale_x = scale.Scale(domain=(min_[0], max_[0]), rang=(0, width))
scale_y = scale.Scale(domain=(min_[1], max_[1]), rang=(0, height))
return scale_x, scale_y
def _get_scale(serial):
return scale.Scale(serial)
import sys
sys.path.append('./cpv')
import cadence
import chord
import scale
import pitch
AbC = chord.AbstractChord
AcC = chord.ActualChord
P = pitch.Pitch
C = cadence.Cadence
main_scale = scale.Scale(P.C4, scale.Mode.M)
# 1st degree
perfect_high_root_1 = AcC(AbC(1, main_scale), [P.C4, P.E4, P.G4, P.C5])
perfect_high_third_1 = AcC(AbC(1, main_scale), [P.C4, P.G4, P.E5])
perfect_1st_inversion_1 = AcC(AbC(1, main_scale), [P.E3, P.C4, P.G4, P.C3])
# 5th degree
perfect_root_5 = AcC(AbC(5, main_scale), [P.G3, P.D4, P.G4, P.B4])
perfect_1st_inversion_5 = AcC(AbC(5, main_scale), [P.B3, P.D4, P.G4, P.D3])
def _NOtest_get_type():
assert C.getType(perfect_root_5,
perfect_high_root_1) is C.Type.PerfectAuthentic
assert C.getType(perfect_root_5,
perfect_high_third_1) is C.Type.ImperfectAuthenticRoot
assert C.getType(
perfect_root_5,
#Deus, in adjutorium meum intende
import sys
sys.path.append('./cpv/')
import chord
import pitch
import pytest
import scale
Chord = chord.Chord
AbstractChord = chord.Chord
mChord = chord._minor__chord
P = pitch.Pitch
scale0 = scale.Scale(P.C0, scale.Mode.M)
scale1 = scale.Scale(P.C0, scale.Mode.m_full)
chord0 = Chord(1, scale0)
chord07 = Chord(1, scale0, seventh=True)
chord1 = Chord(6, scale0)
chord2 = AbstractChord(3, scale0)
chord3 = AbstractChord(7, scale0)
generate_notes = lambda s: [P[val] for val in s.split()]
def test_new():
assert isinstance(Chord(1, scale1), mChord)
def test_contains():
def toScale(self):
self.slideWindow = scale.Scale()
self.slideWindow.show()
def add_gui(self):
#Quick function to format the time in the speed multiplier
def format_time(x):
if x > 31557600:
return str(round(x / 31557600, 3)) + " years/s"
if x > 2592000:
return str(round(x / 2592000, 3)) + " months/s"
if x > 604800:
return str(round(x / 604800, 3)) + " weeks/s"
if x > 86400:
return str(round(x / 86400, 3)) + " days/s"
if x > 3600:
return str(round(x / 3600, 3)) + " hours/s"
if x > 60:
return str(round(x / 60, 3)) + " minutes/s"
return str(round(x, 3)) + " seconds/s"
# Add the GUI objects
self.mouse_objects_stack.append(
slider.Slider("Speed multiplier",
self.dt,
1,
50000000,
self.dt.var,
Vec(410, 10),
200,
10,
10,
var_formatter=format_time,
interpolation_type=1))
self.scale = scale.Scale(Vec(630, 10), 150, 10, 1 / (self.camera.zoom))
self.mouse_objects_stack.append(
dropdownmenu.DropDownMenu("File", Vec(0, 0), 100, 30))
self.mouse_objects_stack[-1].add_button("Save", self.save_bodies,
self.renderer.font_medium,
self.mouse_objects_stack)
self.mouse_objects_stack[-2].add_button("Load", self.load_bodies,
self.renderer.font_medium,
self.mouse_objects_stack)
self.mouse_objects_stack[-3].add_button("Random",
self.generate_solar_system,
self.renderer.font_medium,
self.mouse_objects_stack)
self.mouse_objects_stack.append(
dropdownmenu.DropDownMenu("Options", Vec(297, 0), 100, 30))
self.mouse_objects_stack[-1].add_button(
"Tracers", lambda: self.change_flags(flags_file.RENDER_TRACERS),
self.renderer.font_medium, self.mouse_objects_stack)
self.mouse_objects_stack[-2].add_button(
"Labels",
lambda: self.change_flags(flags_file.RENDER_PLANET_LABELS),
self.renderer.font_medium, self.mouse_objects_stack)
self.mouse_objects_stack[-3].add_button(
"Shadows", lambda: self.change_flags(flags_file.SHADOWS),
self.renderer.font_medium, self.mouse_objects_stack)
self.mouse_objects_stack[-4].add_button(
"Unrealistic",
lambda: self.change_flags(flags_file.REALISTIC),
self.renderer.font_medium,
self.mouse_objects_stack,
toggled_name="Realistic")
self.mouse_objects_stack[-5].add_button(
"Pause",
lambda: self.change_flags(flags_file.PAUSED),
self.renderer.font_medium,
self.mouse_objects_stack,
toggled_name="Unpause")
self.mouse_objects_stack[-6].add_button(
"Fullscreen", lambda: self.renderer.toggle_fullscreen(self),
self.renderer.font_medium, self.mouse_objects_stack)
self.mouse_objects_stack[-7].add_button("Quit", pygame.quit,
self.renderer.font_medium,
self.mouse_objects_stack)
self.mouse_objects_stack.append(
button.Button("Add body", Vec(99, 0), 100, 30,
self.start_creating_new_body,
self.renderer.font_medium))
self.mouse_objects_stack.append(
dropdownmenu.DropDownMenu("Bodies", Vec(198, 0), 100, 30))
self.mouse_objects_stack[-1].add_button(
"None", lambda: [
self.camera.stop_tracking(),
self.finish_editing_body(),
self.remove_planet_info_labels()
], self.renderer.font_medium, self.mouse_objects_stack)
for body in self.bodies:
self.mouse_objects_stack[-1].add_button(
body.name,
lambda body=body:
[self.camera.track_body(body),
self.edit_existing_body(body)],
self.renderer.font_medium,
self.mouse_objects_stack)
import scale
import time
r = scale.Scale()
wt = r.getweight()
fd = open("weight.csv", "a")
print >> fd, time.ctime(), ",", wt, ",", ",".join(argv[1:])
ptemp = r.gettemp()
print "Weight=", wt
exit(int(wt * 100))
import sys
sys.path.append('./cpv')
import chord
import pitch
import scale
P = pitch.Pitch
main_s = scale.Scale(P.C4,scale.Mode.m_full)
tonic_chord = chord._minor__chord(1,main_s,False)
subdominant_chord = chord._minor__chord(4,main_s,False)
dominant_chord = chord._minor__chord(5,main_s,False)
def test_contains():
assert [P.A3,P.Ab3] in subdominant_chord
assert [P.B3,P.Bb3] in dominant_chord
def test_isPosition():
assert subdominant_chord.isPosition(P.C4,5)
assert subdominant_chord.isPosition(P.A4,3)
assert subdominant_chord.isPosition(P.Ab4,3)
def test_isInversion():
assert subdominant_chord.isInversion([P.A3,P.C4,P.F4],1)
assert subdominant_chord.isInversion([P.Ab3, P.C4, P.F4],1)
def test_isFullChord():
assert subdominant_chord.isFullChord([P.F4,P.Ab4,P.C4])
assert subdominant_chord.isFullChord([P.F4,P.A4,P.C4])
def test_findPosition():
assert subdominant_chord.findPosition(P.Ab4) == 3
assert subdominant_chord.findPosition(P.A4) == 3
#Deus, in adjutorium meum intende
import sys
sys.path.append('./cpv')
import note
import pitch
import pytest
import scalenote
import scale
NS = scalenote.NoteScale
P = pitch.Pitch
Mode = scale.Mode
scale0 = scale.Scale(P.C0, Mode.M)
scale1 = scale.Scale(P.A0, Mode.m)
scale2 = scale.Scale(P.A0, Mode.m_full)
def test_new():
assert isinstance(NS(scale2, P.A4), scalenote._minor__note_scale)
def test_moveBy():
ns = NS(scale0, P.D4)
assert ns.note == P.D4
ns.moveBy(1)
assert ns.note == P.E4
ns.moveBy(-2)
assert ns.note == P.C4
