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