def didClickSubmitButton(self, event): print(self.imageFilePath) img = img_as_ubyte(io.imread(CLUSTER_IMAGE_FILENAME)) roi_img = spectral_roi.extract_roi(img, gui_checkbox_handlers.getSelectedClusters()) roi_img_filename = "{}.png".format(Helper.generate_random_id()) io.imsave(roi_img_filename, roi_img) Display.show_image(roi_img, roi_img_filename)
def generate_music_list(softlist_xml_list): found_music = [] selected_softlist_xml = None for softlist_xml in softlist_xml_list.findall('softwarelist'): if softlist_xml.attrib['name'] == "vgmplay": selected_softlist_xml = softlist_xml break found_qty = 0 for soft_xml in selected_softlist_xml: item = FilterSoftware.get(soft_xml) if item is None: continue for part_xml in item.get_soft_xml().findall('part'): part_item = Item() part_item.set_soft_xml(item.get_soft_xml()) part_item.set_part_xml(part_xml) found_music.append(part_item) if len(found_music) > found_qty + 1000: found_qty = len(found_music) Display.print_text("Found " + str(len(found_music)) + " musics") return found_music
def get(soft_list_list): global item_list global first_pass if len(item_list) == 0: if first_pass is False and Config.auto_quit is True: return None first_pass = False item_list = CommandGeneratorMusic.generate_music_list(soft_list_list) Display.print_text("Found " + str(len(item_list)) + " musics") time.sleep(1.5) if len(item_list) == 0: return None if Config.linear is True: rand = 0 else: rand = random.randrange(len(item_list)) selected_item = item_list[rand] item_list.pop(rand) print(str(len(item_list)), "softwares left") return selected_item
def __init__(self): """ Creates display and initial menu """ # nothing much to do here yet until display is better self.b = Board() self.d = Display(self.b) self.n = 0 self.forced = False
def display(self): try: return self._display except AttributeError: self._display = Display() self._display.start() return self._display
def parse_what(neurota, com_name, com): if len(com) != 4 or ':' not in com[3]: Tools.syntax_abort(neurota.args, "wrong # of commands in what statement", "what is <attribute> of <topic:table>") elif com[2] != 'of': Tools.syntax_abort(neurota.args, "wrong # of commands in what statement", "what is <attribute> of <topic:table>") else: topic, table = Tools.split_topic(com[3]) attribute = com[1] if topic not in neurota.db.keys(): Tools.display("topic: %s not found!" % Tools.color(topic, "green")) elif table not in neurota.db[topic].keys(): Tools.display("table: %s not found!" % Tools.color(table, "green")) else: found = False ; i = 0 for node in neurota.db[topic][table]: if node.item == attribute: max_len = len(node.item) ; found = True Display.show_node(i, node, max_len, times=False, show_note=True) break i += 1 if not found: Tools.display("%s not found!" % Tools.color(attribute, "green"))
def question(se, question): """ question(search_engine, question) The function to generate result for a question """ # Analyze the question in the query first term = Answer.get_term(question) author_query = Answer.get_query(term, 'author') business_person_query = Answer.get_query(term, 'business_person') # Queries for author and business person author_result = se.get_mql_result(author_query) if author_result is None: print 'Error in author search' return business_person_result = se.get_mql_result(business_person_query) if business_person_result is None: print 'Error in business person search' return # Extract and format the information author_answer = Answer.get_answer(author_result, 'author') business_person_answer = Answer.get_answer(business_person_result, 'business_person') author_answer.extend(business_person_answer) if author_answer is not None and len(author_answer) > 0: author_answer = sorted(author_answer, key=itemgetter(0)) if not question.endswith('?'): question = question + '?' Display.draw_answer(author_answer, question) else: print 'There is no result for \'' + question + '\'!'
def __init__(self): self.display = Display() self.map_player = Map() self.needle = Item("needle", 4, self.map_player) self.map_player.put_item_on_map(self.needle) self.ether = Item("ether", 5, self.map_player) self.map_player.put_item_on_map(self.ether) self.tube = Item("tube", 6, self.map_player) self.map_player.put_item_on_map(self.tube) self.mac_gyver = Player(self.map_player) self.display.load_wall() self.display.load_ground() self.display.load_player_display() self.display.load_jailer() self.display.load_items() self.display.load_font() self.display.refresh(self.map_player, self.mac_gyver) self.display.show_inventory(self.mac_gyver) self.items_in_game = [self.needle, self.ether, self.tube] self.keyboard_list_movements = [ pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT ] self.keyboard_functions = [ self.mac_gyver.move_up, self.mac_gyver.move_down, self.mac_gyver.move_left, self.mac_gyver.move_right ]
def move(self, board, n, newDisplay): """ The main function for this class. Returns the point the AI wants to move in. """ self.updateAll(board, n, newDisplay, -1000) # check for four in a row on both sides move = self.assuredMove() if self.decided: if move == False: print "Chris has been trying to recreate this bug for a while," print "Please get all this info to him if possible." print "Moves: ", self.b.moveList print "Players: ", self.n, self.o print "Move, assured, decided, scared: ", move, self.assured, self.decided, self.scared print "Board:" newD = Display(self.b, [None], [None]) newD.displayShittyBoard() print "Possible moves: ", self.moves return move move = self.weakLookAhead() return move
def extract_roi(img, labels_to_keep=[1, 2]): ''' Given a wheat image, this method returns an image containing only the region of interest. Args: img: input image. labels_to_keep: cluster labels to be kept in image while pixels belonging to clusters besides these ones are removed. Return: roi_img: Input image containing only the region of interest. ''' label_img = segmentation.slic(img, compactness=30, n_segments=6) labels = np.unique(label_img) print(labels) gray = rgb2gray(img) for label in labels: if (label not in labels_to_keep): logicalIndex = (label_img == label) gray[logicalIndex] = 0 Display.show_image(gray) return gray
def infobox(se, query): """ infobox(search_engine, query) The function to generate infobox for the query """ json = se.get_search_result(query) if json is None: print 'Error in search' return info_list = None for element in json: topic_id = element['mid'] topic = se.get_topic_result(topic_id) if topic is None: continue # Parse and analyze the topic # Get out of the loop if the topic is valid # Otherwise, continue to check the next topic title = query.title() info_list = Analyser.build_infobox(topic, title) if len(info_list) > 0: # Nonempty result # print info_list break if info_list is not None and len(info_list) > 0: Display.draw_infobox(info_list) else: print 'There is no result for \'' + query + '\'!'
def __init__(self, id=None, name=None, parent=None): Layout.Vertical.__init__(self, id, name, parent) self.addClass("WebElementActionBox") self.header = self.addChildElement(Display.Label()) self.header.addClass("WebElementActionBoxHeader") self.actions = self.addChildElement(Display.List())
def __init__(self, isDisplay=True): self.__isDisplay = isDisplay if isDisplay: self.display = Display() self.genetic = Genetic() self.tetrisList = [] self.population = [] self.generation = 0
def list_drink(self): drink_items = [] for key in self.items: obj = self.items[key] if type(obj) == type(Drink()): table_row = obj.list_for_table() drink_items.append(table_row) Display.table_to_console(self.table_header(), drink_items)
def onClickPesticide(self): arduinoControl.make_connection() #arduinoControl.kill_weeds() if arduinoControl.no_connection() is None: Display.displayWarning(self, 'Arduino was unable to initialize.') return self.log('Pesticide') arduinoControl.close_connection()
class GFXEngine : """ This class draws the gfx """ def __init__ (self, lll, viewspace, mymap): self.lll = lll self.display = Display () self.viewspace = viewspace self.mymap = mymap self.terrainset = TerrainSet () # Test self.settsurf = Surface () self.settsurf.loadFromFile ("gfx/protosettler.png") self.settsurf.cols = 16 self.settsurf.rows = 16 self.sprites = [] def create_settler(self, x, y): """ Adds a settler to be drawn on the screen at position x, y and returns a reference to this settler. """ sprite = Sprite (self.viewspace, self.settsurf) sprite.x = x sprite.y = y sprite.configAnimation (True, 0, 24, 25) self.sprites.append(sprite) return sprite def tick (self): """ tick() executes all actions which must be done by the GFX-Engine in one Game-Loop-cycle This is: clearing the screen, drawing all objects, showing the new game-frame """ self.display.clear () self.draw () for sprite in self.sprites: sprite.drawToDisplay (self.display) self.display.showFrame () def draw (self): self.drawLandscape () def drawLandscape (self): self.drawTerrain () def drawTerrain (self): self.lll.view.DrawTerrain (self.mymap.terra.asCArray (), self.mymap.mapsize, TRIA_W, TRIA_H, TEX_FACTOR, self.terrainset.asCArray(), self.mymap.getVertarray().asCArray())
def parse_search(neurota, com_name, com): # scan for optional keywords. remove if found. times = Tools.scan_option("times", com) sort = Tools.scan_option("sort", com) if len(com) == 2 and com[0].find(':') != -1: topic, table = Tools.split_topic(com[0]) pattern = com[1] if topic not in neurota.db.keys(): Tools.display("topic: %s not found!" % Tools.color(topic, "green")) else: if table not in neurota.db[topic].keys(): Tools.display("table: %s not found!" % Tools.color(table, "green")) else: search_results = [] # Search title and note of node for search term. # If found, highlight the search pattern. reg = re.compile(pattern, re.IGNORECASE) for node in neurota.db[topic][table]: found_in_node = False # This searches the title of the node. if reg.search(node.item): found_in_node = True node.item = node.item.replace( pattern, Tools.color(pattern, "green")) # This searches the note of the node. i = 0 for i in range(len(node.note)): if reg.search(node.note[i]): found_in_node = True node.note[i] = node.note[i].replace( pattern, Tools.color(pattern, "green")) if found_in_node: search_results.append(node) if len(search_results) == 0: print Tools.display("Search pattern: %s not found in:" % pattern) Display.show_table(topic, table, search_results, sort, times) elif len(com) == 2 and com[0] == 'topics': pattern = com[1] reg = re.compile(pattern, re.IGNORECASE) for k in neurota.db.keys(): if reg.search(k): Display.show_topic(k)
def StringToType(argument): i = 1 t = Display.TypeToString(i) while t is not None: if argument.strip().lower() == t.strip().lower(): return i i += 1 t = Display.TypeToString(i) return None
def show_single_photo(): if PhotoThread.photo_load_threads()[0].is_alive(): Output.debug("PLT is still running. Sleeping 0.5s before trying again.") Display.root().after(500, show_single_photo) return Display.show_single_photo() Output.debug("Display.show_single_photo() returned") Settings.WAIT_FOR_BUTTON_PRESS = True Settings.ON_BUTTON_PRESS = lambda: Settings.main_script.start()
def _checkRoll(roll, key): updRoll = Game.randomRoll() if roll == None else int(roll) if updRoll < 1 or updRoll > 6: Display.error( f'{hl(key)} value {NOT} valid: {updRoll}. Must be between {hl(1)} and {hl(6)}' ) return None else: return updRoll
def elmination(self): for player in self.players: if player.stack == 0: self.players.remove(player) if len(self.players) == 1: self.players[0].justWon = True Display.displayGameState(self) raw_input("Play again?") self.__init__(*newGameParams)
def do_move(self, arg): [player_name, roll1, roll2] = Commands._unpack(arg, 3) player_label = hl(player_name) if player_name in players: roll1 = Commands._checkRoll(roll1, 'roll1') roll2 = Commands._checkRoll(roll2, 'roll2') if roll1 is not None and roll2 is not None: Display.text(Game.action(player_name, roll1, roll2)) else: Display.error(f'Player {player_label} {NOT} found')
def run(self): Output.debug("PhotoLoadThread " + str(self.index) + " starting...") # Load the photo Output.debug("PhotoLoadThread " + str(self.index) + ": Opening...") self.image = Image.open(self.filename) Output.debug("PhotoLoadThread " + str(self.index) + ": Fitting...") self.image = ImageOps.fit(self.image, (Display.image_size(self.fullsize), Display.image_size(self.fullsize))) Output.debug("PhotoLoadThread " + str(self.index) + ": TKing...") images()[self.index] = ImageTk.PhotoImage(self.image) Output.debug("PhotoLoadThread " + str(self.index) + " finished.")
def __init__(self, parent=None): super(self.__class__, self).__init__(parent) self.setupUi(self) self.centerOnScreen() self.BTN_SelFolder.clicked.connect(self.browse_folder) self.BTN_Process.clicked.connect(self.process_folder) self.actionAuthors.triggered.connect(self.show_authors) self.form2 = ProgressClass(self) self.form3 = Display(self) self.magic = magic.open(magic.MAGIC_MIME) self.magic.load()
def __init__(self): self.square = Square(SQUARE_X, SQUARE_Y, SQUARE_HEIGHT, SQUARE_WIDTH, [0, 0], SQUARE_SPEED) self.missiles = [] self.display = Display(SCREEN_WIDTH, SCREEN_HEIGHT) self.done_game = True self.done_all = False self.time_between_missiles = TIME_BETWEEN_MISSILES self.time_last_missile = 0 self.score = 0 self.client = Client()
def awardPot(self, winners): potSplit = self.pot / len(winners) potExtra = self.pot % len(winners) for winner in winners: winner.justWon = True Display.displayGameState(self) raw_input("Press ENTER to continue") for winner in winners: winner.justWon = False winner.stack += potSplit choice(winners).stack += potExtra
def load_machine_list(): Display.print_text("Get machines XML") file_name = get_listxml_file_name() if os.path.isfile(file_name) is False: print("Creating", file_name) fd = open(file_name, "w") subprocess.run([Config.mame_binary, '-listxml'], stdout=fd) else: print(file_name, "already exists")
def load_soft_list(): Display.print_text("Get software list XML") file_name = get_softlist_file_name() if os.path.isfile(file_name) is False: print("Creating", file_name) fd = open(file_name, "w") subprocess.run([Config.mame_binary, '-getsoftlist'], stdout=fd) else: print(file_name, "already exists")
def extract_roi(img, labels_to_keep=[1,2]): label_img = segmentation.slic(img, compactness=30, n_segments=6) labels = np.unique(label_img);print(labels) gray = rgb2gray(img); for label in labels: if(label not in labels_to_keep): logicalIndex = (label_img == label) gray[logicalIndex] = 0; Display.show_image(gray) io.imsave("grayy.png", gray)
def __init__(self, id, name=None, parent=None): Layout.Vertical.__init__(self, id, name, parent=parent) self.inputContainer = self.addChildElement(Layout.Horizontal()) self.label = self.inputContainer.addChildElement(Display.Label()) self.fieldActions = self.inputContainer.addChildElement(Layout.Box()) self.addChildElementsTo = self.fieldActions self.userInput = self.inputContainer.addChildElement(Base.Invalid()) errorContainer = self.addChildElement(Layout.Horizontal()) self.formError = errorContainer.addChildElement( Display.FormError(id, parent=self))
def loose_search_machine_list(machine_list): new_machine_list = [] for desc in Config.description: found_qty = 2 for machine in machine_list: if exact_search_machine(machine, desc) is True: found_machine = machine found_qty = 1 break # Trying to find a single machine matching the most word in Config.description desc_list = desc.split(' ') word_qty = 0 while found_qty > 1: # Build a search string from words in Config.description starting from last word and adding the previous one by one. word_qty += 1 if word_qty > len(desc_list): # Unable to find a single machine corresponding to all words in Config.description found_qty = 0 break # s = ".*" s = "" for j in range(-word_qty, 0): s += desc_list[j] s += ' ' # remove last ' ' search_string = s[:-1] found_qty = 0 for machine in machine_list: if loose_search_machine(machine, search_string) is True: found_qty += 1 found_machine = machine if found_qty > 1: break if found_qty == 1: new_machine_list.append(found_machine) Display.print_text("Loose search find " + str(len(new_machine_list)) + " machines") else: print("No loose match for", search_string) return new_machine_list
def newRound(self): self.deck = Deck.Deck() self.activePlayers = list(self.players) for player in self.activePlayers: player.hand = Deck.Hand(self.deck) player.active = True player.playerBet = 0 self.pot = 0 self.activeBet = 0 self.phase = 0 self.community = [] self.roundOver = False Prediction.predictRound(self) Display.displayGameState(self)
def add_next_tetromino(game): """ Attempts to add a new tetromino for a game. If the tetromino cannot be added then the game is over """ global falling_tetrominoes global board new_tetromino = get_next_tetromino(game) falling_tetrominoes.append(new_tetromino) heuristic_queue.append(new_tetromino) if tetromino_collides(new_tetromino, board): return False # Game over add_tetromino_to_display(new_tetromino) Display.update_display(board_display) return True
def __init__(self, id=None, name=None, parent=None): Layout.Vertical.__init__(self, id + "NestedSelect", name, parent) self.groupLabel = self.addChildElement(Display.Label()) self.groupSelect = self.addChildElement(Inputs.Select(id)) self.groupSelect.addJavascriptEvent( 'onclick', CallBack(self, "jsPopulateItemSelect")) self.groupSelect.connect('selectionChanged', None, self, 'updateItems') self.itemLabel = self.addChildElement(Display.Label()) self.itemSelect = self.addChildElement(Inputs.Select(id + "Items")) self.groups = [] self.items = {}
def onClickWater(self): arduinoControl.make_connection() arduinoControl.ser.flushInput() arduinoControl.flush_read() #arduinoControl.water_cycle() arduinoControl.water() if arduinoControl.no_connection() is None: Display.displayWarning(self, 'Arduino was unable to initialize.') return arduinoControl.wait(1) start = time.time() while time.time() - start < 2: message = arduinoControl.read_message() self.log('Water') arduinoControl.close_connection()
def runSimulation(self): if len(self.networkFrames.getInputNetworks()) > 0: print "Recreating Input Network..." # Set the initial configuration start_frame = self.networkFrames.getInputNetworkAt(0) for iteration in range(self.iterations): print str(iteration+1), focus_frame = start_frame.copy() self.addGraphToSimulatedNetwork(focus_frame) attempt_data_display = Display.display(False) frame_number = 0 while frame_number < len(self.networkFrames.getInputNetworks())-1: rewriting_event = None attempts = 0 while rewriting_event is None: extraction_subgraph = self.extraction.performExtraction(focus_frame) rewriting_event = self.rewriting.performRewriting(extraction_subgraph) attempts += 1 attempt_data_display.addInputValue(attempts) self.networkFrames._decompress(focus_frame, rewriting_event) self.addGraphToSimulatedNetwork(focus_frame) frame_number += 1 self.storeSimulatedNetwork() self.clearSimulatedNetwork() self.UESFrequencyList.append(copy.deepcopy(self.rewriting.getDisplayData())) self.rewriting.resetDataDisplay() print "Done." self.processSimulationData() print "UES Mean BD: " + str(self.UES_BDMean) print "UES Std BD: " + str(self.UES_BDStd) #self.meanNetwork.writeSpecificGraphs("generatedOutputMeanNetwork.graphML", self.meanNetwork.getDecompressedFrames()) ues_display = Display.display(False) ues_display.addInputValues([], self.UESFrequencyList[0].getHistInputData()) ues_display.addExperimentalValues([] ,self.UESMeanFrequencyList) ues_display.UESBarPlot('Unique Extraction Subgraph Comparison', 'Times Selected', 'Subgraph Groups', self.UESMeanFrequencyList, self.UESStdFrequencyList, self.UES_BDMean) self.bhattacharyyaDegreeDisplay.lineGraph("Bhattacharyya Distance - Cumulative Degree Distribution", "Time Step", "Bhattacharyya Distance", multiLine=True) self.cumulativeDegreeDist.lineGraph("Cumulative Degree Distribution", "Degree (d)", "P(x >= d)") self.densityDisplay.lineGraph("Graph Density", "Time Step", "Graph Density", legloc="upper right", multiLine=True) self.avgShortestPathDisplay.lineGraph("Average Shortest Path Length", "Time Step", "Avg. Shortest Path", multiLine=True) self.avgClusteringDisplay.lineGraph("Average Clustering", "Time Step", "Average Clustering", legloc= "upper right", multiLine=True)
def init(script_to_run): """Initializes the photo booth.""" global filename_schema, photo_thread check_things() filename_schema = "photos/this-should-not-happen---{}.jpg" Settings.main_script = script_to_run Settings.runs = 0 photo_thread = PhotoThread.PhotoThread() GPIO.setmode(GPIO.BOARD) GPIO.setup(Settings.GPIO, GPIO.IN) GPIO.add_event_detect(Settings.GPIO, GPIO.RISING, callback=button_pressed, bouncetime=300) Display.init(lambda: script_to_run.start())
def __init__(self): self.network = NetworkFrames.NetworkFrames() self.subgraphPair = [] self.leftSubgraphs = [] self.rightSubgraphs = [] self.uniqueExtractionSubgraphs = {} self.firstRun = True self.dataDisplay = Display.display(False) self.utility = Utility.utility()
def __init__(self, playerObj, num): self.playerObj = playerObj self.menuObject = None self.maxRooms = num self.currRoomIndex = 0 for i in xrange(0, self.maxRooms): self.listRooms.append(Room(self, Display.returnRandomColor(), random.randint(0,1))) if self.numRooms > 1: self.addRoomToDungeon(self.listRooms[self.numRooms - 1]) for j in xrange(0, self.maxRooms): self.connectNeighboringRooms(self.listRooms[j])
def draw_everything(self): self.display.fill(WHITE) for ship in self.ship_list: self.draw_ship(ship) for bullet in self.bullet_list: self.draw_bullet(bullet) i = 0 while i < len(self.debris): debra = self.debris[i] loc = (debra[0][0] + debra[1][0], debra[0][1] + debra[1][1]) dur = debra[2] - 1 self.debris[i] = (loc, debra[1], dur, debra[3], debra[4], debra[5], debra[6], debra[7]) debra = self.debris[i] Display.draw_circle(self.display, self.camera, debra[7], debra[0], int((debra[6]-debra[2])*debra[3]) + debra[4], debra[5]) if self.debris[i][2]<=0: self.debris.remove(self.debris[i]) else: i+=1 for wall in self.wall_list: self.draw_wall(wall) pygame.display.update()
def draw_ship(self, ship): if not ship.isDead(): Display.draw_triangle(self.display, self.camera, BLACK, ship.location, ship.bounds, ship.direction, 2) if ship.moved: Display.draw_triangle_offset(self.display, self.camera, RED, (ship.location[0], ship.location[1]+ship.bounds[1]*3/2), (ship.bounds[0]/2, ship.bounds[1]/2), ship.direction-180, ship.location, 2) if ship.shield_obj: Display.draw_rect(self.display, self.camera, GREEN, ship.shield_obj, 2)
def next_step(self): Settings.WAIT_FOR_BUTTON_PRESS = False Settings.AFTER_ID = None delay, command, additional, target_branch = self.lines[self.line] self.line += 1 if self.line>=len(self.lines): self.line = 0 if command=="text": if target_branch is not None: Settings.ON_BUTTON_PRESS = lambda: target_branch.start() Settings.WAIT_FOR_BUTTON_PRESS = True Display.display_text(additional) elif command=="photo": Output.debug("Photo! Number " + str(additional)) functions.call_photo_thread(additional) elif command=="overview": if target_branch is not None: Settings.ON_BUTTON_PRESS = lambda: target_branch.start() Settings.WAIT_FOR_BUTTON_PRESS = True Display.show_overview() elif command=="clear": Display.clear() elif command=="branch": Display.root().after(delay, lambda: target_branch.start()) return elif command=="wait": Settings.ON_BUTTON_PRESS = self.next_step Settings.WAIT_FOR_BUTTON_PRESS = True return elif command=="init_run": functions.start_run(self) return # check if the next command is a "photo" if self.lines[self.line][1]=="photo": delay = max(delay - Settings.PHOTO_DELAY, 1) if Settings.DEBUG_SHORT_DELAYS: delay = delay / 100 + 1 #Output.debug("Waiting: " + str(delay)) Settings.AFTER_ID = Display.root().after(delay, self.next_step)
def __init__(self): self.inputFrames = [] # List of graphs that have been added during simulation or read in from graphML self.stateName = None # String name of state used in input graph self.processedFrames = [] # List of graphs that the user has added with calculations performed on each frame self.compressedFrames = [] # The compressed list of graphs with the initial graph and the subsequent differences self.extractionSubgraphs = [] # List of LHS (left hand side) subgraphs that turn into the full compressed frame self.decompressedFrames = [] # The uncompressed list of graphs generated from decompressing the compressed frames self.graphML = nx.readwrite.graphml # The internal networkx graphML object self.frameKey = 0 # The frame key used to created unique graph id's for the inputNetwork graphs self.compressedFrameKey = 0 # The frame key used to created unique graph id's for the compressed graphs self.decompressedFrameKey = 0 # The frame key used to created unique graph id's for the decompressed graphs self.processedFrameKey = 0 # The frame key used to create unique graph id's for the processed graphs self.extractionSubgraphKey = 0 # The subgraph key used to create unique graph id's for the extraction subgraphs self.nodesAddedWhenEdgesData = Display.display(False)
def __init__ (self, lll, viewspace, mymap): self.lll = lll self.display = Display () self.viewspace = viewspace self.mymap = mymap self.terrainset = TerrainSet () # Test self.settsurf = Surface () self.settsurf.loadFromFile ("gfx/protosettler.png") self.settsurf.cols = 16 self.settsurf.rows = 16 self.sprites = []
def __init__(self): self.network = NetworkFrames.NetworkFrames() self.util = Utility.utility() self.prev_extraction = Extraction.Extraction() self.rewriting = Rewriting.Rewriting() self.sample_num = 0 self.sample_motifs = [] self.extractionMap = [] self.extractionPool = {} self.gtrieExtractionPool = {} self.proportionalSelection = [] self.display = Display.display() self.gtrie = GTrie.GTrie() self.gtrie.createGTrieWithFour() self.simulationgtrie = GTrie.GTrie() self.usedRewritingRules = {} self.avg_changes = 0.
def __init__(self, extraction, rewriting, utility, networkFrames): self.iterations = 1 self. extraction = extraction self.rewriting = rewriting self.utility = utility self.networkFrames = networkFrames self.avgShortestPathDisplay = Display.display(True) self.densityDisplay = Display.display(True) self.nodesDisplay = Display.display(True) self.edgesDisplay = Display.display(True) self.avgClusteringDisplay = Display.display(True) self.cumulativeDegreeDist = Display.display(True) self.bhattacharyyaDegreeDisplay = Display.display() self.simulationNetwork = [] self.simulationNetworkList = [] self.UESFrequencyList = [] self.UESMeanFrequencyList = [] self.UESStdFrequencyList = [] self.UES_BDList = [] self.AttemptList = [] self.BDMeanIndex = 0 self.UES_BDMean = 0. self.UES_BDStd = 0. self.simulationInputKey = 0
def _analyse(ui, fileUrls, algorithm): global output if len(fileUrls)!=0: algorithmClass= _loadAlgorithmClass(algorithmsFolder,algorithm)() if len(str(ui.qwtPlot.title().text()))==0: ui.curveX, ui.curveY = preparePlot(ui, algorithm) for fileUrl in fileUrls: print fileUrl video, i,j = cv2.VideoCapture(fileUrl), 0,0 ret, frame = video.read() algorithmClass._initiateRegisters(frame) display1 = Display(ui.label_17) display2 = Display(ui.label_18) display3 = Display(ui.label_7) avaragePeriod, outlierDistance = ui.spinBox.value(), ui.spinBox_2.value() opencvPreview = ui.checkBox_2.isChecked() ui.resultDict = {} while ret: display1.display(frame) algorithmClass.analyze(frame, avaragePeriod) display2.display(algorithmClass.processedFrame) frame2= algorithmClass.processedFrame if not opencvPreview: frame2 = np.zeros((100,100,3), dtype=np.uint8) cv2.imshow("raw preview ", frame2) if 0xFF & cv2.waitKey(5) == 27: break ret, frame = video.read() if i%ui.spinBox.value()==0 and i>0: ui.resultDict = algorithmClass.getResultDict(i, outlierDistance) output.append(ui.resultDict) #print "output len ", sys.getsizeof(output) if j==0: printAlgorithmResultsKeys(ui, j) j+=1 i+=1 video.release()
config = Config.getConfig() protocol = config.getString("login", "protocol") #init the protocol we are going to use Protocol.initProtocol( protocol ) protocol = Protocol.getProtocol() #first get the cookie and id's nick = config.getString( "login", "username" ) passwd = config.getString( "login", "password" ) events = Events.getEvents() events.addListener( Display.getDisplay() ) events.addListener( SpamFilter.getInstance() ) #create the socket sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM ) sock.settimeout( 120.0 ) chatserver = config.getString( "login", "chatserver" ) chatport = config.getInt( "login", "chatport" ) #recreate the acl? if sys.argv.count( "-newacl" ): os.unlink( Acl.ACLFILE ) chatRoom = config.getString( "login", "chatroom" )
class Shift: # Define wPi GPIO SER = 0 # Valeur RCLK = 0 # Validateur SRCLK = 0 # Suivant display = 0 leds = [Led(), Led(), Led(), Led(), Led()] array = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]] def __init__(self, SER = 7, RCLK = 9, SRCLK = 8): #def __init__(self, SER = 1, RCLK = 16, SRCLK = 15): self.SER = SER self.RCLK = RCLK self.SRCLK = SRCLK wPi.wiringPiSetup() wPi.pinMode(self.SER, OUT) wPi.pinMode(self.RCLK, OUT) wPi.pinMode(self.SRCLK, OUT) self.loadDisplay() self.loadLeds() #self.leds = [0, 0, 0, 0, 0] ## LOADING ## def loadLeds(self): self.leds = [Led(), Led(), Led(), Led(), Led()] print "Leds initialized!" def loadDisplay(self): self.display = Display() self.clearDisplay() print "Display initialized!" def addLed(self, position, led): self.leds[position] = led ## SETTING LEDs COLORS ## ## One LED ## def setLedColor(self, led, color, state): if color == 'r' or color == 'red': self.setLedR(led, state) elif color == 'g' or color == 'green': self.setLedG(led, state) elif color == 'b' or color == 'blue': self.setLedB(led, state) def setLedColors(self, led, r, g, b): self.leds[led].setColors(r, g, b) def setLedR(self, led, r): self.leds[led].setR(r) def setLedG(self, led, g): self.leds[led].setG(g) def setLedB(self, led, b): self.leds[led].setB(b) def toggleLed(self, led): self.leds[led].toggleAll() def toggleLedColor(self, led, color): self.leds[led].toggleColor(color) self.apply() def applyLedColors(self, led): self.array[led] = self.leds[led].getColors() ## All LEDs ## def setLedsColors(self, r, g, b): for i in range(0, 5): self.leds[i].setColors(r, g, b) def setLedsR(self, state): for i in range(0, 5): self.leds[i].setR(state) def setLedsG(self, state): for i in range(0, 5): self.leds[i].setG(state) def setLedsB(self, state): for i in range(0, 5): self.leds[i].setB(state) def toggleLeds(self): for i in range(0, 5): self.leds[i].toggleAll() def toggleLedsColor(self, color): for i in range(0, 5): self.leds[i].toggleColor(color) def applyLedsColors(self): for i in range(0, 5): self.array[4-i] = list(self.leds[i].getColors()) ## SETTING DISPLAY ## def setNumber(self, x): self.array[5] = self.display.getNumber(x) if self.array == 0: print "Nombre saisi incorrect!" def setNumbers(self): return self.display.getNbSelected() def clearDisplaye(self): self.array[5] = self.display.clear() ## APPLY CHANGE ## def apply(self): wPi.digitalWrite(self.RCLK, DOWN) for j in reversed(self.array[5]): wPi.digitalWrite(self.SRCLK, DOWN) wPi.digitalWrite(self.SER, j) wPi.digitalWrite(self.SRCLK, UP) for i in range(0, 5): for j in reversed(self.array[i]): wPi.digitalWrite(self.SRCLK, DOWN) wPi.digitalWrite(self.SER, j) wPi.digitalWrite(self.SRCLK, UP) wPi.digitalWrite(self.RCLK, UP) ## CLEAR ## def clearDisplay(self): for i in range(0, 6): wPi.digitalWrite(self.RCLK, DOWN) for j in reversed(self.array[i]): wPi.digitalWrite(self.SRCLK, DOWN) wPi.digitalWrite(self.SER, DOWN) wPi.digitalWrite(self.SRCLK, UP) # print j, wPi.digitalWrite(self.RCLK, UP) #print "" print "Display cleaned!" def clearData(self): for i in range(0, 6): for j in reversed(self.array[i]): self.array[i][j] = 0 print "Data cleaned!" ## LOADINGS EFFETCS ## def loading(self, color): self.setLedColor(0, color, 1) self.applyLedsColors() self.apply() sleep(0.2) self.setLedColor(1, color, 1) self.applyLedsColors() self.apply() sleep(0.2) self.setLedColor(0, color, 0) self.setLedColor(2, color, 1) self.applyLedsColors() self.apply() sleep(0.2) self.setLedColor(1, color, 0) self.setLedColor(3, color, 1) self.applyLedsColors() self.apply() sleep(0.2) self.setLedColor(2, color, 0) self.setLedColor(4, color, 1) self.applyLedsColors() self.apply() sleep(0.2) self.setLedColor(3, color, 0) self.applyLedsColors() self.apply() sleep(0.2) self.setLedColor(4, color, 0) self.applyLedsColors() self.apply() sleep(0.2) def trimble(self): #self.clearData() #self.apply() color = ['r', 'g', 'b'] for i in range(0, 3): print 'Set ' + str(0) + ' to ' + str(1) print '' self.setLedColor(0, color[i], 1) self.setNumber(randint(0, 6)) self.applyLedsColors() self.apply() sleep(0.1) self.setNumber(randint(0, 6)) self.apply() sleep(0.1) print 'Set ' + str(1) + ' to ' + str(1) print '' self.toggleLedColor(1, color[i]) self.setNumber(randint(0, 6)) self.applyLedsColors() self.apply() sleep(0.1) self.setNumber(randint(0, 6)) self.apply() sleep(0.1) for j in range(2, 5): print 'Set ' + str(j-2) + ' to ' + str(0) print 'Set ' + str(j) + ' to ' + str(1) print '' self.toggleLedColor(j-2, color[i]) self.toggleLedColor(j, color[i]) self.setNumber(randint(0, 6)) self.applyLedsColors() self.apply() sleep(0.1) self.setNumber(randint(0, 6)) self.apply() sleep(0.1) print 'Set ' + str(3) + ' to ' + str(0) print '' self.toggleLedColor(3, color[i]) self.setNumber(randint(0, 6)) self.applyLedsColors() self.apply() sleep(0.1) self.setNumber(randint(0, 6)) self.apply() sleep(0.1) print 'Set ' + str(4) + ' to ' + str(0) self.toggleLedColor(4, color[i]) self.setNumber(randint(0, 6)) self.applyLedsColors() self.apply() sleep(0.1) #
def send( self, sock ): """override send to display the pm""" Packet.send( self, sock ) Display.getDisplay().pmTo( self.destination, self.statement )
def loadDisplay(self): self.display = Display() self.clearDisplay() print "Display initialized!"
import Display import pygame pygame.init() screen = Display.pywindow(500, 500, 'Snake', 'None', backColor = (0,0,255)) screen.updateSysstat() screen.updateScreen() thing = Display.gameObject(True, False, 10, 10, 0, 0, 'minecraft_icon.bmp',(0,0,0)) while True: screen.update()
def test_backlight(): say('testing backlight') Display.set_cursor_position(0,2) Display.write('Backlight ') Display.rgb(255,0,0) time.sleep(1) Display.rgb(0,255,0) time.sleep(1) Display.rgb(0,0,255) time.sleep(1) for i in range(0, 360): Display.hue(i/360.0) time.sleep(0.01) for i in range(0, 360): Display.sweep(i/360.0) time.sleep(0.01) Display.rgb(255,255,255) Display.set_cursor_position(0,2) Display.write(' ')
def test_lights(): say('Testing lights') Display.set_cursor_position(0,2) Display.write('Lights ') say('Lamp 0 on') Display.set_cursor_position(0,2) Display.write('Lamp 0 On ') Lights.set_lamp(0, 1) time.sleep(3) say('Lamp 1 on') Display.set_cursor_position(0,2) Display.write('Lamp 1 On ') Lights.set_lamp(1, 1) time.sleep(3) say('Lamp 2 on') Display.set_cursor_position(0,2) Display.write('Lamp 2 On ') Lights.set_lamp(2, 1) time.sleep(3) say('Lamp 3 on') Display.set_cursor_position(0,2) Display.write('Lamp 3 On ') Lights.set_lamp(3, 1) time.sleep(3) say('Lamp 0 off') Display.set_cursor_position(0,2) Display.write('Lamp 0 Off ') Lights.set_lamp(0, 0) say('Lamp 1 off') Display.set_cursor_position(0,2) Display.write('Lamp 1 Off ') Lights.set_lamp(1, 0) say('Lamp 2 off') Display.set_cursor_position(0,2) Display.write('Lamp 2 Off ') Lights.set_lamp(2, 0) say('Lamp 3 off') Display.set_cursor_position(0,2) Display.write('Lamp 3 Off') Lights.set_lamp(3, 0) Display.set_cursor_position(0,2) Display.write(' ')
def generateTrainingSamples(ui): if ui.listWidget_6.count() >0: display1 = Display(ui.label_17) #load the selected algorithms algorithms={}#, samples ={},{} outputTrainingDataName ='' for i in range(ui.listWidget_6.count()): algorithmName = str(ui.listWidget_6.item(i).text().replace('.py','')) algorithm = _loadAlgorithmClass(algorithmsFolder, algorithmName)() algorithms[algorithmName] = algorithm #outputTrainingDataName+=str(algorithmName+'#') period = ui.spinBox.value() #print algorithms trainingSamples, responses =[], [] for key in algorithms.keys(): #iterate through environments for n in range(ui.listWidget_2.count()): environment = str(ui.listWidget_2.item(n).text()) #iterate through environment sample videos filmUrlList = ui.filmSamples[environment] for filmUrl in filmUrlList: print filmUrl video, i = cv2.VideoCapture(filmUrl), 0 ret, frame = video.read() #initiate the analysis algorithms for algorithmName in algorithms.keys(): algorithms[algorithmName]._initiateRegisters(frame) #iterate via frames in a film sample while ret: i += 1 display1.display(frame) #for each algorithm sample =[] #for key in algorithms.keys(): algorithms[key].analyze(frame, period) if i % period==0: #distX, distY = algorithms[key].getDistribution(period) #weightCenter = algorithms[key].getWeightCenter(distX[1], distY[1]) #sample = algorithms[key].getCharacteristicPointsVector() #sample.append(weightCenter[0]) #sample.append(weightCenter[1]) if ui.radioButton_2.isChecked(): sample = np.array(algorithms[key].keyPointsVector).astype(np.float32) #samples[environment].append(sample) else: sample=algorithms[key].keyPointsVector trainingSamples.append(sample) responses.append(n) ret, frame = video.read() if ui.radioButton_2.isChecked(): fileName = 'data/trainingData/'+ key +'.dat' with open(fileName, "w") as f: print "Saved to ", fileName pickle.dump([trainingSamples,responses],f) else: fileName = 'data/trainingData/'+key+ '.txt' with open(fileName, "w") as f: print "Saved to ", fileName f.write(str(trainingSamples)+"\nRESPONSES\n"+str(responses))
def test_bargraph(): say('testing bargraph') Display.set_cursor_position(0,2) Display.write('Bargraph ') for intensity in range (0,100): Display.set_graph(intensity/100.0) time.sleep(.01) for intensity in range (100,0,-1): Display.set_graph(intensity/100.0) time.sleep(.01) Display.set_cursor_position(0,2) Display.write(' ')
def _perform_action(self, action, playerObj, menuObject): if action == MOVE_LEFT: playerObj.moveLeft = True playerObj.direction = 'left' elif action == MOVE_RIGHT: playerObj.moveRight = True playerObj.direction = 'right' elif action == MOVE_DOWN: playerObj.moveDown = True playerObj.direction = 'down' elif action == MOVE_UP: playerObj.moveUp = True playerObj.direction = 'up' elif action == NO_MOVE_LEFT: playerObj.moveLeft = False elif action == NO_MOVE_RIGHT: playerObj.moveRight = False elif action == NO_MOVE_DOWN: playerObj.moveDown = False playerObj.currentWeapon.spriteObj.resetSpriteList() elif action == NO_MOVE_UP: playerObj.moveUp = False elif action == NORMAL_ATTACK: playerObj.isAttacking = 1 elif action == NO_NORMAL_ATTACK: playerObj.isAttacking = 0 elif action == RANGED_ATTACK: if playerObj.arrows > 0: playerObj.arrows -= 1 print "Firing!" playerObj.rangedWeapon.shoot() else: print "No arrows!" elif action == CONTINIOUS_RANGED_ATTACK: if pygame.time.get_ticks() > playerObj.lastFired + 500 and playerObj.arrows > 0: playerObj.rangedWeapon.shoot() playerObj.lastFired = pygame.time.get_ticks() playerObj.arrows -= 1 else: if playerObj.arrows < 1: print "No arrows!" else: print "Notching arrow!" elif action == SWITCH_WEAPON: playerObj.cycleWeapon() elif action == USE_POTION: playerObj.usePotion() elif action == PICKUP_OBJECT: playerObj.pickup = True if functions.playerInventory: playerObj.isTrading = True elif action == NO_PICKUP_OBJECT: playerObj.pickup = False playerObj.isTrading = False elif action == OPEN_MENU: self._log.debug('Opening menu') menuObject.activateText() elif action == PAUSE_GAME: if functions.paused: self._log.debug('Resuming game') functions.paused = False else: self._log.debug('Pausing game') functions.paused = True elif action == TAKE_SCREENSHOT: self._log.info('Taking screenshot') functions.screenshot() elif action == SET_FULLSCREEN: if Display.is_fullscreen: self._log.debug('Exiting fullscreen') Display.resetWindow() Display.is_fullscreen = 0 else: self._log.debug('Entering fullscreen') Display.fullscreen() Display.is_fullscreen = 1 elif action == RESTART_MATCH: self._log.info('Restarting match') playerObj.isDead = True elif action == QUIT_GAME: self._log.info('Quitting game') functions.terminate()
def runMotifSimulation(self, motifSize): if len(self.networkFrames.getInputNetworks()) > 0: print "Recreating Input Network..." # Set the initial configuration self.extraction.generateExtractionTree() startFrame = self.networkFrames.getInputNetworkAt(0) bargraph = Display.display() for iteration in range(self.iterations): print str(iteration+1), focusFrame = startFrame.copy() self.addGraphToSimulatedNetwork(focusFrame) attemptDataDisplay = Display.display(False) motifSizeList = self.extraction.getMotifSizeList() frameNumber = 0 while frameNumber < len(self.networkFrames.getInputNetworks())-1: numchanges = 0 targetchanges = self.networkFrames.getNumberOfChanges(frameNumber+1)/motifSize self.extraction.generateGTrieExtractionPool(focusFrame) self.extraction.clearUsedRewritingRules() self.extraction.resetRewritingRuleExclusionList() self.extraction.generateProportionalSelectionData() self.extraction.generateSampleComparisonData() while self.extraction.getSizeOfExtractionSubgraphGTrieMatch() > 0 and numchanges < targetchanges: rewritingRule = None extractionSubgraph = None while rewritingRule == None: extractionSubgraph = self.extraction.chooseExtractionSubgraphGTrie(focusFrame) rewritingRule = self.extraction.selectRewritingRuleGTrie(extractionSubgraph) if rewritingRule == None: self.extraction.removeExtractionSubgraphGTrieMatch(extractionSubgraph) if self.extraction.getSizeOfExtractionSubgraphGTrieMatch() == 0: break if rewritingRule == None: continue self.extraction.addUsedRewritingRules(rewritingRule) self.networkFrames._decompress(focusFrame, rewritingRule) numchanges += 1 #comparison = self.extraction.getComparisonData() #bargraph.barCompare("Extraction Subgraph Compare", "Extraction Subgraph", "Frequency", comparison[0], comparison[1]) print "Number of changes: " + str(numchanges) self.extraction.displayUsedRewritingRuleGraph() self.addGraphToSimulatedNetwork(focusFrame) frameNumber+=1 self.storeSimulatedNetwork() self.clearSimulatedNetwork() self.UESFrequencyList.append(copy.deepcopy(self.rewriting.getDisplayData())) self.rewriting.resetDataDisplay() print "Done." self.processSimulationData() print "UES Mean BD: " + str(self.UES_BDMean) print "UES Std BD: " + str(self.UES_BDStd) #self.meanNetwork.writeSpecificGraphs("generatedOutputMeanNetwork.graphML", self.meanNetwork.getDecompressedFrames()) UES_Display = Display.display(False) UES_Display.addInputValues([],self.UESFrequencyList[0].getHistInputData()) UES_Display.addExperimentalValues([],self.UESMeanFrequencyList) #UES_Display.UESBarPlot('Unique Extraction Subgraph Comparison', 'Times Selected', 'Subgraph Groups',self.UESMeanFrequencyList, self.UESStdFrequencyList, self.UES_BDMean) self.bhattacharyyaDegreeDisplay.lineGraph("Bhattacharyya Distance - Cumulative Degree Distribution", "Time Step", "Bhattacharyya Distance",multiLine=True) #self.cumulativeDegreeDist.loglogPlot("Cumulative Degree Distribution", "Degree (d)", "P(x >= d)", legloc="upper right",multiLine=False) self.densityDisplay.lineGraph("Graph Density", "Time Step", "Graph Density", legloc="upper right",multiLine=True) self.nodesDisplay.lineGraph("Number of Nodes", "Time Step", "Num Nodes", legloc="upper right", multiLine=True) self.edgesDisplay.lineGraph("Number of Edges","Time Step", "Num Edges", legloc="upper right", multiLine=True) self.avgShortestPathDisplay.lineGraph("Average Shortest Path Length", "Time Step", "Avg. Shortest Path",multiLine=True) self.avgClusteringDisplay.lineGraph("Average Clustering", "Time Step", "Average Clustering",legloc="upper right",multiLine=True)