class Application(object):
def __init__(self):
self.logger = get_logger('dashboard')
self.server = SocketServer.UDPServer(
(settings.DASHBOARD_HOST, settings.DASHBOARD_PORT),
self.handle_request)
self.server.timeout = settings.DASHBOARD_REQUEST_TIMEOUT
self.raw_telem_time = 0
self.raw_telem_bat = 0
self.raw_telem_temp = 0
self.raw_telem_photo = 0
self.__init_main()
self.__init_motor()
self.__init_light()
self.__init_video()
self.__init_telem()
def __init_main(self):
self.window = Tk()
self.window.wm_minsize(400, 400)
def __init_motor(self):
self.w_lf_motor = LabelFrame(self.window, text=u'Моторы')
self.w_scale_motor1 = Scale(self.w_lf_motor, from_=-255, to=255)
self.w_scale_motor2 = Scale(self.w_lf_motor, from_=-255, to=255)
self.w_lf_motor.place(relx=0, rely=0, relwidth=1, relheight=0.3)
self.w_scale_motor1.place(relx=0, rely=0, relwidth=1, relheight=1)
self.w_scale_motor2.place(relx=0.5, rely=0, relwidth=1, relheight=1)
def __init_light(self):
self.w_lf_light = LabelFrame(self.window, text=u'Свет')
self.w_l_light = Label(self.w_lf_light,
text=u'Выключен',
fg='red',
font='Arial 20')
self.w_lf_light.place(relx=0, rely=0.3, relwidth=1, relheight=0.15)
self.w_l_light.place(relx=0, rely=0, relwidth=1, relheight=1)
def __init_video(self):
self.w_lf_video = LabelFrame(self.window, text=u'Видео')
self.w_l_video = Label(self.w_lf_video,
text=u'Выключен',
fg='red',
font='Arial 20')
self.w_b_show = Button(self.w_lf_video,
text=u'mplayer',
command=self.start_mplayer)
self.w_lf_video.place(relx=0, rely=0.45, relwidth=1, relheight=0.15)
self.w_l_video.place(relx=0, rely=0, relwidth=0.7, relheight=1)
self.w_b_show.place(relx=0.7, rely=0, relwidth=0.3, relheight=1)
def __init_telem(self):
# телеметрия
self.w_lf_telem = LabelFrame(self.window, text=u'Телеметрия')
self.w_l_telem_time = Label(self.w_lf_telem,
text=u'0',
font='Arial 15')
self.w_l_telem_bat = Label(self.w_lf_telem, text=u'0', font='Arial 15')
self.w_l_telem_temp = Label(self.w_lf_telem,
text=u'0',
font='Arial 15')
self.w_l_telem_photo = Label(self.w_lf_telem,
text=u'0',
font='Arial 15')
self.w_lf_telem.place(relx=0, rely=0.6, relwidth=1, relheight=0.4)
Label(self.w_lf_telem, text=u'Время:',
font='Arial 15').place(relx=0,
rely=0,
relwidth=0.5,
relheight=0.25)
Label(self.w_lf_telem, text=u'Батарея:',
font='Arial 15').place(relx=0,
rely=0.25,
relwidth=0.5,
relheight=0.25)
Label(self.w_lf_telem, text=u'Температура:',
font='Arial 15').place(relx=0,
rely=0.5,
relwidth=0.5,
relheight=0.25)
Label(self.w_lf_telem, text=u'Освещенность:',
font='Arial 15').place(relx=0,
rely=0.75,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_time.place(relx=0.5,
rely=0,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_bat.place(relx=0.5,
rely=0.25,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_temp.place(relx=0.5,
rely=0.5,
relwidth=0.5,
relheight=0.25)
self.w_l_telem_photo.place(relx=0.5,
rely=0.75,
relwidth=0.5,
relheight=0.25)
def set_motor_value(self, left_value, right_value):
if left_value > 255:
left_value = 255
elif left_value < -255:
left_value = -255
self.w_scale_motor1.set(left_value)
if right_value > 255:
right_value = 255
elif right_value < -255:
right_value = -255
self.w_scale_motor2.set(right_value)
def set_light(self, value):
"""
устанавливает значение для фонарика
:param value:
"""
if value == 1:
self.w_l_light['text'] = u'Включен'
self.w_l_light['fg'] = 'green'
else:
self.w_l_light['text'] = u'Выключен'
self.w_l_light['fg'] = 'red'
def set_video(self, value):
"""
устанавливает значение для фонарика
:param value:
"""
if value == 1:
self.w_l_video['text'] = u'Включен'
self.w_l_video['fg'] = 'green'
else:
self.w_l_video['text'] = u'Выключен'
self.w_l_video['fg'] = 'red'
def set_time(self, value):
"""
устанавливает значение для даты
:param value:
"""
if self.raw_telem_time == value:
return
self.raw_telem_time = value
try:
value = datetime.fromtimestamp(value).strftime('%Y.%m.%d %H:%M:%S')
except Exception as err:
print(err)
self.logger.debug(str(err))
self.w_l_telem_time['text'] = value
def set_bat(self, value):
"""
устанавливает значение для батареи
:param value:
"""
if self.raw_telem_bat == value:
return
self.raw_telem_bat = value
self.w_l_telem_bat['text'] = value
def set_temp(self, value):
"""
устанавливает значение для температуры
:param value:
"""
if self.raw_telem_temp == value:
return
self.raw_telem_temp = value
self.w_l_telem_temp['text'] = '{0} ({1})'.format(
round((value * 3.3 / 1024 - 0.5) / 0.01, 3), value)
def set_photo(self, value):
"""
устанавливает значение для температуры
:param value:
"""
if self.raw_telem_photo == value:
return
self.raw_telem_photo = value
self.w_l_telem_photo['text'] = value
def start_mplayer(self):
"""
включает mplayer
"""
process = subprocess.Popen(settings.VIDEO_SHOW_CMD, shell=True)
def handle_request(self, request, client_address, server):
"""
обработка входных данных
:param request:
:param client_address:
:param server:
:return:
"""
_request, _socket = request
if ',' not in _request:
return
values = [int(i) for i in _request.split(',')]
self.set_motor_value(*values[:2])
self.set_light(values[2])
self.set_video(values[3])
self.set_time(values[4])
self.set_temp(values[5])
self.set_bat(values[6])
self.set_photo(values[7])
def wait_request(self):
""""""
self.server.handle_request()
self.register_mainloop()
def register_mainloop(self):
"""
регистриуем обработчик, который периодический будет обрабатывать события
"""
self.window.after(after_timeout, self.wait_request)
def run(self):
""""""
try:
self.register_mainloop()
self.window.mainloop()
except KeyboardInterrupt:
pass
except Exception as err:
self.logger.debug(err)
import traceback
self.logger.debug(traceback.format_exc())
raise
class Window(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, background="white")
self.parent = parent
self.parent.title("Proyecto PyGame")
self.pack(fill=BOTH, expand=1)
self.centerWindow()
self.value_str = ''
self.audio = pyaudio.PyAudio()
self.bandsArray = []
self.filename1 = ''
self.filename2 = ''
self.filename3 = ''
self.filename4 = ''
self.waveArray = []
self.datos_archivo1 = []
self.datos_archivo2 = []
self.datos_archivo3 = []
self.datos_archivo4 = []
# creating a menu instance
menu = Menu(self.parent)
self.master.config(menu=menu)
# create the file object)
file = Menu(menu)
# added "file" to our menu
menu.add_cascade(label="File", menu=file)
file.add_command(label="Exit", command=self.QuitAction)
self.slider_track1 = Scale(self, from_=0, to=-100)
self.slider_track1.place(x=10, y=80)
button_opentrack1 = Button(self,
text="Open",
command=self.askopenfilename1)
button_opentrack1.place(x=25, y=50)
self.slider_track2 = Scale(self, from_=0, to=-100)
self.slider_track2.place(x=90, y=80)
button_opentrack2 = Button(self,
text="Open",
command=self.askopenfilename2)
button_opentrack2.place(x=105, y=50)
self.slider_track3 = Scale(self, from_=0, to=-100)
self.slider_track3.place(x=170, y=80)
button_opentrack3 = Button(self,
text="Open",
command=self.askopenfilename3)
button_opentrack3.place(x=185, y=50)
self.slider_track4 = Scale(self, from_=0, to=-100)
self.slider_track4.place(x=260, y=80)
button_opentrack4 = Button(self,
text="Open",
command=self.askopenfilename4)
button_opentrack4.place(x=275, y=50)
button_save = Button(self,
text="Export",
command=self.press_button_export)
button_save.place(x=240, y=0)
quitButton = Button(self, text="Quit", command=self.QuitAction)
quitButton.place(x=325, y=0)
# define options for opening or saving a file
self.file_opt = options = {}
options['defaultextension'] = '.wav'
options['filetypes'] = [('all files', '.*'), ('wav files', '.wav')]
options['initialdir'] = 'C:\\'
# define options for opening or saving a file
self.file_opt1 = options = {}
options['defaultextension'] = '.wav'
options['filetypes'] = [('all files', '.*'), ('wav files', '.wav')]
options['initialdir'] = 'C:\\'
#To open and analize images
def showImg(self):
load = Image.open(self.filename)
#to center the window
def centerWindow(self):
w = 410
h = 200
sw = self.parent.winfo_screenwidth()
sh = self.parent.winfo_screenheight()
x = (sw - w) / 2
y = (sh - h) / 2
self.parent.geometry('%dx%d+%d+%d' % (w, h, x, y))
#To Quit the app and Turn off sound in puredata
def QuitAction(self):
self.parent.quit()
#To open an image and process it
def askopenfilename1(self):
# getting the filename
filename = tkFileDialog.askopenfilename(**self.file_opt)
self.filename1 = filename
self.datosarchivo1 = self.abrirarchivo1()
def abrirarchivo1(self):
archivo1 = wave.open(self.filename1, 'r')
nivel1 = self.slider_track1.get()
amplitud1 = 32678.0 * (10**(float(nivel1) / 20))
cuadros1 = archivo1.getnframes()
canales1 = archivo1.getnchannels()
muestreo1 = archivo1.getframerate()
datos1 = archivo1.readframes(cuadros1)
#completar codigo
wavearray1 = []
for i in range(0, len(datos1), 2):
datoNum1 = datos1[i] + datos1[i + 1]
dato1 = struct.unpack('<h', datoNum1)
wavearray1.append((dato1[0] / 32678.0) * amplitud1)
return wavearray1
def askopenfilename2(self):
# getting the filename
filename = tkFileDialog.askopenfilename(**self.file_opt)
self.filename2 = filename
self.datosarchivo2 = self.abrirarchivo2()
def abrirarchivo2(self):
archivo2 = wave.open(self.filename2, 'r')
nivel2 = self.slider_track2.get()
amplitud2 = 32678.0 * (10**(float(nivel2) / 20))
cuadros2 = archivo2.getnframes()
canales2 = archivo2.getnchannels()
muestreo2 = archivo2.getframerate()
datos2 = archivo2.readframes(cuadros2)
# completar codigo
wavearray2 = []
for i in range(0, len(datos2), 2):
datoNum2 = datos2[i] + datos2[i + 1]
dato2 = struct.unpack('<h', datoNum2)
wavearray2.append((dato2[0] / 32678.0) * amplitud2)
return wavearray2
def askopenfilename3(self):
# getting the filename
filename = tkFileDialog.askopenfilename(**self.file_opt)
self.filename3 = filename
self.datosarchivo3 = self.abrirarchivo3()
def abrirarchivo3(self):
archivo3 = wave.open(self.filename3, 'r')
nivel3 = self.slider_track3.get()
amplitud3 = 32678.0 * (10**(float(nivel3) / 20))
cuadros3 = archivo3.getnframes()
canales3 = archivo3.getnchannels()
muestreo3 = archivo3.getframerate()
datos3 = archivo3.readframes(cuadros3)
# completar codigo
wavearray3 = []
for i in range(0, len(datos3), 2):
datoNum3 = datos3[i] + datos3[i + 1]
dato3 = struct.unpack('<h', datoNum3)
wavearray3.append((dato3[0] / 32678.0) * amplitud3)
return wavearray3
def askopenfilename4(self):
# getting the filename
filename = tkFileDialog.askopenfilename(**self.file_opt)
self.filename4 = filename
self.datosarchivo4 = self.abrirarchivo4()
def abrirarchivo4(self):
archivo4 = wave.open(self.filename4, 'r')
nivel4 = self.slider_track3.get()
amplitud4 = 32678.0 * (10**(float(nivel4) / 20))
cuadros4 = archivo4.getnframes()
canales4 = archivo4.getnchannels()
muestreo4 = archivo4.getframerate()
datos4 = archivo4.readframes(cuadros4)
# completar codigo
wavearray4 = []
for i in range(0, len(datos4), 2):
datoNum4 = datos4[i] + datos4[i + 1]
dato4 = struct.unpack('<h', datoNum4)
wavearray4.append((dato4[0] / 32678.0) * amplitud4)
return wavearray4
def press_button_export(self):
nivel1 = self.slider_track1.get()
nivel2 = self.slider_track2.get()
nivel3 = self.slider_track3.get()
nivel4 = self.slider_track4.get()
sum1 = []
if len(self.datosarchivo1) > len(self.datosarchivo2):
for i in range(len(self.datosarchivo2), len(self.datosarchivo1)):
self.datosarchivo2.append(0)
for i in range(len(self.datosarchivo1)):
x = self.datosarchivo1[i] + self.datosarchivo2[i]
sum1.append(x)
if len(self.datosarchivo2) > len(self.datosarchivo1):
for i in range(len(self.datosarchivo1), len(self.datosarchivo2)):
self.datosarchivo1.append(0)
for i in range(len(self.datosarchivo2)):
x = self.datosarchivo2[i] + self.datosarchivo1[i]
sum1.append(x)
sum2 = []
if len(self.datosarchivo3) > len(self.datosarchivo4):
for i in range(len(self.datosarchivo4), len(self.datosarchivo3)):
self.datosarchivo4.append(0)
for i in range(len(self.datosarchivo3)):
x = self.datosarchivo3[i] + self.datosarchivo4[i]
sum2.append(x)
if len(self.datosarchivo4) > len(self.datosarchivo3):
for i in range(len(self.datosarchivo3), len(self.datosarchivo4)):
self.datosarchivo3.append(0)
for i in range(len(self.datosarchivo4)):
x = self.datosarchivo4[i] + self.datosarchivo3[i]
sum2.append(x)
print nivel1, nivel2, nivel3, nivel4
val = max(abs(i) for i in (sum1))
#Completar Codigo
filename = tkFileDialog.asksaveasfilename(**self.file_opt1)
file = wave.open(filename, 'w')
file.setparams((2, 2, 44100, 0, 'NONE', 'not compressed'))
a = []
for i in range(len(sum1)):
x = (sum1[i] / val) * (32767)
a.append(x)
val2 = max(abs(i) for i in (sum2))
b = []
for i in range(len(sum2)):
x = (sum2[i] / val2) * (32767)
b.append(x)
for i in range(len(sum1)):
try:
file.writeframes(struct.pack("<h", int(a[i])))
file.writeframes(struct.pack("<h", int(b[i])))
except:
IndexError
file.close()
menu = Menu(root)
root.config(menu=menu)
filemenu = Menu(menu)
menu.add_cascade(label="File", menu=filemenu)
filemenu.add_command(label="New", command=NewFile)
filemenu.add_command(label="Open...", command=OpenFile)
filemenu.add_command(label="Save...", command=file_save)
filemenu.add_separator()
filemenu.add_command(label="Exit", command=quitme)
helpmenu = Menu(menu)
menu.add_cascade(label="Help", menu=helpmenu)
helpmenu.add_command(label="About...", command=About)
#Scale set
var = DoubleVar()
scale = Scale(root, variable=var, orient=HORIZONTAL, from_=1, to=20)
scale.place(height=40, width=150, x=510, y=150)
#Text set
text = Text(root)
text.place(height=445, width=400, x=5, y=50)
text.insert(
END,
"#Welcome to Turing Machine simulator!\n#Quick syntax guide:\n#Lines that start with space or #\n#are concidered as comments\n"
)
text.insert(
END,
"#Input looks like this:\n#STATE1 SYMBOL1 STATE2 SYMBOL2 MOVE\n#Where STATE1 - your current state\n# SYMBOL1 - reading symbol\n# STATE2 - your next state\n"
)
text.insert(
END,
"# SYMBOL2 - writing symbol\n# MOVE - where to go(r-right,l-left,s-stay)\n#Have fun!\n"
)
class ResolverInterface:
def __init__(self):
self.window_width = 800
self.window_height = 10*40
self.root = Tk()
self.colourSetter = ColourSetter(self)
self.draw(init=True)
self.root.mainloop()
return
def draw(self, init=False):
self.root.geometry("%dx%d" % (self.window_width, self.window_height))
self.root.title("RandomImageResolver")
# set colours
self.root.configure(background="black")
self.tk_iters_scale = Scale(self.root)
self.tk_iters_scale_label = Label(self.root, text="Iters")
self.tk_width_scale = Scale(self.root, command=self.handleGridSizeChange)
self.tk_width_scale_label = Label(self.root, text="Width")
self.tk_height_scale = Scale(self.root, command=self.handleGridSizeChange)
self.tk_height_scale_label = Label(self.root, text="Height")
self.tk_hueStd_scale = Scale(self.root)
self.tk_hueStd_scale_label = Label(self.root, text="HueStd")
self.tk_saturStd_scale = Scale(self.root)
self.tk_saturStd_scale_label = Label(self.root, text="SaturStd")
self.tk_valueStd_scale = Scale(self.root)
self.tk_valueStd_scale_label = Label(self.root, text="ValueStd")
self.tk_stdDecay_scale = Scale(self.root)
self.tk_stdDecay_scale_label = Label(self.root, text="StdDecay")
self.tk_parentNoise_scale = Scale(self.root)
self.tk_parentNoise_scale_label = Label(self.root, text="ParentPosNoise")
self.tk_parentNoiseDecay_scale = Scale(self.root)
self.tk_parentNoiseDecay_scale_label = Label(self.root, text="ParentPosNoiseDecay")
# start width, start height, hue shift std, saturation std, value std
self.tk_randomize = Button(self.root, text="Randomize", command=self.handleRandomize)
self.tk_generate = Button(self.root, text="Generate", command=self.handleGenerate)
self.tk_expand = Button(self.root, text="Expand", command=self.handleExpand)
self.tk_save = Button(self.root, text="Save", command=self.handleSave)
self.tk_iters_scale.configure(bd=0, from_=1, to=10, orient=HORIZONTAL, sliderrelief=FLAT, resolution=1)
self.tk_iters_scale.set(8)
self.tk_width_scale.configure(bd=0, from_=1, to=10, orient=HORIZONTAL, sliderrelief=FLAT, resolution=1)
self.tk_width_scale.set(2)
self.tk_height_scale.configure(bd=0, from_=1, to=10, orient=HORIZONTAL, sliderrelief=FLAT, resolution=1)
self.tk_height_scale.set(2)
self.tk_hueStd_scale.configure(bd=0, from_=0, to=0.1, orient=HORIZONTAL, sliderrelief=FLAT, resolution=0.005)
self.tk_hueStd_scale.set(0.01)
self.tk_saturStd_scale.configure(bd=0, from_=0, to=0.4, orient=HORIZONTAL, sliderrelief=FLAT, resolution=0.01)
self.tk_saturStd_scale.set(0.07)
self.tk_valueStd_scale.configure(bd=0, from_=0, to=0.4, orient=HORIZONTAL, sliderrelief=FLAT, resolution=0.01)
self.tk_valueStd_scale.set(0.07)
self.tk_stdDecay_scale.configure(bd=0, from_=0, to=1., orient=HORIZONTAL, sliderrelief=FLAT, resolution=0.1)
self.tk_stdDecay_scale.set(0.)
self.tk_parentNoise_scale.configure(bd=0, from_=0, to=1, orient=HORIZONTAL, sliderrelief=FLAT, resolution=0.05)
self.tk_parentNoise_scale.set(0.15)
self.tk_parentNoiseDecay_scale.configure(bd=0, from_=0, to=1, orient=HORIZONTAL, sliderrelief=FLAT, resolution=0.1)
self.tk_parentNoiseDecay_scale.set(0.)
self.root.bind("<Configure>", self.resize)
# make sure colourSetter size is synced to default
self.colourSetter.setGridSize((self.tk_width_scale.get(), self.tk_height_scale.get()))
self.colourSetter.randomize()
return
def handleRandomize(self, event=[]):
# generate a new random set of colours
start_width = self.tk_width_scale.get()
start_height = self.tk_height_scale.get()
self.colourSetter.setGridSize((start_width, start_height))
self.colourSetter.randomize()
return
def handleGenerate(self, event=[]):
'''
iters = self.tk_iters_scale.get()
start_width = self.tk_width_scale.get()
start_height = self.tk_height_scale.get()
hueStd = self.tk_hueStd_scale.get()
staurStd = self.tk_saturStd_scale.get()
valueStd = self.tk_valueStd_scale.get()
std_decay = self.tk_stdDecay_scale.get()
parent_pos_noise = self.tk_parentNoise_scale.get()
self.IMGS = newImage(start_size=(start_width, start_height), iters=iters, hsv_std = (hueStd, staurStd, valueStd), std_decay=std_decay, parent_pos_noise=parent_pos_noise)
self.IMGS[-1].show()
'''
iters = self.tk_iters_scale.get()
hueStd = self.tk_hueStd_scale.get()
staurStd = self.tk_saturStd_scale.get()
valueStd = self.tk_valueStd_scale.get()
std_decay = self.tk_stdDecay_scale.get()
parent_pos_noise = self.tk_parentNoise_scale.get()
parent_pos_noise_decay = self.tk_parentNoiseDecay_scale.get()
seed = self.colourSetter.getSeed()
self.IMGS = newImage(seed=seed, iters=iters, hsv_std = (hueStd, staurStd, valueStd), std_decay=std_decay, parent_pos_noise=parent_pos_noise, parent_pos_noise_decay=parent_pos_noise_decay)
self.IMGS[-1].show()
return
def handleExpand(self, event=[]):
hueStd = self.tk_hueStd_scale.get()
staurStd = self.tk_saturStd_scale.get()
valueStd = self.tk_valueStd_scale.get()
std_decay = self.tk_stdDecay_scale.get()
parent_pos_noise = self.tk_parentNoise_scale.get()
parent_pos_noise_decay = self.tk_parentNoiseDecay_scale.get()
new_imgs = newImage(seed=self.IMGS[-1], iters=1, hsv_std = (hueStd, staurStd, valueStd), std_decay=std_decay, parent_pos_noise=parent_pos_noise, parent_pos_noise_decay=parent_pos_noise_decay, inum_offset=len(self.IMGS))
self.IMGS.append(new_imgs[-1])
self.IMGS[-1].show()
return
def handleSave(self, event=[]):
# save the current image with prompt for name
#self.tk_entry.focus()
d = MyDialog(self.root)
self.root.wait_window(d.top)
#print("You said: ", d.value)
fname = d.value.strip()
try:
if '.png' not in fname:
fname = fname+".png"
self.IMGS[-1].save(fname)
print("Saved.")
except:
#print("Error: Have not generated image yet.")
print("Error: Nothing saved")
def handleGridSizeChange(self, event=[]):
self.colourSetter.setGridSize((self.tk_width_scale.get(), self.tk_height_scale.get()))
return
def resize(self, event=[]):
pixelX=self.root.winfo_width()
pixelY=self.root.winfo_height()
self.window_width = pixelX
self.window_height = pixelY
nb_scales = 9
colourSetterWidth = 200
label_width = 150
button_width = 75
scale_height = self.window_height/nb_scales
cur_height = 0
scale_width = self.window_width - label_width - button_width - colourSetterWidth
scale_x = label_width+colourSetterWidth
self.tk_iters_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_iters_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_width_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_width_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_height_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_height_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_hueStd_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_hueStd_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_saturStd_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_saturStd_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_valueStd_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_valueStd_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_stdDecay_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_stdDecay_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_parentNoise_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_parentNoise_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
cur_height += scale_height
self.tk_parentNoiseDecay_scale.place(x=scale_x, y=cur_height, width = scale_width, height = scale_height)
self.tk_parentNoiseDecay_scale_label.place(x=colourSetterWidth, y=cur_height, width = label_width, height = scale_height)
randomize_height = int(round(self.window_height*0.3))
generate_height = int(round(self.window_height*0.3))
expand_height = int(round(self.window_height*0.2))
save_height = int(round(self.window_height*0.2))
button_cur_ypos = 0.
self.tk_randomize.place(x=self.window_width-button_width, y=button_cur_ypos, width=button_width, height=randomize_height)
button_cur_ypos += randomize_height
self.tk_generate.place(x=self.window_width-button_width, y=button_cur_ypos, width=button_width, height=generate_height)
button_cur_ypos += generate_height
self.tk_expand.place(x=self.window_width-button_width, y=button_cur_ypos, width=button_width, height= expand_height)
button_cur_ypos += expand_height
self.tk_save.place(x=self.window_width-button_width, y=button_cur_ypos, width=button_width, height= save_height)
button_cur_ypos += save_height
self.colourSetter.place(x=0, y=0, width = colourSetterWidth, height = self.window_height)
def tabla():
global New_Ind_0, New_Ind_1, Amount_People, Index_Variables, Index_Gender
global Tabla_Datos, Lista_Indice, New_Ind_2, State_2, Var_G2, Var_G3
global Var_G6, Index_Var
State_0 = map((lambda var: var.get()), Variable_CB_0)
State_1 = Var_G2.get()
State_2 = Var_G3.get()
New_Ind_0 = []
New_Ind_1 = []
New_Ind_2 = []
print "Variables"
for i in range(len(State_0)):
if State_0[i] == 1:
print i, List_Variables[i]
New_Ind_0.append(Index_Variables[i])
print ''
print "Genero"
print State_1, List_Gender[State_1]
New_Ind_1.append(Index_Gender[State_1])
print ''
print "Parametro"
print State_2, List_Var[State_2]
New_Ind_2.append(Index_Var[State_2])
print ''
Flag_0 = 0 #Bandera para discriminar celdas vacias
Aux_0 = 0 #Auxiliar 0, valor de la celda de datos #Auxiliar 1, valor de la celda de la variable
Lista_Indice = [] #Lista donde se almacena el indice de la tabla de datos
Lista_Temp = [] #Vector auxiliar para armar la Matriz
Tabla_Datos = numpy.zeros(
(0, len(New_Ind_0)
)) #Matriz con los datos de dimensiones 0x(Numero de variables)
for i in range(2, Amount_People,
1): #Desde la primera Columna hasta la ultima
Flag_0 = 0 #Bandera en 0
for j in New_Ind_0: #Desde la primera Fila hasta la ultima
Aux_0 = Sheet.cell(
row=i, column=j
).value #Aux_0 toma el valor de datos de la celda leida #Aux_1 toma el valor de la variable en la misma fila
if Aux_0 is None or Val_Check(
i
) == 1: #Si ni la celda de la variable ni la del dato carecen de valor
Flag_0 = 1 #Bandera en 1
else:
Aux_0 = Sheet.cell(
row=i, column=j
).value * 1.0 #Valor de la tabla pasa de int a float
Lista_Temp.append(
Aux_0
) #Se crea una lista temporal con el valor de la celda de datos
if Flag_0 == 0: #Si la bandera no fue levantada
Tabla_Datos = numpy.vstack(
(Tabla_Datos, Lista_Temp)
) #Se agrega la lista de datos sobre la Tabla que se esta generando
Lista_Indice.append(
i) #Srea una lista indice de la tabla original del Excel
Lista_Temp = [
] #Se reinicia la lista para la siguiente fila #Devuelve la Tablaz y el Indice
global vart
vart = IntVar()
scale = Scale(top,
label=" Number of Clusters",
orient=HORIZONTAL,
variable=vart,
from_=2,
to=10,
length=200,
width=28)
scale.set(3)
scale.place(x=130, y=32, width=150)
Var_G6 = IntVar()
my_objects_5 = []
for i in range(3):
my_objects_5.append(MyClass(i))
k = 0
d = 0
for i in ["Kmeans", "MeanShift", "DBSCAN"]:
my_objects_5[k] = Radiobutton(top, text=i, variable=Var_G6, value=k)
my_objects_5[k].place(x=120, y=105 + d * 20)
k = k + 1
d = d + 1
