def harris(im, d_value):
data_src = im.getdata()
xsize, ysize = im.size
data_res = []
now_pix = 0
last_pix_col = 0
last_pix_row = []
rows = Rows(data_src, 3, xsize)
win = Window(3)
while 1:
w = win.update(rows.update())
if win.is_enable():
break
for y in range(ysize):
for x in range(xsize):
if rows.frame_empty():
rows.create(data_src, 3, xsize)
pix_tblr = [w[0][1], w[2][1], w[1][2], w[1][0]]
pix_now = w[1][1]
diff_tblr = []
for pix in pix_tblr:
diff_tblr.append(abs(pix_now - pix))
pix_res = 0
for d_tb in diff_tblr[0:2]:
for d_lr in diff_tblr[2:4]:
if d_tb >= d_value and d_lr >= d_value:
pix_res = 1
data_res.append(pix_res)
w = win.update(rows.update())
return data_res
def __init__(self, prefs):
self.results = []
Window.__init__(self, self.gtk_builder_file, self.window_name)
self.prefs = prefs
self.ge = GrepEngine()
self.ge.exclude_dirs = self.prefs.get('exclude-dirs')
self.ge.exclude_files = self.prefs.get('exclude-files')
txtbuf = self.txt_results.get_buffer()
self.tag_fixed = txtbuf.create_tag('fixed', family='Monospace')
self.tag_link = txtbuf.create_tag('link', foreground='Blue')
self.tag_red = txtbuf.create_tag('color', foreground='Red')
self.tag_green = txtbuf.create_tag('green', foreground='Dark Green')
self.gtk_window.connect('delete_event', self.close)
self.btn_search.connect('clicked', self.btn_search_clicked)
self.txt_results.connect('button-press-event', self.results_clicked)
self.lbl_path.connect('activate-link', self.lbl_path_clicked)
self.txt_results.connect('motion-notify-event', self.results_mouse_motion)
self.txt_results.connect('key-press-event', self.results_keypress)
self.lbl_options.connect('activate--link', self.options_clicked)
(win_width, win_height) = self.prefs.get('window-size')
self.win_main.resize(win_width,win_height)
self.cbox_path.forall(self.cbox_disable_togglebutton_focus, None)
self.cbox_search.forall(self.cbox_disable_togglebutton_focus, None)
self.deactivate_on_search = [self.btn_search, self.lbl_path, self.lbl_options,
self.cbox_search, self.cbox_path, self.txt_results]
def __init__(self):
Window.show(self)
wdg_retorno = self.get_wdg("txtRetorno")
buffer = gtk.TextBuffer()
wdg_retorno.set_buffer(buffer)
tag_table = buffer.get_tag_table()
error_tag = gtk.TextTag("error")
error_tag.set_property("foreground", "red")
tag_table.add(error_tag)
error_tag = gtk.TextTag("success")
error_tag.set_property("foreground", "blue")
tag_table.add(error_tag)
default_tag = gtk.TextTag("default")
default_tag.set_property("foreground", "black")
tag_table.add(default_tag)
self.stbip = []
self.get_wdg('cbRemoteType').set_active(0)
self.__fill_ip()
self.__check_automate()
WinCamera()
def init(config, files): window = Window(config) if len(files): window.open(files[0]) # We open no more than one file. window.show()
def __init__(s):
#Dane:
win=Window("Point",0,0,600,600)
master=win.getMaster()
desk=Desk(master)
C=desk.getC()
p1=Point(100,100)
p2=Point(200,100)
p3=Point(200,200)
p4=Point(100,200)
desk.addPoint(p1)
desk.addPoint(p2)
desk.addPoint(p3)
desk.addPoint(p4)
path=Path()
path.addPoint(p1)
path.addPoint(p2)
path.addPoint(p3)
path.addPoint(p4)
desk.addPath(path)
win.loop()
def __init__(self):
self.wdg = 'wdgCamera'
self.threads = []
Window.show(self)
img = self.get_wdg('imgCamera')
self.update = UpdateImg(img)
self.update.start()
def loadTemplate(self, key):
conf = {}
if key == '1D ULA, water, critical sampling':
# List the parameters we want:
M = 32 # Number of elements
c = 1540 # Acustic propagation speed in water
fc = 10e3 # Carrier frequency
lmda = c/fc # Wavelength
d = lmda/2 # Distance between elements (spatial sampling)
# w = ones(M)/M # A rectangular window
# Create some axes
p = linspace(0,1,M)*M*d
# Find
# kx = k*cos(theta)
conf['Medium'] = {
# 'id' : 0 ,
'type' : 'simple' ,
'c' : c }
conf['Interface'] = {
# 'id' : 0 ,
'type' : 'simple' }
p = Coordinate(x=p, y=None, z=None)
conf['Array'] = {
# 'id' : 0 ,
'type' : 'simple' ,
'p' : p }
conf['Data'] = {
# 'id' : 0 ,
'type' : 'none' }
w = Window()
w.kaiser(32, 1, 0)
conf['Window'] = {
# 'id' : 0 ,
'type' : 'custom' ,
'w' : w.getData() }
conf['Signal' ] = {
# 'id' : 0 ,
'type' : 'continuous wave' ,
'fc' : fc }
conf['System' ] = {
# 'id' : 0 ,
'type' : 'Simple HUGIN template',
'next' : ('Window', 'Window') }
self.conf = conf
def __init__(self, parent, dictRes):
## STOCK ITEM
self.stock_items = (
("gtk-sendResult", "", 0, 0, None),
)
self.stock_aliases = (
("gtk-sendResult", gtk.STOCK_EXECUTE),
)
gtk.stock_add(self.stock_items)
factory = gtk.IconFactory()
factory.add_default()
style = gtk.Style()
for item, alias in self.stock_aliases:
icon_set = style.lookup_icon_set(alias)
factory.add(item, icon_set)
## FENETRE
self.parent=parent
Window.__init__(self, "Administration Oracle : Résultats")
self.fenetre.connect("delete_event", self.close_window)
settings = gtk.settings_get_default()
settings.props.gtk_button_images = True
self.vbox_main = gtk.VBox(False, 20)
self.fenetre.add(self.vbox_main)
self.frm_res=gtk.Frame("Résultats")
self.scrolled_window = gtk.ScrolledWindow()
self.scrolled_window.set_border_width(10)
self.scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
self.scrolled_window.add_with_viewport(self.frm_res)
self.tab_send = gtk.Table(2, 1, False)
self.frm_send=gtk.Frame("Envoi des résultats par mail ")
self.frm_send.add(self.tab_send)
self.vbox_main.pack_start(self.frm_send, False, False, 0)
self.vbox_main.pack_start(self.scrolled_window, True, True, 0)
self.vbox_resultats= gtk.VBox(False, 0)
self.entry_mail = gtk.Entry()
self.entry_mail.set_width_chars(50)
self.entry_mail.set_text("de[email protected];[email protected];...")
self.but_mailRes = gtk.Button(stock="gtk-sendResult")
self.but_mailRes.modify_bg(gtk.STATE_NORMAL, self.but_color)
self.but_mailRes.connect("clicked", self.sendResult, dictRes)
self.tab_send.attach(self.entry_mail, 0, 1, 0, 1)
self.tab_send.attach(self.but_mailRes, 0, 1, 1, 2)
self.frm_res.add(self.vbox_resultats)
self.setResults(dictRes)
self.fenetre.show_all()
# Min Size
winSize=self.fenetre.get_size()
screen = self.fenetre.get_screen()
if winSize[0]+80 >= screen.get_width()-80:
newWidth = screen.get_width()-80
else:
newWidth = winSize[0]+80
if winSize[1]+80 >= screen.get_height()-80:
newHeight = screen.get_height()-80
else:
newHeight = winSize[1]+80
self.fenetre.resize(newWidth, newHeight)
self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.__isExpanded = True
self.__elements = {}
self.__CreateUI()
def __init__(self, layer = "UI"): Window.__init__(self, layer) self.__maxValue = 1 self.__curValue = 0 self.__doMove = False self.__CreateUI()
def notify (self, event):
"""D.notify (...) -> None
Notifies the DialogWindow about an event.
"""
Window.notify (self, event)
# Recursively notify all attached children.
if self.child:
self._notify_children (self.child, event)
def destroy (self):
"""D.destroy () -> None
Destroys the DialogWindow and removes it from its event system.
"""
self._stop_events = True
if self.manager:
self.manager.eventgrabber = None
Window.destroy (self)
def __init__(self, layer = "UI"): Window.__init__(self, layer) self.__maxValue = 1 self.__curValues = [] self.__rangeSliderWidth = 0 self.__doMove = False self.__CreateUI()
def init(host='localhost',server=None):
"""
Most of this code is copied from init() function in client.py
Game initialization function.
1. Creates a L{Debugger} (debugger) and L{EventTimer} (eventTimer) and
stores references to them in an instance of L{EventManager}.
2. Several listeners are started and registered with eventManager:
- Instance of L{Universe} (universe)
- Instance of L{UserInterface} (ui)
- Instance of L{Window} (gameWindow)
3. We send the eventManager a message to start the game
- This message is interpreted by the gameWindow
"""
#Creates a Debugger that posts events to the terminal for debugging purposes
debugger = Debugger()
eventTimer = EventTimer()
#Create the event manager for low-level events
eventManager = Manager(eventTimer,debugger) #FIXME: more specific manager\
Entity.manager = eventManager
# World w is set to the activeWorld of the universe
universe = Universe(eventManager)
ui = UserInterface(eventManager,universe.activeWorld,'BROADCASTSERVER')
gameWindow = Window(eventManager,width=1024,height=768)
gameWindow.fullscreenMode = False
gameWindow.updateScreenMode()
w = World(universe)
s.world=w
networked = True
client = GameClient(eventManager,host=s.host,port=1567)
#wait until the client is assigned an ID before proceeding
while client.ID == None:
import time
time.sleep(.02)
print 'Got an ID',client.ID
clientID = client.ID
ui.setClientID(clientID)
wManipulator = WorldManipulator(eventManager,w,networked,gameClientID = clientID)
#generate the resources in the server, the existance of these
#resources will propogate through to every client when they connect
w._generateResources()
#Notify the manager that the window should start to accept input:
eventManager.post(Event.StartEvent())
return eventManager.eventTypesToListeners
def getWinnow(self, guarantee, noise=1, salt=''):
thisWindow = Window(guarantee, noise)
for line in self.getHashCopy(salt=salt).split('\n'):
if line.strip() != '':
lineNumber = int(line[1:line.find(' ')])
line = line[line.find(' ') + 1:]
for chunk in line.split(' '):
thisWindow.addChunk(chunk, lineNumber)
return thisWindow.fingerPrint
def __init__(self, layer = "UI"): Window.__init__(self, layer) self.__state = _ButtonState.NORMAL self.__CreateUI() self._SetEventListeners() self.SetWidth(0) self.SetState(_ButtonState.NORMAL)
class Prototype:
def __init__(self):
self.map = Map(Map.MEDIUM)
self.world = World(self.map)
self.window = Window(self.world)
self.inputHandler = InputHandler(self.world, self.window)
def start(self):
self.window.start()
def __init__(self, question, parent, answer_var):
self.width = 400
self.height = 200
self.parent = parent
self.x = (parent.get_width() - self.width) / 2.0
self.y = (parent.get_height() - self.height) / 2.0
self.text = question
answer_var = "LOL"
Window.__init__(self, self.x, self.y, self.width, self.height, parent, "Ask", True)
self.q_label = Button(20, 50, self.text, self.surface, (255, 255, 255), hpad=0)
self.a_input = Input(20, 80, 360)
def __init__(self, layer = "UI"): Window.__init__(self, layer) self.__state = ExpanderState.COLLAPSED self.__arrowRotation = 0.0 self.__CreateUI() self.__SetEventListeners() self.SetWidth(0) self.SetState(ExpanderState.COLLAPSED)
def set_event_manager (self, manager):
"""D.set_event_manager (...) -> None
Sets the event manager of the DialogWindow.
Sets the event manager of the DialogWindow and invokes the
grab_events() method for the DialogWindow.
"""
if not manager and self.manager:
self.manager.eventgrabber = None
Window.set_event_manager (self, manager)
if self.manager:
self.manager.eventgrabber = self
def __init__(self, stdscreen):
self.screen = stdscreen
curses.curs_set(0)
title = "Network Monitor - Dion Bosschieter, Timo Dekker - Version: 0.1"
debug_console = DebugConsole(self.screen, "Debugging information")
main_window = Window(title, self.screen)
info_container = InfoContainer(self.screen, "Netwerk info", debug_console)
gather_information = GatherInformation(info_container, debug_console, "10.3.37.50")
main_menu_items = [
('Connect/Disconnect', gather_information.toggleconnect),
('Gather packets', gather_information.getPackets),
('Exit', exit)
]
main_menu = Menu(main_menu_items, self.screen, "Main menu", debug_console, info_container)
main_window.display()
info_container.display()
debug_console.display()
debug_console.log("Logging initialized")
debug_console.log("Network Monitor has started")
debug_console.log("")
debug_console.log("Usage:")
debug_console.log("Press 'q' to quit, 'h' for the menu, 'p' to import newest packets, 'c' to connect and 'd' to disconnect")
self.threadstop = 0
#create refresh deamon
update_screens = Thread(target=self.updateScreens, args=(debug_console,info_container, main_menu))
update_screens.daemon = True
update_screens.start()
#listen for keypressess
while(True):
c = terminal.getch()
if c == 'q': break
elif c == 'h':
self.threadstop = 1
main_menu.display()
self.threadstop = 0
update_screens = Thread(target=self.updateScreens, args=(debug_console,info_container, main_menu))
update_screens.daemon = True
update_screens.start()
elif c == 'p': gather_information.getPackets()
elif c == 'c': gather_information.connect()
elif c == 'd': gather_information.disconnect()
def __init__(self, file_name,
data_begin = 0,
data_end = 2**31,
temperature = 298.15,
bin_minimum = -200.0, bin_maximum = -100.0,
number_of_bins = 100,
force_constant = 0.0, minimum = 0.0) :
Window.__init__(self, file_name = file_name,
data_begin = data_begin, data_end = data_end,
temperature = temperature,
bin_minimum = bin_minimum, bin_maximum = bin_maximum,
number_of_bins = number_of_bins)
self.__force_constant = force_constant
self.__minimum = minimum
return
def __init__(self, parent, **kwargs):
Window.__init__(self, parent)
# data
self.__dict__["title"] = None
self.__dict__["items"] = None
self.__dict__["looseFocusClose"] = 1
self.__dict__["columns"] = 1
self.__dict__["decorated"] = 0
self.__dict__["layoutManager"] = SimpleGridLM()
self.__dict__["width"] = 10
self.__dict__["_labels"] = []
self.processKWArguments(kwargs)
# subscribe action
# add title
Title(self, id = "_menuTitle")
def create(im, wsize, rank): data_src = im.getdata() xsize,ysize = im.size data_res = [] rows = Rows(data_src, wsize, xsize) win = Window(wsize) while 1: w = win.update(rows.update()) if win.is_enable(): break for i in range(len(data_src)): if rows.frame_empty(): rows.create(data_src, wsize, xsize) data_res.append(rank_fitter(w, rank)) w = win.update(rows.update()) return data_res
def show(self, pos = None):
self._menuTitle.layout = (0, 0, self.width, 1)
self._menuTitle.text = self.title
if not pos:
pos = pygame.mouse.get_pos()
index = 0
width = int(1.0 * self.width / self.columns)
perColumn = ceil(1.0 * len(self.items) / self.columns)
currentLeft = 0
currentVert = 0
for item in self.items:
if len(self._labels) <= index:
label = ActiveLabel(self, align = ALIGN_W, enabled = item.enabled)
label.subscribeAction("*", self.actionHandler)
self._labels.append(label)
label = self._labels[index]
label.layout = (currentLeft, currentVert + 1, width, 1)
label.text = item.text
if hasattr(item, "action"):
label.action = item.action
else:
label.action = None
if hasattr(item, "data"):
label.data = item.data
else:
label.data = None
index += 1
currentVert += 1
if currentVert == perColumn:
currentVert = 0
currentLeft += width
rowSize, colSize = self.app.theme.getGridParams()
self.rect = Rect(pos[0], pos[1], self.width * colSize, (perColumn + 1) * rowSize)
return Window.show(self)
def create(im, wsize, mask, mode): data_src = im.getdata() xsize,ysize = im.size data_res = [] rows = Rows(data_src, wsize, xsize) win = Window(wsize) while 1: win.update(rows.update()) if win.is_enable(): break for y in range(ysize): for x in range(xsize): if rows.frame_empty(): rows.create(data_src, wsize, xsize) w = win.update(rows.update()) data_res.append(erosion_dilation(w, mask, mode)) return data_res
def OC(Window_Type, percent, *args, **kwargs):
# See: http://www.recordingblogs.com/sa/tabid/88/Default.aspx?topic=Overlap+correlation
r = percent/100
N = 1024
if kwargs == {}:
if Window_Type == "coswind":
dummy, w = Window.coswind(N)
elif Window_Type == "gausswind":
dummy, w = Window.gausswind(N)
elif Window_Type == "gengausswind":
if len(args) == 2:
dummy, w = Window.gengausswind(N, args[1], args[2])
else:
raise("2 Adidional args are needed but not given")
elif Window_Type == "genhamwind":
if len(args) == 2:
dummy, w = Window.genhamwind(N, args[1], args[2])
else:
raise("2 Adidional args are needed but not given")
elif Window_Type == "hamwind":
dummy, w = Window.hamwind(N)
elif Window_Type == "hanwind":
dummy, w = Window.hanwind(N)
elif Window_Type == "partzwind":
dummy, w = Window.partzwind(N)
elif Window_Type == "rectwind":
dummy, w = Window.rectwind(N)
elif Window_Type == "triwind":
dummy, w = Window.triwind(N)
elif Window_Type == "Tukeywind":
dummy, w = Window.Tukeywind(N)
elif kwargs['WindowSet'] == 'window':
w = Window_Type
else:
(dummy, w) = Window.hanwind(N)
oc_num = []
for idx in range(int(r * len(w))):
oc_num = np.append(oc_num, w[idx] * w[idx + (1 - r) * len(w)])
oc = oc_num.sum() / np.sum(w ** 2)
return (oc)
def start(self):
self.success = False
self.gameOver = False
self.setCurses()
Global.shell = MineShell()
Global.timer = Timer()
createField = 'minefield ' + str(self.width) + ' ' + str(self.height) + ' ' + str(self.num)
Global.shell.getInput(createField)
window = Window(self.scr)
layout = window.drawLayout(self.width, self.height)
if layout == None:
curses.endwin()
print("The window is too small to display the Game field")
print("Please increase the window size or decrease the font size")
sys.exit(0);
self.mineWin, log, panel, record = layout
self.record = Record(record)
self.mine = GameField(self.mineWin, Global.shell)
self.mine.drawUndeployedMineField()
Global.panel = panel
clock = ClockUpdater()
clock.daemon = True
clock.start()
return self.mine, log, panel, self.record
def __init__(self, name, wl, dataFile):
'''
Constructor:
name name of the stream in multiple data stream
wl window length
dataFile file containing event stream
'''
super(Streamer,self).__init__()
# Storing the values
self.name = name
self.wl = wl
self.dataFile = dataFile
# Setting switches
self.window = Window(wl) # Contents of window
def __init__(self, dataFile, outputFileName, wl, mtp, alpha, sigma, printSummary):
'''
Constructor:
dataFile file containing event stream
outputFileName file in which the output is produced
wl window length
mtp minimal time span
alpha minimal support threshold
sigma minimal conference threshold
printSummary print the summaries at the print interval
'''
# Storing the values
self.dataFile = dataFile
self.outputfileName = outputFileName
self.wl = wl
self.mtp = mtp
self.alpha = alpha
self.sigma = sigma
self.printSummary = printSummary
# Setting switches
self.time = 0 # Current time of the stream
self.outputFile = open(outputFileName, "w") # Output file
self.window = Window(wl) # Contents of window
from Window import Window
from GridManager import GridManager
totalIterations = 500000
speed = .1
# print("Python: {}".format(sys.version))
# print("scipy: {}".format(scipy.__version__))
# print("numpy: {}".format(numpy.__version__))
# print("matplotlib: {}".format(matplotlib.__version__))
# print("pandas: {}".format(pandas.__version__))
# print("sklearn: {}".format(sklearn.__version__))
print()
gridManager = GridManager(1)
w = Window(750, 750)
generate = False
a = input("number of id to start or 0 play certain id: ")
a = int(a)
if a == 0:
a = input("enter id to run: ")
a = int(a)
else:
generate = True
gridManager.setID(a, generate)
w.displayGrids(gridManager)
lastTime = time.time()
iteration = 0
#!/usr/bin/python
from Window import Window
#
# Simple code for testing the Window module, and showing how it is used
#
# Create window of size 10
w = Window(10)
# Add integers 0 - 19 to the window
for i in range(20):
w.add(i)
print w
print w.isFull()
print w.getItem(5)
print w.lastOut
w.clear()
print w
print w.isFull()
print w.lastOut
from Decoder import Decoder
from Window import Window
window = Window()
decoder = Decoder()
while True:
event, values = window.window.Read()
if event is None or event == 'Exit':
break
if event == 'Decoder':
decoder.decoder_tag(window, values)
import wx
from Window import Window
if __name__ == "__main__":
app = wx.App()
wnd = Window(None, "Поиск строк")
app.MainLoop()
import sys
from Window import Window
from PyQt5.QtWidgets import *
if __name__ == "__main__":
app = QApplication(sys.argv)
window = Window()
window.show()
app.exec_()
from Window import Window
from Light import DirLight
from Material import Material
from cv2 import aruco
print aruco.drawDetectedMarkers
#cv2.aruco.drawMarker()
#dic = cv2.aruco.getPredefinedDictionary(cv2.acuro.DICT_6X6_250)
#print cv2.aruco
print help(cv2)
bridge = CvBridge()
with open('camera_calib.pickle', 'r') as f:
ret, mtx, dist, rvecs, tvecs, objpoints, imgpoints = pickle.load(f)
window = Window(640, 480, 16, 'OpenCV+OpenGL')
webcam_image = np.zeros((480, 640, 3), dtype=np.uint8)
tex = Texture(webcam_image.shape[:2])
fbo = Framebuffer(*webcam_image.shape[:2])
Texture.handlesToUBO([tex.handle, fbo.color_handle])
def callback(data):
webcam_image[:] = bridge.imgmsg_to_cv2(data, "passthrough")
rospy.init_node('listener', anonymous=True, disable_signals=True)
rospy.Subscriber("/rgb/image", Image, callback, queue_size=1)
thread.start_new_thread(rospy.spin, ())
def __init__(self, layer="UI"):
Window.__init__(self, layer)
from tkinter import *
from Window import Window
if __name__ == '__main__':
root = Tk()
app = Window(root)
root.resizable(False, False)
root.mainloop()
def run():
random.seed(1)
print("RUN")
simulation = Simulation(step=0,
threshold=threshold_size,
control_area_edges=control_area_edges_cnf)
window = Window(simulation.step, set(), set(), 0, 0, 0)
while traci.simulation.getMinExpectedNumber(
) > 0: # While there are cars (and waiting cars)
# LAST STEP
# Vehicles to control area
vehs_load = traci.simulation.getLoadedIDList()
vehs_load_Vehicle = []
for veh in vehs_load:
if veh != "simulation.findRoute":
vehicl = Vehicle(veh)
vehs_load_Vehicle.append(vehicl)
simulation.vehs_load = vehs_load_Vehicle
update_vehicles_to_control_area(simulation)
if simulation.step == 0:
simulation.NOx_control_zone_restriction_mode = p_t_ini
window.NOx_total_w = p_t_ini
window.NOx_control_zone_w = p_t_ini
window.p_t = p_t_ini
window.p_t_total = p_t_ini
window.lambda_l = 0.8
window.alpha = alpha_ini
simulation.add_alpha(alpha_ini)
#print("STEP 0", simulation.alphas)
#print(simulation.alphas[len(simulation.alphas) - 1])
# Add variables for the last 50 steps
simulation.add_window(window)
print("Window: ", window)
# Reboot all
window = Window(simulation.step, window.vehicles_in_w.copy(),
set(), 0, 0, window.veh_total_number_w)
# NEW STEP
traci.simulationStep() # Advance one time step: one second
simulation.update_Step()
window.update_Step()
# MANAGE VEHICLES - All simulation
id_vehs_departed = list(
traci.simulation.getDepartedIDList()) # Vehicles in simulation
if (id_vehs_departed): # if the list is not empty
# All simulation:
id_vehs_departed_Vehicle = []
for id_veh_dep in id_vehs_departed:
if id_veh_dep != "simulation.findRoute":
id_veh_dep_Vehicle = Vehicle(id_veh_dep)
id_veh_dep_Vehicle.step_ini = simulation.step
num_packages = random.randint(min_packages, max_packages)
id_veh_dep_Vehicle.n_packages = num_packages
id_veh_dep_Vehicle.vType = traci.vehicle.getTypeID(
id_veh_dep_Vehicle.id)
id_vehs_departed_Vehicle.append(id_veh_dep_Vehicle)
simulation.add_vehicles_in_simulation(
id_vehs_departed_Vehicle
) # Add vehicles to the simulation list
simulation.add_all_veh(id_vehs_departed_Vehicle)
# Per window:
window.add_vehicles_in_w(simulation.vehicles_in_simulation)
window.veh_total_number_w = len(window.vehicles_in_w)
# Taking into account the vehicles that reach their destination:
id_vehicles_arrived = traci.simulation.getArrivedIDList()
for veh in id_vehicles_arrived:
for veh_sim in simulation.vehicles_in_simulation:
if veh == veh_sim.id: # If the vehicle has arrived then remove it from the simulation
simulation.update_step_fin_veh(simulation.step, veh_sim)
simulation.remove_vehicles_in_simulation(veh_sim)
simulation.add_veh_total_number(
1) # Update Vehicle Total Number in all simulation
for veh_w in window.vehicles_in_w:
if veh == veh_w.id:
window.remove_vehicles_in_w(veh_w)
window.sub_veh_total_number_w(1)
break
break
## IMPORTANT PART - FOR EACH VEHICLE:
for veh in simulation.vehicles_in_simulation:
# Emissions:
# All simulation
vehNOxEmission = traci.vehicle.getNOxEmission(
veh.id) # Return the NOx value per vehicle in each step
if vehNOxEmission > 0 and veh.id in historical_veh_max: #HISTORICAL
historical_veh_max_contador[veh.id] += 1
historical_veh_max[veh.id] += vehNOxEmission
elif veh.id not in historical_veh_max:
historical_veh_max_contador[veh.id] = 1
historical_veh_max[veh.id] = vehNOxEmission
simulation.add_NOx_Total(vehNOxEmission)
veh.add_NOx(vehNOxEmission)
#print(veh.id, veh.NOx)
# Per Window
window.add_NOx_Total_w(vehNOxEmission)
# Control Area:
pos = traci.vehicle.getPosition(vehID=veh.id) # (x,y)
if (pos[1] <= min_y and pos[1] >= max_y) and (
pos[0] >= min_x and pos[0] <= max_x
): # x=> 0, y=>1. If the vehicle is in the control area
# All simulation:
simulation.add_NOx_control_zone(vehNOxEmission)
# Per window:
window.add_NOx_control_zone_w(vehNOxEmission)
# Control area:
simulation.add_NOx_control_zone_restriction_mode(
vehNOxEmission)
# Route lenght per vehicle
rouIndex = traci.vehicle.getRouteIndex(veh.id)
edges = traci.vehicle.getRoute(veh.id)
if veh not in window.vehicles_in_control_zone_w and edges[
rouIndex] + "_0" in control_area_edges_cnf:
window.add_vehicles_in_control_zone_w(veh.id)
"""
if rouIndex == (len(edges) - 1): # Only if is the last edge
stage = traci.simulation.findRoute(edges[0], edges[rouIndex])
rouLength = stage.length # Route Length
veh.total_km = rouLength
# Control area - Threshold:
string_current_edge = edges[rouIndex] + "_0"
if simulation.restrictionMode and traci.vehicle.getVehicleClass(veh.id)!="authority":
if (string_current_edge in simulation.control_area_edges): # current edge in control area
vClass_last2 = traci.vehicle.getVehicleClass(veh.id)
traci.vehicle.setType(vehID=veh.id, typeID="authority")
if (vClass_last2 != "passenger"):
traci.vehicle.setEmissionClass(veh.id, "zero")
# REROUTE VEHICLES:
if simulation.restrictionMode:
inList = False
for edg in edges:
edgStrng = edg + "_0"
if edgStrng in simulation.control_area_edges:
inList = True
break
if inList:
traci.vehicle.rerouteTraveltime(veh.id, True)
"""
# Window
if ((simulation.step %
window_size) == 0): # Each window, window_size steps
# Discount NOx of the last window:
for w in range(len(simulation.windows)):
if simulation.windows[
w].step == simulation.step - window_size: # The last window
lambda_l = random.uniform(0.8, 1.2)
alpha = max(
0.5,
min(
1, lambda_l *
simulation.alphas[len(simulation.alphas) - 1]))
simulation.add_alpha(alpha)
window.lambda_l = lambda_l
window.alpha = alpha
p_t = alpha * simulation.windows[
w].p_t + window.NOx_control_zone_w
p_t_total = alpha * simulation.windows[
w].p_t_total + window.NOx_total_w
simulation.NOx_control_zone_restriction_mode = p_t
window.p_t = p_t
window.p_t_total = p_t_total
if simulation.NOx_control_zone_restriction_mode < 0:
simulation.NOx_control_zone_restriction_mode = 0
window.p_t = 0
# Add variables for the last 50 steps
simulation.add_window(window)
print("Window: ", window)
# Reboot all
window = Window(simulation.step, window.vehicles_in_w.copy(),
window.vehicles_in_control_zone_w.copy(), 0, 0,
window.veh_total_number_w)
window.vehicles_in_control_zone_w = set()
"""
# CONTROL ZONE ON
#print(simulation.step, simulation.NOx_control_zone_restriction_mode)
if simulation.vehicles_in_simulation != [] and simulation.restrictionMode == False and simulation.NOx_control_zone_restriction_mode > threshold_size:
print("CONTROL ZONE ON", simulation.NOx_control_zone_restriction_mode)
simulation.restrictionMode = True
for aEd in simulation.control_area_edges:
traci.lane.setDisallowed(laneID=aEd, disallowedClasses=["passenger", "evehicle"])
#print("disa ", traci.lane.getDisallowed(laneID=aEd))
traci.lane.setAllowed(laneID=aEd, allowedClasses=["authority"])
#print("alo ", traci.lane.getAllowed(laneID=aEd))
# CONTROL ZONE OFF
if (simulation.restrictionMode and simulation.NOx_control_zone_restriction_mode <= threshold_size):
print("CONTROL ZONE OFF", simulation.NOx_control_zone_restriction_mode)
simulation.restrictionMode = False
for aEd in simulation.control_area_edges:
traci.lane.setAllowed(laneID=aEd, allowedClasses=["authority", "passenger", "evehicle"])
for veh in simulation.vehicles_in_simulation:
traci.vehicle.rerouteTraveltime(veh.id, True)
"""
#print(simulation.step, "NOx_control_zone: ", simulation.NOx_control_zone, ". NOx_control_zone_restriction_mode: ", simulation.NOx_control_zone_restriction_mode, ". NOx_total: ", simulation.NOx_total)
minutes = round(simulation.step / 60, 3)
"""
for v in simulation.all_veh:
simulation.total_kilometers += v.total_km
"""
# Results:
print("Windows:")
for w in simulation.windows:
print(w)
print("Vehicles:")
print("In ", simulation.step, "seconds (", minutes, " minutes)")
print("All simulation:")
print(simulation)
## HISTORICAL
for veh in simulation.all_veh:
print(historical_veh_max[veh.id], historical_veh_max_contador[veh.id])
historical_veh_max[veh.id] = historical_veh_max[
veh.id] / historical_veh_max_contador[veh.id]
print(historical_veh_max[veh.id])
hist_veh = dict(
sorted(historical_veh_max.items(), key=lambda item: item[1])) # sort
# RESULTS FILE - HISTORICAL
cont_file = 0
file = "historical_"
fileName = r"./historical_results/" + file + str(cont_file) + "_max.txt"
print(fileName)
fileObject = Path(fileName)
while fileObject.is_file():
cont_file += 1
fileName = r"./historical_results/" + file + str(
cont_file) + "_max.txt"
print(fileName)
fileObject = Path(fileName)
# f=open("./"+fileName+".txt", "w")
f = open(fileName, "w")
for k, v in hist_veh.items():
f.write(k + " " + str(v) + "\n")
f.close()
## RESULTS FILE 2
cont_file = 0
file = "results_file_"
fileName = r"./results2/" + file + str(cont_file) + ".csv"
print(fileName)
fileObject = Path(fileName)
while fileObject.is_file():
cont_file += 1
fileName = r"./results2/" + file + str(cont_file) + ".csv"
print(fileName)
fileObject = Path(fileName)
f = open(fileName, "w")
# Results:
f.write("HISTORICAL - NO CONTROL ZONE, " + "\n")
f.write("PARAMETERS," + "\n")
# p(t)
f.write("window_size, alpha_ini, p_t_ini, min_packages, max_packages," +
"\n")
f.write(
str(window_size) + "," + str(alpha_ini) + "," + str(p_t_ini) + "," +
str(min_packages) + "," + str(max_packages) + "," + "\n")
f.write("WINDOWS," + "\n")
f.write(
"step, NOx_total_w, NOx_total_acum, alpha, lambda, p_t_total, e_t_total, p_t_control_zone, e_t_control_zone, num_veh_total, num_vehicles_control_zone, "
+ "\n")
acum = 0
for w in simulation.windows:
acum += w.NOx_total_w
f.write(
str(w.step) + "," + str(w.NOx_total_w) + "," + str(acum) + "," +
str(w.alpha) + "," + str(w.lambda_l) + "," + str(w.p_t_total) +
"," + str(w.NOx_total_w) + "," + str(w.p_t) + "," +
str(w.NOx_control_zone_w) + "," + str(w.veh_total_number_w) + "," +
str(len(w.vehicles_in_control_zone_w)) + "," + "\n")
f.write("VEHICLES," + "\n")
f.write(
"id, vType, NOx_total_veh, n_packages, step_ini, step_fin, total_time(sec),median_package,"
+ "\n")
p_all = 0
cont = 0
for v in simulation.all_veh:
total_time = v.step_fin - v.step_ini
median_package = total_time / v.n_packages
p_all += median_package
cont += 1
f.write(v.id + "," + v.vType + "," + str(v.NOx) + "," +
str(v.n_packages) + "," + str(v.step_ini) + "," +
str(v.step_fin) + "," + str(total_time) + "," +
str(median_package) + "," + "\n")
median_package_all = p_all / cont
f.write("ALL SIMULATION," + "\n")
f.write("total_steps(sec), minutes, median_package_all_sim," + "\n")
f.write(
str(simulation.step) + "," + str(minutes) + "," +
str(median_package_all) + "," + "\n")
f.close()
# TraCI
traci.close()
sys.stdout.flush()
from Window import Window
if __name__ == '__main__':
window = Window(512, 512, 'Lab2 Sergey Pereyaslavskiy')
window.show()
from Window import Window from tkinter import Tk root = Tk() win = Window(root) root.mainloop()
def run():
print("RUN")
simulation = Simulation(step = 0, threshold_L = threshold_L, threshold_H= threshold_H, k = 1,
control_area_edges=control_area_edges_cnf)
window = Window(simulation.step,set(), 0, 0, 0)
while traci.simulation.getMinExpectedNumber() > 0: # While there are cars (and waiting cars)
# LAST STEP
# Vehicles to control area
vehs_load = traci.simulation.getLoadedIDList()
vehs_load_Vehicle = []
for veh in vehs_load:
if veh != "simulation.findRoute":
vehicl = Vehicle(veh)
vehs_load_Vehicle.append(vehicl)
simulation.vehs_load = vehs_load_Vehicle
update_vehicles_to_control_area(simulation)
# NEW STEP
traci.simulationStep() # Advance one time step: one second
simulation.update_Step()
window.update_Step()
# Window
if ((simulation.step % window_size) == 0) and window.vehicles_in_w != []: # Each window, window_size steps # TODO change [] for set()
# Discount NOx of the last window:
for w in range(len(simulation.windows)):
if simulation.windows[w].step == simulation.step - window_size:
#print("1",simulation.step, simulation.NOx_control_zone_restriction_mode)
simulation.sub_NOx_control_zone_restriction_mode(simulation.windows[w].NOx_control_zone_w)
if simulation.NOx_control_zone_restriction_mode < 0:
simulation.NOx_control_zone_restriction_mode = 0
#print("2",simulation.step, simulation.NOx_control_zone_restriction_mode)
# Add variables for the last 50 steps
simulation.add_window(window)
print("Window: ", window)
# Reboot all
window = Window(simulation.step,window.vehicles_in_w.copy(), 0, 0, window.veh_total_number_w)
# MANAGE VEHICLES - All simulation
id_vehs_departed = list(traci.simulation.getDepartedIDList()) # Vehicles in simulation
if(id_vehs_departed): # if the list is not empty
# All simulation:
id_vehs_departed_Vehicle = []
for id_veh_dep in id_vehs_departed:
if id_veh_dep != "simulation.findRoute":
id_veh_dep_Vehicle = Vehicle(id_veh_dep)
id_vehs_departed_Vehicle.append(id_veh_dep_Vehicle)
simulation.add_vehicles_in_simulation(id_vehs_departed_Vehicle) # Add vehicles to the simulation list
simulation.add_all_veh(id_vehs_departed_Vehicle)
# Per window:
window.add_vehicles_in_w(simulation.vehicles_in_simulation)
window.veh_total_number_w = len(window.vehicles_in_w)
# Taking into account the vehicles that reach their destination:
id_vehicles_arrived = traci.simulation.getArrivedIDList()
for veh in id_vehicles_arrived:
for veh_sim in simulation.vehicles_in_simulation:
if veh == veh_sim.id: # If the vehicle has arrived then remove it from the simulation
simulation.remove_vehicles_in_simulation(veh_sim)
simulation.add_veh_total_number(1) # Update Vehicle Total Number in all simulation
for veh_w in window.vehicles_in_w:
if veh == veh_w.id:
window.remove_vehicles_in_w(veh_w)
window.sub_veh_total_number_w(1)
break
break
## IMPORTANT PART - FOR EACH VEHICLE:
for veh in simulation.vehicles_in_simulation:
# Emissions:
# All simulation
vehNOxEmission = traci.vehicle.getNOxEmission(veh.id) # Return the NOx value per vehicle in each step
simulation.add_NOx_Total(vehNOxEmission)
veh.add_NOx(vehNOxEmission)
#print(veh.id, veh.NOx)
# Per Window
window.add_NOx_Total_w(vehNOxEmission)
# Control Area:
pos = traci.vehicle.getPosition(vehID=veh.id) # (x,y)
if (pos[1] <= min_y and pos[1] >= max_y) and (pos[0] >= min_x and pos[0] <= max_x): # x=> 0, y=>1. If the vehicle is in the control area
# All simulation:
simulation.add_NOx_control_zone(vehNOxEmission)
# Per window:
window.add_NOx_control_zone_w(vehNOxEmission)
# Control area:
simulation.add_NOx_control_zone_restriction_mode(vehNOxEmission)
# Route lenght per vehicle
rouIndex = traci.vehicle.getRouteIndex(veh.id)
edges = traci.vehicle.getRoute(veh.id)
"""
if rouIndex == (len(edges) - 1): # Only if is the last edge
stage = traci.simulation.findRoute(edges[0], edges[rouIndex])
rouLength = stage.length # Route Length
veh.total_km = rouLength
"""
# Control area - Threshold:
class_veh_changer(simulation, veh)
# REROUTE VEHICLES:
if simulation.restrictionMode:
inList = False
for edg in edges:
edgStrng = edg + "_0"
if edgStrng in simulation.control_area_edges:
inList = True
break
if inList:
traci.vehicle.rerouteTraveltime(veh.id, True)
# CONTROL ZONE
decision_maker(simulation)
#print(simulation.step, "NOx_control_zone: ", simulation.NOx_control_zone, ". NOx_control_zone_restriction_mode: ", simulation.NOx_control_zone_restriction_mode, ". NOx_total: ", simulation.NOx_total)
minutes = round(simulation.step / 60, 0)
"""
for v in simulation.all_veh:
simulation.total_kilometers += v.total_km
"""
## RESULTS FILE
cont_file = 0
file = "results_file_"
fileName = r"./results/"+file+str(cont_file)+".txt"
print(fileName)
fileObject = Path(fileName)
while fileObject.is_file():
cont_file += 1
fileName = r"./results/"+ file + str(cont_file) +".txt"
print(fileName)
fileObject = Path(fileName)
#f=open("./"+fileName+".txt", "w")
f=open(fileName, "w")
# Results:
print("Windows:")
f.write("Windows:\n")
for w in simulation.windows:
print(w)
vehInW = ""
for veh in w.vehicles_in_w:
vehInW += veh.id + ","
f.write(str(w.step) + ". NOx_total_w: " + str(w.NOx_total_w) + ". NOx_control_zone_w: " + str(w.NOx_control_zone_w) + ". veh_total_number_w: " + str(w.veh_total_number_w) + ". Vehicles: " + vehInW +"\n")
print("Vehicles:")
f.write("Vehicles:\n")
for v in simulation.all_veh:
print(v)
f.write(str(v.id) + " . Total NOx per vehicle: " + str(v.NOx) + "\n")
print("In ", simulation.step, "seconds (", minutes, " minutes)")
f.write("In "+ str(simulation.step)+ "seconds ("+ str(minutes)+ " minutes)\n")
print("All simulation:")
f.write("All simulation:\n")
print(simulation)
f.write(str(simulation.step) + ". restrictionMode: " + str(simulation.restrictionMode) + ". NOx_total:" + str(simulation.NOx_total)+ \
". NOx_control_zone:" + str(simulation.NOx_control_zone) + ". veh_total_number: " + str(simulation.veh_total_number) +"\n")
f.close()
# TraCI
traci.close()
sys.stdout.flush()
from Window import Window window = Window() window.start()
def __init__(self):
pygame.init()
self.window = Window(1280, 760, 'Depth', './assets/player/Wizard.png')
self.running = None
self.gameStateHandler = GameStateHandler(self.window, self)
""" This file is responsible for starting the ASL Translator Author: Sufiyaan Nadeem """ from Window import Window import tkinter Window(tkinter.Tk( )) #Window(tkinter.Tk(),1)#Video Source can be changed for external webcam
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random
from multiprocessing import Process
from Window.Window import *
win = Window()
def randomPoint(tipo):
global win
while True:
start = list()
start.append(random.randrange(win.getDimensions()[0]))
start.append(random.randrange(win.getDimensions()[1]))
#print (start)
if win.valTerrain(start, tipo):
break
return start
def run(inicio, final, name):
win = Window()
tipo = ["Human", "Monkey", "Octopus"]
players = list()
print("{}\tInicio: {}\tFinal: {}".format(name, inicio, final))
for t in tipo:
players.append([t, inicio, final])
win.setPlayers(players)
win.loop()
def __init__(self, layer="UI"):
Window.__init__(self, layer)
self.liButtons = []
self.__selectedIndex = 0
# -*- coding:utf-8 -*-
from tkinter import Tk
from Window import Window
import socket
if __name__ == '__main__':
win=Tk()
ww = 530#窗口宽设定530
wh = 430#窗口高设定430
# 服务端为TCP方式，客户端也采用TCP方式，默认参数即为TCP
client = socket.socket()
# 访问服务器的IP和端口
ip_port= ('192.168.43.31', 8888)
# 连接主机
client.connect(ip_port)
Window(win,ww,wh,client)
win.protocol("WM_DELETE_WINDOW",Window.closeEvent)
win.mainloop()
from Window import Window
from Connection import Connection
from GetHost import getHost
import hd
sep = "\x1d"
username = "******"
def formatMessage(m):
mType, sender, data = m.split(sep)
return sender + ": " + data
def loop():
for i in window.getEvents():
connection.send(i, "message", username)
recieve = connection.getEvents()
if recieve:
window._print(formatMessage(recieve))
ip, port = getHost()
username = getHost()
window = Window()
connection = Connection(ip, port)
window.runLoop(loop)
def __init__(self, layer="UI"):
Window.__init__(self, layer)
self.SetFontName("Tahoma:12") # TODO
__author__ = 'thecomet'
import pygame
from Window import Window
if __name__ == '__main__':
pygame.init()
window = Window(1280, 720)
window.enter_main_loop()
pygame.quit()
from Window import Window
import threading
from DetectAndTrack import Tracking
import time
import cv2
import os
from application import App
from detection import get_classes, detect_image
os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'
threading_event = threading.Event()
trackers = cv2.MultiTracker_create()
door_to_heaven = Window(trackers)
time.sleep(1)
if __name__ == "__main__":
server = UdpSocket(door_to_heaven, threading_event)
server.start_socket("127.0.0.1", 50000, "test")
serverSensors = UdpSocket(door_to_heaven, threading_event)
serverSensors.start_socket("127.0.0.1", 50009, "test")
tracking = Tracking(threading_event, trackers, door_to_heaven)
tracking.start()
tk_app = App(tkinter.Tk(), "Projet IA Ingé 2", door_to_heaven, server,
serverSensors)
def __del__(self):
Window.__del__(self)
del self.liButtons
def add_window(self, name, window_azimuth, height, length, device_number,
device_width):
new_window = Window(name, window_azimuth, height, length,
device_number, device_width)
self.windows.append(new_window)
class BotTester:
base_x = 10
base_y = 10
def __init__(self, x, y, edge, start, goal, executable, auto):
self.x, self.y = x, y
self.edge = edge
self.auto = auto
self.goal = complex(*self[goal])
self.bot_pos = self.start = complex(*self[start])
self.bot_angle = complex(0, 1)
self.window = Window(self.x, self.y)
self.c_program = Program(executable)
#self.c_program=IO()
Thread(target=self.refresh, daemon=False).start()
self.window.launch()
def refresh(self):
import time, sys
while True:
if not self.window.alive:
sys.exit()
self.window.update()
for i in self.edge:
self.window.create_edge(self[i[0]], self[i[1]])
self.window.create_node(re(self.bot_pos), 5)
self.window.create_node(re(self.bot_pos + self.bot_angle / 10),
1)
time.sleep(.2)
self.get_bot()
def __getitem__(self, n):
return n % self.x, n // self.x
def s(self, x, y):
return int(x + y * self.x)
def at_edge(self, a):
n_e = [self.s(*re(a)), self.s(*re(self.bot_pos))]
for e in self.edge:
if e in (n_e, n_e[::-1]):
return True
return False
def at_node(self, a):
for e in self.edge:
if self.s(*re(a)) in e:
return True
return False
def get_bot(self):
while True:
inp = self.c_program.input()
if '>' in inp:
if 'Further' in inp:
if self.auto:
ans = 'y'
if self.goal == self.bot_pos:
ans = 'g'
self.goal = None
self.auto = False
else:
ans = input()
self.c_program.print(ans)
elif 'Distance' in inp:
i = 0
while i < 100:
i += 1
self.bot_pos += self.bot_angle
if self.at_node(self.bot_pos):
self.c_program.print(str(10 * i))
return
print("Failed")
exit()
elif 'Ways' in inp:
ans = []
for i in complex(1, 0), complex(0, -1), complex(
-1, 0), complex(0, 1):
ans.append(
str(
int(
self.at_edge(self.bot_angle * i +
self.bot_pos))))
self.c_program.print(''.join(ans))
return
elif ':' in inp:
if 'Turn' in inp:
if 'Right' in inp:
self.bot_angle *= complex(0, -1)
elif 'Left' in inp:
self.bot_angle *= complex(0, 1)
elif 'Back' in inp:
self.bot_angle *= complex(-1, 0)
elif 'Reset' in inp:
self.bot_pos = self.start
self.bot_angle = complex(0, 1)
return
def __del__(self):
Window.__del__(self)
class Handler:
display_file = DisplayFile()
pontos = []
def __init__(self, builder, drawing_area):
self.builder = builder
self.drawing_area = drawing_area
self.normaliza = Normaliza()
self.descritorOBj = DescritorOBj()
self.window_object = builder.get_object("janelaNovoObjeto")
self.window_transform_object = builder.get_object(
"janelaTransformarObjeto")
self.window_choose_file = builder.get_object("janelaEscolherObj")
da_largura = self.drawing_area.get_allocation().width
da_altura = self.drawing_area.get_allocation().height
self.tree_view = self.builder.get_object("treeObjetos")
self.window = Window(-cbz, -cbz, da_largura - cbz, da_altura - cbz)
self.viewport = Viewport(-cbz, -cbz, da_largura - cbz, da_altura - cbz)
self.normaliza.setWindow(self.window)
self.viewport.setWindow(self.window)
self.display_file.setBuilder(builder)
self.radio_rotacionar_mundo = self.builder.get_object(
"radioRotacionarMundo")
self.radio_rotacionar_objeto = self.builder.get_object(
"radioRotacionarObjeto")
self.radio_rotacionar_ponto = self.builder.get_object(
"radioRotacionarPonto")
def onDestroy(self, *args):
Gtk.main_quit()
def on_buttonNovoObjeto_clicked(self, *args):
self.pontos = []
window_object = self.builder.get_object("janelaNovoObjeto")
window_object.show_all()
def on_buttonCriarDesenharPonto_clicked(self, *args):
name_entry = self.builder.get_object("entryNomeObjeto")
x_entry = self.builder.get_object("spinXPonto")
y_entry = self.builder.get_object("spinYPonto")
p = Poligono(name_entry.get_text())
p.addPonto(int(x_entry.get_text()), int(y_entry.get_text()))
p.setTipo("ponto")
self.display_file.addObjeto(p)
self.window_object.hide()
def on_buttonCriarDesenharReta_clicked(self, *args):
name_entry = self.builder.get_object("entryNomeObjeto")
x_entry = self.builder.get_object("spinXInicialReta")
y_entry = self.builder.get_object("spinYInicialReta")
x_final_entry = self.builder.get_object("spinXFinalReta")
y_final_entry = self.builder.get_object("spinYFinalReta")
p = Poligono(name_entry.get_text())
p.addPonto(int(x_entry.get_text()), int(y_entry.get_text()))
p.addPonto(int(x_final_entry.get_text()),
int(y_final_entry.get_text()))
p.setTipo("reta")
self.display_file.addObjeto(p)
self.window_object.hide()
def on_buttonAdicionarPontoPoligono_clicked(self, *args):
x_entry = self.builder.get_object("spinXPoligono")
y_entry = self.builder.get_object("spinYPoligono")
self.pontos.append([x_entry.get_text(), y_entry.get_text(), 1])
print('Ponto - x: {}, y: {} adicionado'.format(int(
x_entry.get_text()), int(y_entry.get_text())))
def on_buttonCriarDesenharPoligono_clicked(self, *args):
name_entry = self.builder.get_object("entryNomeObjeto")
p = Poligono(name_entry.get_text())
for ponto in self.pontos:
p.addPonto(int(ponto[0]), int(ponto[1]))
if int(len(self.pontos)) > 2:
p.setTipo("poligono")
elif int(len(self.pontos)) == 2:
p.setTipo("reta")
else:
p.setTipo("ponto")
self.display_file.addObjeto(p)
self.window_object.hide()
def on_buttonDeletarObjeto_clicked(self, *args):
obj_lista, i = self.tree_view.get_selection().get_selected()
if i != None:
self.display_file.removeObjeto(obj_lista[i][0])
obj_lista.remove(i)
self.redraw(self.drawing_area)
def on_buttonTransformarObjeto_clicked(self, *args):
_, i = self.tree_view.get_selection().get_selected()
if i != None:
window_transform_object = self.builder.get_object(
"janelaTransformarObjeto")
window_transform_object.show_all()
def on_buttonUp_clicked(self, *args):
passo = self.builder.get_object("spinPasso")
self.window.move(0, int(passo.get_text()))
self.redraw(self.drawing_area)
def on_buttonLeft_clicked(self, *args):
passo = self.builder.get_object("spinPasso")
self.window.move(-int(passo.get_text()), 0)
self.redraw(self.drawing_area)
def on_buttonDown_clicked(self, *args):
passo = self.builder.get_object("spinPasso")
self.window.move(0, -int(passo.get_text()))
self.redraw(self.drawing_area)
def on_buttonRight_clicked(self, *args):
passo = self.builder.get_object("spinPasso")
self.window.move(int(passo.get_text()), 0)
self.redraw(self.drawing_area)
def on_ButtonIn_clicked(self, *args):
passo = self.builder.get_object("spinPasso")
porcentagem = 1 + (int(passo.get_text()) / 100)
self.window.zoom(porcentagem)
self.redraw(self.drawing_area)
def on_buttonOut_clicked(self, *args):
passo = self.builder.get_object("spinPasso")
porcentagem = 1 - (int(passo.get_text()) / 100)
self.window.zoom(porcentagem)
self.redraw(self.drawing_area)
def on_buttonRotacionaEsquerda_clicked(self, *args):
angulo = int(self.builder.get_object("spinAnguloWindow").get_text())
self.window.rotate(angulo)
self.redraw(self.drawing_area)
def on_buttonRotacionaDireita_clicked(self, *args):
angulo = int(self.builder.get_object("spinAnguloWindow").get_text())
self.window.rotate(-angulo)
self.redraw(self.drawing_area)
def on_buttonTransladar_clicked(self, *args):
obj_lista, i = self.tree_view.get_selection().get_selected()
obj = self.display_file.getObjeto(obj_lista[i][0])
dx = self.builder.get_object("spinXVetorTrans")
dy = self.builder.get_object("spinYVetorTrans")
obj.translacao(int(dx.get_text()), int(dy.get_text()))
self.window_transform_object.hide()
self.redraw(self.drawing_area)
def on_buttonEscalonar_clicked(self, *args):
obj_lista, i = self.tree_view.get_selection().get_selected()
obj = self.display_file.getObjeto(obj_lista[i][0])
dx = self.builder.get_object("spinXFatorEscala")
dy = self.builder.get_object("spinYFatorEscala")
centro = obj.centroGeo()
obj.escalona(int(dx.get_text()), int(dy.get_text()), centro)
self.window_transform_object.hide()
self.redraw(self.drawing_area)
def on_buttonRotacionar_clicked(self, *args):
obj_lista, i = self.tree_view.get_selection().get_selected()
obj = self.display_file.getObjeto(obj_lista[i][0])
angulo = self.builder.get_object("spinAngulo")
if self.radio_rotacionar_mundo.get_active():
obj.rotacionaMundo(int(angulo.get_text()))
elif self.radio_rotacionar_objeto.get_active():
centro = obj.centroGeo()
obj.rotacionaObj(int(angulo.get_text()), centro)
elif self.radio_rotacionar_ponto.get_active():
dx = self.builder.get_object("spinXRotacionarPonto")
dy = self.builder.get_object("spinYRotacionarPonto")
obj.rotacionaPonto(int(dx.get_text()), int(dy.get_text()),
int(angulo.get_text()))
self.window_transform_object.hide()
self.redraw(self.drawing_area)
def on_buttonImportarObj_clicked(self, *args):
self.window_choose_file.show_all()
def on_buttonExportarObj_clicked(self, *args):
self.descritorOBj.exportFile("./file.obj")
def on_buttonAbrirArquivo_clicked(self, *args):
file_path = self.window_choose_file.get_filename()
self.descritorOBj.importFile(file_path)
self.window_choose_file.hide()
def on_buttonCancelarImportacao_clicked(self, *args):
self.window_choose_file.hide()
def drawBackground(self, drawing_area, ctx, *args):
ctx.set_source_rgb(255, 255, 255) # color white
ctx.paint()
def drawClippingBorder(self, drawing_area, ctx, *args):
ctx.set_line_width(2)
ctx.set_source_rgb(255, 0, 0) # color red
ctx.move_to(cbz, cbz)
ctx.line_to(self.window.getLargura() - cbz, cbz)
ctx.line_to(self.window.getLargura() - cbz,
self.window.getAltura() - cbz)
ctx.line_to(cbz, self.window.getAltura() - cbz)
ctx.close_path()
ctx.stroke()
def on_myDrawingArea_draw(self, drawing_area, ctx, *args):
self.drawBackground(drawing_area, ctx)
ctx.set_line_width(2)
ctx.set_source_rgb(0, 0, 0) # color black
for objeto in self.display_file.getObjetos():
print('Desenhando objeto "{}"'.format(objeto.getNome()))
objeto.drawToViewport(ctx, self.viewport)
ctx.stroke()
self.drawClippingBorder(drawing_area, ctx)
def redraw(self, drawing_area, *args):
drawing_area.queue_draw()
def main():
app = QApplication(sys.argv) # 创建QApplication对象获取命令行参数
window = Window() # 建立一个新窗口
window.resize(960, 640) # 设定窗口大小
window.show() # 展示窗口
sys.exit(app.exec_()) # 退出程序
mod_4 = Module_Individual.Module('Module 4', sens_13, sens_14, sens_15,
sens_16)
mod_5 = Module_Individual.Module('Module 5', sens_17, sens_18, sens_19,
sens_20)
mod_6 = Module_Individual.Module('Module 6', sens_21, sens_22, sens_23,
sens_24)
mod_7 = Module_Individual.Module('Module 7', sens_25, sens_26, sens_27,
sens_28)
mod_8 = Module_Individual.Module('Module 8', sens_29, sens_30, sens_31,
sens_32)
modules_all = [mod_1, mod_2, mod_3, mod_4, mod_5, mod_6, mod_7,
mod_8] # Used to get channels easily (goes from 0 to 7)
# ----------- CONFIGS ----------
daq_config = DAQ_Configuration.DAQconfigs()
base_window = Window()
setting_data_manager = set_dat_man.Setting_File_Manager(
daq_config=daq_config, module_config=modules_all)
main_window = MainWindow(daq_configuration=daq_config,
setting_manager=setting_data_manager,
modules=modules_all)
store_data_window = SaveDataOptionDialog(daq_config)
sensor_matrix = SensorSelectionMatrix()
prog_dlg = ProgressDialog()
# TESTING purposes
log = 1
log_working = 0
# Global Variables.
stop_break_loop = True
def main():
app = wx.App()
frame = Window(None, "Untitled - Codepad")
frame.Show()
app.MainLoop()
