def draw_dependencies(gammas, phis, ds, amps):
'''
Draw 2 graphics: phi(gamma), d(gamma) dependencies and amplitude(gamma) dependency
:param gammas: list of gamma values
:param phis: list of phis values
:param ds: list of d values
:param amps: list of amplitude values
'''
# draw phi, d dependencies
phid_figure_name = 'cubic_oscillating_phi0d0{}_x0={:.5},beta={:.5}'.format(
SUFFIX_NAME, x0, beta)
drawer_phid = drawer.Drawer(x_label=r'$\gamma$',
figure_name=phid_figure_name,
save_dir=SAVE_DIRECTORY)
drawer_phid.drawAxis(show_Ox=True)
drawer_phid.drawTwoCurves(gammas, phis, ds, r'$\varphi_0$', r'$d_0$',
'darkcyan', 'darkorange')
# draw amplitude dependency
amp_figure_name = 'cubic_oscillating_A{}_x0={:.5},beta={:.5}'.format(
SUFFIX_NAME, x0, beta)
drawer_amp = drawer.Drawer(x_label=r'$\gamma$',
y_label='$A_c$',
figure_name=amp_figure_name,
save_dir=SAVE_DIRECTORY)
drawer_amp.drawAxis(show_Ox=True)
drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def draw_dependencies(gammas, phis, ds, amps):
'''
Draw 2 graphics: phi(gamma), d(gamma) dependencies and amplitude(gamma)
dependency
:param gammas: list of gamma values
:param phis: list of phis values
:param ds: list of d values
:param amps: list of amplitude values
'''
# draw phi, d dependencies
phid_figure_name = 'cubic_divergent_phi0d0_x0={:.5},g[{:.5},{:.5}],beta={:.5}'.format(
x0, g_min, g_max, beta)
drawer_phid = drawer.Drawer(x_label=r'$\gamma$',
figure_name=phid_figure_name,
save_dir=SAVE_DIRECTORY)
drawer_phid.drawAxis(show_Ox=True)
drawer_phid.drawTwoCurves(gammas,
phis,
ds,
curve1_lbl=r'$\varphi_0$',
curve2_lbl=r'$d_0$',
curve1_color='darkcyan',
curve2_color='darkorange')
# draw amplitude dependency
amp_figure_name = 'cubic_divergent_Au_x0={:.5},beta={:.5}'.format(x0, beta)
drawer_amp = drawer.Drawer(x_label=r'$\gamma$',
y_label='$A_u$',
figure_name=amp_figure_name,
save_dir=SAVE_DIRECTORY)
drawer_amp.drawAxis(show_Ox=True)
drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def draw_dependencies(gammas, phis, ds, amps):
'''
Draw 3 graphics: phi(gamma) dependency, d(gamma) dependency and amplitude(gamma) dependency
:param gammas: list of gamma values
:param phis: list of phis values
:param ds: list of d values
:param amps: list of amplitude values
'''
# draw phi dependency
phi_pict = 'oscillating_phi0{}_x0={:.5}'.format(SUFFIX_NAME, x0)
drawer_phi = drawer.Drawer(x_label=r'$\gamma$',
y_label=r'$\varphi_0$',
figure_name=phi_pict,
save_dir=SAVE_DIRECTORY)
drawer_phi.drawAxis(show_Ox=True)
drawer_phi.drawCurve(gammas, phis, curve_color='darkcyan')
# draw d dependency
d_pict = 'oscillating_d0{}_x0={:.5}'.format(SUFFIX_NAME, x0)
drawer_d = drawer.Drawer(x_label=r'$\gamma$',
y_label='$d_0$',
figure_name=d_pict,
save_dir=SAVE_DIRECTORY)
drawer_d.drawAxis(show_Ox=True)
drawer_d.drawCurve(gammas, ds, curve_color='orange')
# draw amplitude dependency
amp_pict = 'oscillating_Ac{}_x0={:.5}'.format(SUFFIX_NAME, x0)
drawer_amp = drawer.Drawer(x_label=r'$\gamma$',
y_label='$A_c$',
figure_name=amp_pict,
save_dir=SAVE_DIRECTORY)
drawer_amp.drawAxis(show_Ox=True)
drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def _configure(self, qtile, screen):
if self not in [screen.top, screen.bottom]:
raise confreader.ConfigError(
"Bars must be at the top or the bottom of the screen.")
if len(filter(lambda w: w.width_type == STRETCH, self.widgets)) > 1:
raise confreader.ConfigError("Only one STRETCH widget allowed!")
Gap._configure(self, qtile, screen)
self.window = window.Internal.create(self.qtile, self.x, self.y,
self.width, self.height,
self.opacity)
self.drawer = drawer.Drawer(self.qtile, self.window.window.wid,
self.width, self.height)
self.drawer.clear(self.background)
self.window.handle_Expose = self.handle_Expose
self.window.handle_ButtonPress = self.handle_ButtonPress
self.window.handle_ButtonRelease = self.handle_ButtonRelease
qtile.windowMap[self.window.window.wid] = self.window
self.window.unhide()
for i in self.widgets:
qtile.registerWidget(i)
i._configure(qtile, self)
self._resize(self.width, self.widgets)
# FIXME: These should be targeted better.
hook.subscribe.setgroup(self.draw)
hook.subscribe.changegroup(self.draw)
def main():
set_brightness(.05)
switchColor(1)
draw = drawer.Drawer(output = True)
switchColor(2)
print('---Switch is strating')
#intializeDrawer()
flip = False
xSquare = framer(6)
try:
for xS in xSquare:
draw.square(xS[0],xS[1],xS[2],xS[3]/xS[2])
#line(50,50,length=50,angle=0)
#line(50,50,length=55,angle=.1)
#line(50,50,length=60,angle=.2)
#line(50,50,length=65,angle=.4)
#line(50,50,length=70,angle=.8)
#line(50,50,length=75,angle=1.6)
#for k in range(0,10):
#draw.square(100,70,10*k/2.0,noise = 3,speed=500)
#for j in range(0,10):
#square((k+1)*11,(j+1)*11,10,angle=math.pi*(k*j)/(400))
#draw.circle((k+1)*11,(j+1)*11,k+j)
except Exception as e:
print(traceback.format_exc())
draw.toPosition(0,0)
draw.closeDrawer()
switchColor(1)
def __init__(self):
Tk.__init__(self)
self.frame_height = [800, 800]
self.frame_width = [200, 1500]
# Frames
self.signal_frame = drawer.Drawer(tk = self,
grid_position = None,#(0, 1),
height = self.frame_height[1],
width = self.frame_width[1])
self.value_frame = ControlFrame(tk = self,
height = self.frame_height[0],
width = self.frame_width[0],
bg = '#EEFFEE')
self.value_frame.grid(row = 0, column = 0)
self.signal_frame.grid(row = 0, column = 1)
# UDP
self.udp_port = 9999
self.udp_server = UDPServer(self.udp_port)
self.n_signal_samples = 2000
self.signal_limits = [-2**11, 2**11]
self.spectrum_limits = [0, 10000]
self.signal_contraction = 1.1
self.signal_buffer = deque([0] * self.n_signal_samples, maxlen = self.n_signal_samples)
self.spectrum_buffer = deque([0] * self.n_signal_samples, maxlen = self.n_signal_samples)
self.saved_signal = []
self.n_saved = 10000
# self.saved_file = open('saved.txt', 'w')
# Setup
self.setup()
def run():
try:
search_file = sys.argv[1]
with open(search_file) as f:
result = json.loads(f.read())
agents = list()
for ag in result["agents"]:
try:
model_x = model.models[ag["x"]["type"]](*ag["x"]["params"])
model_y = model.models[ag["y"]["type"]](*ag["y"]["params"])
agents.append(agent.Agent(model_x, model_y))
except TypeError:
agents.append(path.make(list()))
for p in ag:
agents[-1].append(stpoint.make(p["x"], p["y"], p["t"]))
b_path = path.make(list())
for st_p in result["path"]:
b_path.append(stpoint.make(st_p["x"], st_p["y"], st_p["t"]))
fig = plt.figure()
ax_dr = fig.add_subplot(111, projection="3d")
dr = drawer.Drawer(fig, ax_dr)
dr.draw_path(b_path)
for ag in agents:
dr.draw_agent(ag, b_path.get_max_time())
dr.show()
except IndexError:
print_usage()
def main():
set_brightness(.05)
switchColor(1)
draw = drawer.Drawer(output=True)
switchColor(2)
print('---Switch is strating')
#intializeDrawer()
flip = False
xSquare = []
for k in range(0, 8):
checked = False
while not checked:
x0 = 30 + 200 * random.random()
y0 = 30 + 150 * random.random()
R0 = 5 + 15 * random.random()
if x0 - R0 > 10 and x0 + R0 < 250 and y0 - R0 > 10 and y0 + R0 < 170:
checked = True
xSquare.append([x0, y0, R0])
print('and the sqaures are : ')
print(xSquare)
try:
for xS in xSquare:
draw.square(xS[0], xS[1], xS[2])
for k in range(10, 300):
x = np.arange(10, 250, .2)
if flip:
x = np.flip(x)
y = 10 + k * .6 + 2 * np.sin(
(6 * math.pi * ((x - 10) / 240))**(1 + k / 300))
y2 = np.copy(y[(x >= xS[0] - xS[2]) & (x <= xS[0] + xS[2]) &
(y >= xS[1] - xS[2]) & (y <= xS[1] + xS[2])])
x2 = np.copy(x[(x >= xS[0] - xS[2]) & (x <= xS[0] + xS[2]) &
(y >= xS[1] - xS[2]) & (y <= xS[1] + xS[2])])
if len(x2) > 2:
draw.lines(x2, y2)
flip = not flip
#line(50,50,length=50,angle=0)
#line(50,50,length=55,angle=.1)
#line(50,50,length=60,angle=.2)
#line(50,50,length=65,angle=.4)
#line(50,50,length=70,angle=.8)
#line(50,50,length=75,angle=1.6)
#for k in range(0,10):
#draw.square(100,70,10*k/2.0,noise = 3,speed=500)
#for j in range(0,10):
#square((k+1)*11,(j+1)*11,10,angle=math.pi*(k*j)/(400))
#draw.circle((k+1)*11,(j+1)*11,k+j)
except Exception as e:
print(traceback.format_exc())
draw.toPosition(0, 0)
draw.closeDrawer()
switchColor(1)
def draw_dependencies(gammas, ds, amps):
'''
Draw 2 graphics: d(gamma) dependency and amplitude(gamma) dependency
:param gammas: list of gamma values
:param ds: list of d values
:param amps: list of amplitude values
'''
# draw d dependency
d_figure_name = 'integral_divergent_d0_g[{:.5},{:.5}]'.format(g_min, g_max)
drawer_d = drawer.Drawer(x_label=r'$\gamma$',
y_label='d',
figure_name=d_figure_name,
save_dir=SAVE_DIRECTORY)
drawer_d.drawAxis(show_Ox=True)
drawer_d.drawCurve(gammas, ds, curve_color='darkorange')
# draw amplitude dependency
amp_figure_name = 'integral_Au_g[{:.5},{:.5}]'.format(g_min, g_max)
drawer_amp = drawer.Drawer(x_label=r'$\gamma$',
y_label='$A_u$',
figure_name=amp_figure_name,
save_dir=SAVE_DIRECTORY)
drawer_amp.drawAxis(show_Ox=True)
drawer_amp.drawCurve(gammas, amps, curve_color='crimson')
def main():
args = sys.argv
if len(args) != 3:
print("Usage: ./main.py <file_to_draw> <luminance_thresh (0-255)>")
return
file = sys.argv[1]
luminanceThresh = int(sys.argv[2])
strokeDuration = 1
pointMethod = directionTravel.PointTravel(luminanceThresh)
points = pointMethod.getPoints(file)
artist = drawer.Drawer(1)
artist.drawPoints(points)
def main():
ros = rosenbrock.Rosenbrock()
sph = sphere.Sphere()
qua = quartic.Quartic()
ras = rastrigin.Rastrigin()
aux = np.array([])
graph = np.array([])
ejecuciones = 1
draw = drawer.Drawer()
individuos = 32
dimensiones = 16
intervalos = 8
a = 1
Q = 20
evaporacion = 0.9
t0 = 0.00001
generaciones = 100
bestFitnessPos = 100
graphName = "Quartic" + str(dimensiones) + "D"
aco = ACO.ACO(individuos, dimensiones, intervalos, a, Q, evaporacion, t0,
ras, generaciones, bestFitnessPos)
for i in range(ejecuciones):
aux = aco.run()
if i == 0:
graph = aux
else: #Sumamos el resto de las ejecuciones.
for a in range(len(aux)):
graph[a] = graph[a] + aux[a]
for x in range(len(graph)):
graph[x] = graph[
x] / ejecuciones #Obtenemos el promedio de cada posicion
draw.drawIndividual(graph, graphName)
file = open(graphName + ".txt", "w")
for y in range(len(graph)):
file.write(str(graph[y]) + "\n")
file.close()
def __init__(self, height=400, width=1000):
Tk.__init__(self)
self.title("SoundEEG")
self.height = height
self.width = width
self.width_ratio = 7
self.signal_frame = drawer.Drawer(
tk=self,
grid_position=None,
height=self.height,
width=self.width * self.width_ratio // (self.width_ratio + 1))
self.signal_frame.grid(row=0, column=0)
self.control_frame = SoundEEG_Control(tk=self)
self.control_frame.grid(row=0, column=1)
self.control_fields = dict(self.DEFAULT_CTL_FIELDS)
self.control_fields['connect']['command'] = self.connect
self.control_fields['choose_wav']['command'] = self.choose_wav
self.control_fields['play+EEG']['command'] = self.playEEG
# Objects
self.wav_player = wavplayer.WavPlayer()
self.bci_comm = neurorec.GanglionControl()
def main():
# ras = rastrigin.rastrigin()
# qua = quartic.quartic()
# sph = sphere.sphere()
# ros = rosenbrock.rosenbrock()
#
# aux = np.array([])
# graph = np.array([])
# ejecuciones = 5
draw = drawer.Drawer()
#
# dimensions = 16
# num_particles = 50
# max_iterations = 2000 #Generaciones
# weight = 0.729 #Inercia de la velocidad.
# cognitive_learning = 1.49445 #Proporcion de aprendizaje cognitivo.
# social_learning = 1.49445 #Proporcion de aprendizaje social.
#
# graphName = "Quartic" + str(dimensions) + "D"
#
# for i in range(ejecuciones):
# aux = PSO.PSOrun(max_iterations, num_particles, dimensions, qua, weight,
# cognitive_learning, social_learning)
# if i == 0:
# graph = aux
# else: #Sumamos el resto de las ejecuciones.
# for a in range(len(aux)):
# graph[a] = graph[a] + aux[a]
#
# for x in range(len(graph)):
# graph[x] = graph[x]/ejecuciones #Obtenemos el promedio de cada posicion
#
# draw.drawIndividual(graph, graphName)
#
# file = open(graphName + ".txt", "w")
# for y in range(len(graph)):
# file.write(str(graph[y]) + "\n")
# file.close()
draw.drawGroup("Quartic")
def __init__(self, username, proxy_uri, spectator_mode=False):
self.username = username
try:
self.proxy = Pyro4.Proxy(proxy_uri)
except:
raise Exception("Invalid URI")
if not spectator_mode:
register_response: dict = self.proxy.push_command("START " +
username)
if register_response['status'] != "OK":
raise Exception(register_response['message'])
self.board_id = register_response['board_id']
self.player_id = register_response['player_id']
else:
self.board_id = "X"
self.player_id = "X"
latest_board: dict = self.proxy.push_command("UPDATE")
self.board = board.Board(latest_board['data'])
self.drawer = drawer.Drawer(self.board, self.username,
str(self.board_id), self.player_id,
self.proxy, spectator_mode)
def main():
sph = sphere.sphere()
ros = rosenbrock.rosenbrock()
qua = quartic.quartic()
ras = rastrigin.rastrigin()
draw = drawer.Drawer()
aux = np.array([])
graph = np.array([])
executions = 5
stepSize_parameter = 0.5 #[0.4, 0.9] (F in DE)
crossover_rate = 0.7 #[0.1, 1.0] (c in DE)
individuals = 30
generations = 2000
dimensions = 2
graphName = "Sphere" + str(dimensions) + "D"
for i in range(executions):
aux = DE.differentialEvolution(sph, dimensions, individuals, stepSize_parameter,
crossover_rate, generations)
if i == 0: #For the first vector, we just make a copy to the one we'll be adding to.
graph = aux
else: #For the rest, we just add.
for a in range(len(aux)):
graph[a] = graph[a] + aux[a]
for x in range(len(graph)):
graph[x] = graph[x]/executions #We obtain the average for each vector position.
draw.drawIndividual(graph, graphName)
file = open(graphName + ".txt", "w")
for y in range(len(graph)):
file.write(str(graph[y]) + "\n")
file.close()
f_a = second_border_func_val(u=a, v=0.0)
func_values.append(f_a)
print('Roots:\na = 0.0')
a_roots = [0.0]
for idx in range(1, len(a_values) - 1):
a_left, f_left = a_values[idx], func_values[idx]
a_right, f_right = a_values[idx + 1], func_values[idx + 1]
if (f_left * f_right <= 0.0):
a_star = flexible_bisection_root_search(a_left, f_left, a_right,
f_right)
print(f'a = {a_star}')
a_roots.append(a_star)
# draw function F(a)
fa_pict = 'Fa_gamma={:.4}_alpha={:.5}'.format(gamma, alpha)
dr = drawer.Drawer(x_label='a',
y_label='F',
figure_name=fa_pict,
save_dir=SAVE_DIRECTORY)
dr.drawAxis(show_Ox=True, show_Oy=True)
#dr.drawPoints(a_roots, [0.0] * len(a_roots))
dr.drawCurve(a_values,
func_values,
curve_color='chocolate',
up=None,
bottom=None)
# draw function u(x) for each a_*
if DRAW_U_FUNCS:
if len(a_roots) > 1:
for a_star in a_roots[1:]:
xs, us = build_original_u_func(a_star)
#print (us)
u_pict = 'u(x)_gamma={:.4}_alpha={:.5}_a={:.4}'.format(
import drawer
import implementation
import interact_interface
import threading
import time
# driver code
if __name__ == "__main__":
interact_interface.Interact()
obj = drawer.Drawer()
ob = obj.please_draw()
i = implementation.Implementation(obj)
mark_lists = i.Start(obj)
obj.draw_marks(mark_lists, ob)
else:
return dichotonomy_root_search(y, right_border, func, **kwargs)
elif (f < -EPS):
if f_left < 0 and f_right > 0:
return dichotonomy_root_search(y, right_border, func, **kwargs)
else:
return dichotonomy_root_search(left_border, y, func, **kwargs)
else:
return y
# variables only for inner usage
_x0 = 0.45
_g_min = 6.8
_g_max = 6.9
_points = 11
# only for inner usage
if __name__ == '__main__':
_gammas = np.linspace(_g_min, _g_max, _points)
_alphas_u = [get_alpha_u(g, _x0) for g in _gammas]
print('\tgamma\talpha')
for idx in range(len(_gammas)):
print('{:>9.6} {:>9.6}'.format(_gammas[idx], _alphas_u[idx]))
_g_loc = get_gamma_local_min(_gammas, _alphas_u)
_a_loc = get_alpha_min(_alphas_u)
if _g_loc != _gammas[-1]:
print('\na_loc_min = {:.12}'.format(_a_loc))
print('g_loc = {:.12}'.format(_g_loc))
drawer_alphau = drawer.Drawer(x_label=r'$\gamma$', y_label=r'$\alpha_u$')
drawer_alphau.drawCurve(_gammas, _alphas_u, curve_color='b')
def __init__(self,
square_size=64,
max_x=15,
max_y=7,
moana_image="images/babymoana.jpg",
moana_boat_image="images/moana_boat.jpg",
maui_image="images/maui_bird_by_biz.jpg",
sharkhead_image="images/maui.jpg",
crab_image="images/crab_by_biz.jpg",
dad_image="images/moana_dad.jpg",
lava_image="images/lava_monster_by_biz.jpg",
island_image="images/tifiti_by_biz.jpg",
hook_image="images/fishhook.jpg",
boat_image="images/boat.jpg",
heart_image="images/heart_by_biz.jpg",
shell_bin_image="images/shell_bin_by_biz.jpg",
shells_image="images/shell.png",
mud_image="images/lava_by_biz.jpg"):
"""Set up the game.
Add one Moana character, a bunch of shells and a bunch of obstacles. Beware:
this does nothing intelligent about making sure all shells are reachable or
checking that the character doesn't get trapped in a corner surrounded by
obstacles. No pathfinding algorithms were invoked in the writing of this
game.
Args:
square_size: (int) the size of each grid square. The images on the grid
should be square and should be this size or it'll look like a mess.
max_x, max_y: (int) how many squares on each side of the grid.
"""
pygame.init()
pygame.mixer.music.load("sounds/shells.wav")
pygame.mixer.music.play()
self.game_over = False
self.clock = pygame.time.Clock()
self.image_lib = {}
self.done = False
self.drawer = drawer.Drawer(square_size, max_x, max_y)
self.crab = things.SelfMovingThing(self.get_image(crab_image),
self.drawer,
x=int(max_x / 2))
self.dad = things.SelfMovingThing(self.get_image(dad_image),
self.drawer,
y=int(max_y / 2))
self.mud = things.StationaryThings(self.get_image(mud_image),
self.drawer,
obstacle=True)
self.mud.place_randomly(15)
self.shells = things.StationaryThings(self.get_image(shells_image),
self.drawer)
self.shells.place_randomly(50)
self.hook = things.StationaryThings(self.get_image(hook_image),
self.drawer)
self.hook.place_randomly(1)
self.boat = things.StationaryThings(self.get_image(boat_image),
self.drawer)
self.boat.place_randomly(1)
self.heart = things.StationaryThings(self.get_image(heart_image),
self.drawer)
self.shell_bin = things.StationaryThings(
self.get_image(shell_bin_image), self.drawer)
self.shell_bin.place_randomly(1)
self.moana = things.MovingThing(self.get_image(moana_image),
self.drawer,
x=0)
self.moana.add_replacement_image(self.get_image(moana_boat_image))
self.maui = things.MovingThing(self.get_image(sharkhead_image),
self.drawer,
x=max_x - 1)
self.maui.add_replacement_image(self.get_image(maui_image))
self.island = things.MovingThing(self.get_image(lava_image),
self.drawer,
x=0,
y=0)
self.island.add_replacement_image(self.get_image(island_image))
self.drawer.set_background((255, 64, 0)) # orange
self.update_score_text("Get the hook!")
self.has_hook = False
self.has_boat = False
'''
Script for building and visualization alpha_u dependency (critical values of alpha,
when zero solution of LINEARIZED BOUNDARY-VALUE PROBLEM with INTEGRAL DEVIATION
in boundary conditions loses its stability in DIVERGENT way)
'''
import numpy as np
import drawer
g_min = -4.1
g_max = 4.1
n_gammas = 8201
SAVE_DIRECTORY = '../Tracer/Variations/Integral Boundary Condition'
if __name__ == '__main__':
gammas = list(np.linspace(g_min, g_max, n_gammas))
alphas_u = list(map(lambda x: -x, gammas))
drawer_alphau = drawer.Drawer(x_label=r'$\gamma$',
y_label=r'$\alpha_u$',
save_dir=SAVE_DIRECTORY)
drawer_alphau.drawAxis(show_Ox=True, show_Oy=True)
drawer_alphau.drawCurve(gammas, alphas_u, curve_color='b')
import numpy as np
import drawer
x0 = 0.0
gamma = 5.1
def get_v_func_val(g, x):
'''
Calculate and return value of v(x) for fixed gamma
:param g: fixed gamma value
:param x: x value
:return: v(x) for fixed gamma
'''
if g <= 0:
mu = np.sqrt(-g)
return np.cosh(mu*x)
else:
mu = np.sqrt(g)
return np.cos(mu*x)
if __name__ == '__main__':
xs = np.linspace(0, 1, 10000)
vs = [get_v_func_val(gamma, x) for x in xs]
# draw v function
v_figure_name = 'x0={:.2}__g={:.4}'.format(x0, gamma)
drawer_v = drawer.Drawer(x_label='x', y_label='v', figure_name=v_figure_name)
drawer_v.drawCurve(xs, vs, curve_color='slateblue')
def main():
set_brightness(.05)
switchColor(1)
try:
frames = kinecter.getFrames(30)
dX, dY, angle, angleZ = kinecter.derivateFrames(frames)
noProblem = True
except Exception as e:
print(traceback.format_exc())
noProblem = False
draw = drawer.Drawer(output=True)
switchColor(2)
print('---Switch is strating')
#intializeDrawer()
flip = False
speed = 5
z = frames[6]
A = angle[6]
nLines = 100
try:
for k in range(0, nLines):
xLines = []
yLines = []
kx = random.randint(0, 640)
ky = random.randint(0, 480)
x, y = scaler(kx, ky)
zTest = z[kx, ky]
while (not np.isnan(zTest)):
xLines.append(x)
yLines.append(y)
dx = x + speed * np.cos(A[kx, ky])
dy = y + speed * np.cos(A[kx, ky])
dkx, dky = scaler(x, y, invert=True)
if (dxk > -1) and (dxk < 640) and (dyk > -1) and (
dyk < 480) and size < 100 * np.sin(A[kx, ky]):
x = dx
y = dy
kx = dkx
ky = dky
zTest = z[kx, ky]
else:
zTest = np.isnan
draw.lines(xLines, yLines)
#line(50,50,length=50,angle=0)
#line(50,50,length=55,angle=.1)
#line(50,50,length=60,angle=.2)
#line(50,50,length=65,angle=.4)
#line(50,50,length=70,angle=.8)
#line(50,50,length=75,angle=1.6)
#for k in range(0,10):
#draw.square(100,70,10*k/2.0,noise = 3,speed=500)
#for j in range(0,10):
#square((k+1)*11,(j+1)*11,10,angle=math.pi*(k*j)/(400))
#draw.circle((k+1)*11,(j+1)*11,k+j)
except Exception as e:
print(traceback.format_exc())
draw.toPosition(0, 0)
draw.closeDrawer()
switchColor(1)
SUFFIX_NAME = '_after_tangent' if AFTER_TANGENT else ''
DATA_PATH = '../Tracer/Results' + f'/x0={x0:.2f}'
CSV_FILE = DATA_PATH + f'/x0={x0:.2f}' + '_analytical.csv'
AFTER_TANGENT_FILE = DATA_PATH + f'/x0={x0:.2f}' + '_analytical_after_tangent.csv'
SAVE_DIRECTORY = '../Tracer/Results/Omegas'
PICT_NAME = SAVE_DIRECTORY + f'/omegas_x0={x0:.2f}' + SUFFIX_NAME + '.png'
def read_params():
'''
Read params for visualization
:return list of gamma values, list of omega values
'''
gs, ws = [], []
if AFTER_TANGENT:
if os.path.exists(AFTER_TANGENT_FILE):
df = pd.read_csv(AFTER_TANGENT_FILE, sep=';')
gs, ws = list(df['gamma']), list(df['w'])
else:
df = pd.read_csv(CSV_FILE, sep=';')
gs, ws = list(df['gamma']), list(df['w'])
return gs, ws
if __name__ == '__main__':
gs, ws = read_params()
# draw omega dependency
drawer_w = drawer.Drawer(x_label=r'$\gamma$',
y_label=r'$\omega$',
save_dir=SAVE_DIRECTORY)
drawer_w.drawCurve(gs, ws, curve_color='g', save_name=PICT_NAME)
df = pd.DataFrame(func_values).sort_values(by=[COLUMNS[0]])
a_s, f_s = tuple(map(lambda x: df[x].tolist(), COLUMNS))
print('Searching for roots...\na = 0')
a_roots = [0.0]
for idx in range(1, len(a_s) - 1):
a_left, f_left = a_s[idx], f_s[idx]
a_right, f_right = a_s[idx + 1], f_s[idx + 1]
if (f_left * f_right <= 0.0):
a_star = flexible_bisection_root_search(a_left, f_left, a_right,
f_right, numerical_method)
print(f'a = {a_star:g}')
a_roots.append(a_star)
# draw function F(a)
fa_pict = 'Fa_gamma={:.4}_alpha={:.5}'.format(gamma, alpha)
dr = drawer.Drawer(x_label=COLUMNS[0],
y_label=COLUMNS[1],
figure_name=fa_pict,
save_dir=SAVE_DIRECTORY)
dr.drawAxis(show_Ox=True, show_Oy=True)
#dr.drawPoints(a_roots, [0.0] * len(a_roots))
dr.drawCurve(a_s, f_s, curve_color='chocolate', up=None, bottom=None)
# draw function u(x) for each a_*
if DRAW_U_FUNCS:
if len(a_roots) > 1:
for a_star in a_roots[1:]:
xs, us = build_original_u_func(a_star)
#print (us)
u_pict = 'u(x)_gamma={:.4}_alpha={:.5}_a={:.4}'.format(
gamma, alpha, a_star)
dr = drawer.Drawer(x_label='x',
y_label='u',
figure_name=u_pict,
def __init__(self):
if hasattr(sys, 'frozen'):
self.local_path = os.path.realpath(os.path.dirname(sys.executable))
sys.path.append(self.local_path)
else:
self.local_path = os.path.realpath(os.path.dirname(__file__))
#self.__init_config()
self.wtree_path = os.path.join(self.local_path, 'editor.ui')
self.builder = Gtk.Builder()
self.builder.add_from_file(self.wtree_path)
self.builder.connect_signals(self)
self.main_window = self.builder.get_object('main_window')
self.main_window.connect('delete-event',
self.on_main_window_delete_event)
self.main_window.connect('destroy', Gtk.main_quit)
self.treeview = self.builder.get_object('treeview')
self.treeview.connect('row-activated', self.on_treeview_row_activated)
self.main_window.show_all()
self.main_box = self.builder.get_object('hbox1')
self.main_box.hide()
self.project_dialog = dialogs.ProjectDialog(self.builder,
self.main_window)
self.search_dialog = dialogs.SearchDialog(self.builder,
self.main_window)
self.file_list = self.builder.get_object('file_list')
self.__load_config()
self.main_box.show_all()
self.teste = self.builder.get_object('viewport3')
self.teste2 = self.builder.get_object('textview1')
self.teste2.modify_font(Pango.FontDescription(fontDescription))
self.teste3 = self.builder.get_object('textview2')
self.teste3.modify_font(Pango.FontDescription(fontDescription))
self.buf = self.teste3.get_buffer()
self.panel_separator = self.builder.get_object("hpaned1")
self.drawing_area = drawer.Drawer(
self.config_files,
bg=os.path.join(self.config_path,
self.main_config['BackgroundFolder']),
font=os.path.join(self.config_path,
self.main_config['FontFolder']))
self.drawing_area.mask_event(Gdk.EventMask.BUTTON_PRESS_MASK)
self.writing_area = writer.Writer()
self.teste2.set_buffer(self.writing_area)
self.writing_area.connect('changed', self.on_writing_area_changed)
self.writing_area.connect('mark-set', self.on_writing_area_mark_set)
self.s_id_1 = self.writing_area.connect(
'modified-changed', self.on_writing_area_modified_changed)
self.drawing_area.connect('draw', self.on_drawing_area_expose_event)
self.drawing_area.show()
self.teste.add(self.drawing_area)
self.file_list_iter = []
self.__init_file_list()
def get_dict_roots(ws, ys):
'''
Form and return dictionary of roots, where sign function changes its sign
(dict_key - omega value, dict_value - alpha_c (oscillating case) value)
:param ws:
:param ys:
:return:
'''
res = {}
for idx in range(1, len(ws)):
if ys[idx - 1] * ys[idx] < 0:
w_star = (ws[idx - 1] + ws[idx]) / 2.0
res[str(w_star)] = utils.get_alpha_c(gamma, w_star, x0)
return res
if __name__ == '__main__':
print(f'gamma = {gamma}\n')
ws = np.linspace(w_start, w_end, n_points)
ys = [get_sign_func_val(w) for w in ws]
# find roots
star = get_dict_roots(ws, ys)
print('gamma;w_star;alpha_c')
for w, a in star.items():
print('{:.9};{:.9};{:.9}'.format(gamma, float(w), a))
# draw function
dr = drawer.Drawer(x_label=r'$\omega$')
dr.drawAxis(show_Ox=True)
dr.drawCurve(ws, ys, curve_color='k')
datapath = os.path.join('..', 'data')
confpath = os.path.join('..', 'conf')
random.seed()
subjectid = ""
sessionid = ""
while subjectid == "" or subjectid == None:
subjectid = raw_input("Subject ID: ")
print subjectid
sessionid = 0
random.seed(subjectid + str(time.time()))
drawer = drawer.Drawer()
scorer = scorer.Scorer()
acceptedkeys = ['s', 'd', 'f', 'j', 'k', 'l']
sessionid = 0
exptname = "skill3"
gensettings = readConfig(os.path.join(confpath, 'configuration.txt'))
colort = readConfig(os.path.join(confpath, 'colors.txt'))
colors = []
for k, v in colort.iteritems():
colors.append(map(int, v))
print colors
letters = [
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
return False
def validate_args(args):
if args.scale < 1:
print("The scale may not be smaller than 1")
exit(-1)
if not os.path.isfile(args.file):
print("The file \"{}\" does not exist or is not a file", args.file)
exit(-1)
if __name__ == '__main__':
args = parser.parse_args()
validate_args(args)
nonogram = nonogram.Nonogram(args)
drawer = drawer.Drawer(nonogram, args)
nonogram.apply_first_step()
drawer.draw_numbers()
drawer.draw_field(True)
if not args.first_step:
solve(0, drawer)
drawer.draw_field(True)
drawer.cleanup()
