コード例 #1
0
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
コード例 #2
0
ファイル: File3.py プロジェクト: hernejj/vizigrep
    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]
コード例 #3
0
	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()
コード例 #4
0
ファイル: __init__.py プロジェクト: ze-phyr-us/galene
def init(config, files):
	window = Window(config)
	
	if len(files):
		window.open(files[0]) # We open no more than one file.

	window.show()
コード例 #5
0
ファイル: Main.py プロジェクト: marbibu/myCad
 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()
コード例 #6
0
 def __init__(self): 
     self.wdg = 'wdgCamera'
     self.threads = []
     Window.show(self)
     img = self.get_wdg('imgCamera')
     self.update = UpdateImg(img)
     self.update.start()
コード例 #7
0
ファイル: Config_bak.py プロジェクト: jpaasen/cos
   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
コード例 #8
0
ファイル: Window_result.py プロジェクト: Ziranium/oradmin
	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("[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)
コード例 #9
0
ファイル: Dropdown.py プロジェクト: YivDev/illumina
	def __init__(self, layer = "UI"):
		Window.__init__(self, layer)

		self.__isExpanded = True

		self.__elements = {}

		self.__CreateUI()
コード例 #10
0
ファイル: Slider.py プロジェクト: YivDev/illumina
	def __init__(self, layer = "UI"):
		Window.__init__(self, layer)

		self.__maxValue = 1
		self.__curValue = 0
		self.__doMove = False

		self.__CreateUI()
コード例 #11
0
    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)
コード例 #12
0
    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)
コード例 #13
0
ファイル: RangeSlider.py プロジェクト: YivDev/illumina
	def __init__(self, layer = "UI"):
		Window.__init__(self, layer)

		self.__maxValue = 1
		self.__curValues = []
		self.__rangeSliderWidth = 0
		self.__doMove = False

		self.__CreateUI()
コード例 #14
0
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
コード例 #15
0
ファイル: Code.py プロジェクト: resturp/Symilar
 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   
コード例 #16
0
ファイル: Button.py プロジェクト: YivDev/illumina
	def __init__(self, layer = "UI"):
		Window.__init__(self, layer)

		self.__state = _ButtonState.NORMAL

		self.__CreateUI()
		self._SetEventListeners()

		self.SetWidth(0)
		self.SetState(_ButtonState.NORMAL)
コード例 #17
0
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()
コード例 #18
0
 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)
コード例 #19
0
ファイル: Expander.py プロジェクト: YivDev/illumina
	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)
コード例 #20
0
    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
コード例 #21
0
    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()
コード例 #22
0
 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
コード例 #23
0
ファイル: Menu.py プロジェクト: ospaceteam/outerspace
 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")
コード例 #24
0
ファイル: sim1.py プロジェクト: NBXApp/FPGA-Imaging-Library
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
コード例 #25
0
ファイル: Menu.py プロジェクト: mozts2005/OuterSpace
	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)
コード例 #26
0
ファイル: sim1.py プロジェクト: NBXApp/FPGA-Imaging-Library
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
コード例 #27
0
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)
コード例 #28
0
ファイル: Game.py プロジェクト: duanduan2015/Termine
 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
コード例 #29
0
ファイル: MultiStreamer.py プロジェクト: hucome/MDSMiner
    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
コード例 #30
0
ファイル: SingleStreamer.py プロジェクト: hucome/MDSMiner
    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
コード例 #31
0
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
コード例 #32
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
コード例 #33
0
ファイル: EMV_Tags.py プロジェクト: feoc10/EMV_Tags
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)
コード例 #34
0
import wx
from Window import Window

if __name__ == "__main__":

    app = wx.App()
    wnd = Window(None, "Поиск строк")
    app.MainLoop()
コード例 #35
0
import sys
from Window import Window
from PyQt5.QtWidgets import *

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = Window()
    window.show()
    app.exec_()
コード例 #36
0
ファイル: main.py プロジェクト: henkeldi/camera_calibration
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, ())
コード例 #37
0
ファイル: AnimatedImageBox.py プロジェクト: YivDev/illumina
 def __init__(self, layer="UI"):
     Window.__init__(self, layer)
コード例 #38
0
from tkinter import *
from Window import Window

if __name__ == '__main__':
    root = Tk()

    app = Window(root)

    root.resizable(False, False)
    root.mainloop()
コード例 #39
0
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()
コード例 #40
0
ファイル: main.py プロジェクト: sergey-judi/opengl-python
from Window import Window

if __name__ == '__main__':
    window = Window(512, 512, 'Lab2 Sergey Pereyaslavskiy')
    window.show()
コード例 #41
0
ファイル: index.py プロジェクト: Comcarus/dicometer
from Window import Window
from tkinter import Tk

root = Tk()
win = Window(root)
root.mainloop()
コード例 #42
0
ファイル: main.py プロジェクト: sandruskyi/SUMO_DEMOS
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()
コード例 #43
0
from Window import Window

window = Window()
window.start()
コード例 #44
0
ファイル: Game.py プロジェクト: JacobMaughan/depth
 def __init__(self):
     pygame.init()
     self.window = Window(1280, 760, 'Depth', './assets/player/Wizard.png')
     self.running = None
     self.gameStateHandler = GameStateHandler(self.window, self)
コード例 #45
0
"""
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
コード例 #46
0
#!/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()
コード例 #47
0
    def __init__(self, layer="UI"):
        Window.__init__(self, layer)

        self.liButtons = []
        self.__selectedIndex = 0
コード例 #48
0
ファイル: main.py プロジェクト: paramagnetism/paramagnetism
# -*- 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()
コード例 #49
0
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)
コード例 #50
0
ファイル: TextLine.py プロジェクト: YivDev/illumina
 def __init__(self, layer="UI"):
     Window.__init__(self, layer)
     self.SetFontName("Tahoma:12")  # TODO
コード例 #51
0
ファイル: Main.py プロジェクト: TheComet/wavesim
__author__ = 'thecomet'

import pygame
from Window import Window

if __name__ == '__main__':
    pygame.init()
    window = Window(1280, 720)
    window.enter_main_loop()
    pygame.quit()
コード例 #52
0
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)
コード例 #53
0
    def __del__(self):
        Window.__del__(self)

        del self.liButtons
コード例 #54
0
 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)
コード例 #55
0
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
コード例 #56
0
ファイル: TextLine.py プロジェクト: YivDev/illumina
 def __del__(self):
     Window.__del__(self)
コード例 #57
0
ファイル: Handler.py プロジェクト: RNolioSC/CG-T1-PY
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()
コード例 #58
0
def main():
    app = QApplication(sys.argv)  # 创建QApplication对象获取命令行参数
    window = Window()  # 建立一个新窗口
    window.resize(960, 640)  # 设定窗口大小
    window.show()  # 展示窗口
    sys.exit(app.exec_())  # 退出程序
コード例 #59
0
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
コード例 #60
0
ファイル: main.py プロジェクト: javan9916/Monkey
def main():
    app = wx.App()
    frame = Window(None, "Untitled - Codepad")
    frame.Show()
    app.MainLoop()