def main(): global encodedLine, insCounter, lineCounter, repeatFlag, isC global repeatBuffer, writeRepeat, writeLineFlag, repetitions F = open("asm.txt", "r") try: os.remove("instructionsOut.txt") except: pass F2 = open("instructionsOut.txt", "a+") FLines = F.readlines() #Initializing the state machine m = StateMachine() m.add_state("Start", startState) m.add_state("OperandState", OperandState) m.add_state("regDestState", regDestState) m.add_state("regSrc1State", regSrc1State) m.add_state("immSrc1State", immSrc1State) m.add_state("regSrc2State", regSrc2State) m.add_state("immSrc2State", immSrc2State) m.add_state("doneState", None, end_state=1) m.add_state("ErrorState", ErrorState) m.set_start("Start") print(FLines) line = 1 lineCounter = 1 for l in FLines: print("Instruction") print(lineCounter) print("Line") print(line) print(l) if m.run(l): if writeLineFlag: F2.write(encodedLine + "\r") if repeatFlag: repeatBuffer = repeatBuffer + encodedLine + "\r" if writeRepeat: while repetitions > 0: F2.write(repeatBuffer) repetitions -= 1 writeRepeat = False repeatBuffer = "" encodedLine = "0000000000000000" insCounter = 0 lineCounter += 1 line += 1 writeLineFlag = True isC = False if repeatFlag: print("Repeate cycle not closed") F.close()
newState = "error_state" return (newState, txt) def not_state_transitions(txt): splitted_txt = txt.split(None,1) word, txt = splitted_txt if len(splitted_txt) > 1 else (txt,"") if word in positive_adjectives: newState = "neg_state" elif word in negative_adjectives: newState = "pos_state" else: newState = "error_state" return (newState, txt) def neg_state(txt): print("Hallo") return ("neg_state", "") if __name__== "__main__": m = StateMachine() m.add_state("Start", start_transitions) m.add_state("Python_state", python_state_transitions) m.add_state("is_state", is_state_transitions) m.add_state("not_state", not_state_transitions) m.add_state("neg_state", None, end_state=1) m.add_state("pos_state", None, end_state=1) m.add_state("error_state", None, end_state=1) m.set_start("Start") m.run("Python is great") m.run("Python is difficult") m.run("Perl is ugly")
def first_window_attempt(): """ The first attempt at creating a gui. :return None: """ class InitialState(BaseState): """ Initial state for the SimpleGUI. """ def _on_enter(self, gui): """ Construct the buttons upon entering the state. :return: """ print("In initial state.") '''Create label''' self.label = tk.Label(gui.root, text="First GUI") self.label.pack() '''Create buttons''' gui.pack_button = tk.Button(gui.root, text="Buttons", command=self.adjust_buttons(gui), font=Font(size=50)) gui.pack_button.pack() gui.greet_button = tk.Button(gui.root, text="Greet", command=self._greet, font=Font(size=50)) gui.close_button = tk.Button(gui.root, text="Close", command=gui.root.quit, font=Font(size=50)) gui.update() def adjust_buttons(self, gui): """ Adjust the buttons. :return: """ def _adjust_buttons(): print("\tButton clicked.") if gui.buttons_on.get(): print("\t\tDetected buttons are on.") self._remove_buttons(gui) else: print("\t\tDetected buttons are off.") self._add_buttons(gui) return _adjust_buttons def _add_buttons(self, gui): """ Add buttons to the view. :return: """ gui.greet_button.pack() gui.close_button.pack() gui.buttons_on.set(True) def _remove_buttons(self, gui): """ Remove buttons from the view. :return: """ gui.greet_button.pack_forget() gui.close_button.pack_forget() gui.buttons_on.set(False) def _greet(self, gui): """ :param gui: :return: """ def _on_exit(self, gui): """ Return the next state. :param gui: :return: """ gui.update() return ButtonsOff() class ButtonsOn(BaseState): """ State for having buttons on. """ def _on_enter(self, gui): """ :param gui: :return: """ print("In buttons on state.") def _state_main(self, gui): """ The main code for the ButtonsOn state. :param gui: :return: """ gui.pack_button.wait_variable(gui.buttons_on) def _on_exit(self, gui): if gui.program_running: gui.update() return ButtonsOff() else: return None class ButtonsOff(BaseState): """ State for having buttons off. """ def _on_enter(self, gui): """ :param gui: :return: """ print("In buttons off state.") def _state_main(self, gui): """ The main code for the ButtonsOn state. :param gui: :return: """ gui.pack_button.wait_variable(gui.buttons_on) def _on_exit(self, gui): if gui.program_running: gui.update() return ButtonsOn() else: return None class SimpleGUI: """ Object for a simple gui. """ def __init__(self, root): """ Initializing the SimpleGUI object. """ self.root = root w, h = root.winfo_screenwidth(), self.root.winfo_screenheight() self.root.geometry("%dx%d+0+0" % (w, h)) self.root.protocol("WM_DELETE_WINDOW", self.end_program) self.buttons_on = tk.BooleanVar() self.buttons_on.set(False) self.program_running = True def update(self): """ Update the GUI. :return: """ self.root.update_idletasks() self.root.update() return self.root def end_program(self): """ Ends the program. :return: """ self.buttons_on.set(not self.buttons_on.get()) self.root.destroy() self.program_running = False '''Initialize and run GUI object''' root = tk.Tk() # Maximize window while maintaining title bar gui = SimpleGUI(root) state_machine = StateMachine(initial_state=InitialState()) state_machine.run(gui)
def drag_and_drop_attempt(): """ The first attempt at creating a gui. :return None: """ class InitialState(BaseState): """ Initial state for the SimpleGUI. """ def _on_enter(self, gui): """ Construct the buttons upon entering the state. :return: """ print("In initial state.") '''Create drag and drop window''' gui.entry_sv = tk.StringVar() gui.drop_box_list = [] gui.drop_box_items = tk.Listbox(master=gui.root, listvariable=gui.drop_box_list) gui.drop_box_text = tk.StringVar() gui.drop_box_text.set("Drop images here") gui.entry = tk.Entry(gui.root, textvar=gui.drop_box_text, justify='center') gui.entry.config(font=("Courier", 44)) gui.entry.place(x=200, y=200, width=800, height=800) #gui.entry.pack() gui.entry.drop_target_register(DND_FILES) gui.entry.dnd_bind('<<Drop>>', self.drop(gui)) gui.update() def _on_exit(self, gui): """ Return the next state. :param gui: :return: """ gui.update() return WaitForDrop() def drop(self, gui): def _drop(event): files = root.tk.splitlist(event.data) gui.entry_sv.set(files) return _drop class WaitForDrop(BaseState): """ State for having buttons on. """ def _on_enter(self, gui): """ :param gui: :return: """ print("In wait for drop state.") def _state_main(self, gui): """ The main code for the ButtonsOn state. :param gui: :return: """ gui.entry.wait_variable(gui.entry_sv) '''Clean string''' files = literal_eval(gui.entry_sv.get()) '''Remove previous images''' if hasattr(gui, "panel"): gui.panel.destroy() '''Load each image''' for file_name in files: file_name = file_name.replace("{", "").replace("}", "") # image = tk.PhotoImage(file=file_name) if ".CR2" in file_name: '''Rawpy implementation''' file_image = rawpy.imread(file_name) file_image = file_image.postprocess() '''Rawkit implementation''' '''file_image = Raw(file_name) file_image = np.array(file_image.to_buffer())''' '''OpenCV implementation''' '''file_image = cv2.imread(file_name)''' else: file_image = Image.open(file_name) '''image = file_image.resize((500, 500), Image.ANTIALIAS) image = ImageTk.PhotoImage(image) gui.panel = tk.Label(gui.root, image=image) gui.panel.image = image gui.panel.pack()''' # panel.grid(row=2) image_data = np.array(file_image) image_data = cv2.cvtColor(image_data, cv2.COLOR_RGB2GRAY) '''print(image_data.shape) print(image_data) print(len(image_data)) print(len(image_data[0]))''' returned_image = Image.fromarray(image_data) '''cv2.imshow("Gray", image_data) cv2.waitKey() cv2.destroyWindow("Gray")''' '''enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(file_image)) enhanced_image = enhanced_contrast.enhance(255) enhanced_data = np.array(enhanced_image) plot_functions.imshow(enhanced_image) plot_functions.show()''' # color_space = cv2.cvtColor(image_data, cv2.COLOR_RGB2HSV) # print(color_space) '''Create mask for white-ish pixels''' '''lower_background = np.array([150, 150, 150]) upper_background = np.array([255, 255, 255]) print(image_data) white_mask = cv2.inRange(image_data, lower_background, upper_background) white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_OPEN, np.ones((3,3),np.uint8)) white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8)) white_mask = white_mask / 255''' '''Create mask for black-ish pixels''' '''lower_background = np.array([0, 0, 0]) upper_background = np.array([25, 25, 25]) black_mask = cv2.inRange(image_data, lower_background, upper_background) black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8)) black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8)) black_mask = black_mask / 255''' '''Add masks together''' '''background_mask = white_mask # Ensure no value is above 1 background_mask = np.clip(background_mask, 0, 1)''' copied_image_data = np.asarray(returned_image).copy() # background_mask = np.logical_not(background_mask) '''for row_index, [mask_row, image_row] in enumerate(zip(background_mask, copied_image_data)): # place black pixel on corresponding masked pixels # copied_image_data[row_index] = np.array([image_row[pixel] * int(mask_row[pixel]) for pixel in range(len(mask_row))]) # make pixel fully white on corresponding masked pixels copied_image_data[row_index] = np.array([np.array([255, 255, 255]) if int(mask_row[pixel]) else image_row[pixel] for pixel in range(len(mask_row))])''' '''Turn removed pixels red''' '''mask_image = Image.fromarray(copied_image_data) plot_functions.imshow(mask_image) plot_functions.show()''' trapezoid_data = copied_image_data.copy() enhanced_contrast = ImageEnhance.Contrast( Image.fromarray(trapezoid_data)) enhanced_image = enhanced_contrast.enhance(255) trapezoid_data = np.array(enhanced_image) '''Detect lines''' edges = cv2.Canny(trapezoid_data, 75, 150) lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 100, maxLineGap=1000) # print(lines) for line in lines: x1, y1, x2, y2 = line[0] if y1 == y2: cv2.line(copied_image_data, (x1, y1), (x2, y2), (255, 255, 255), 1) '''Trapezoid attempt''' # filters image bilaterally and displays it bilatImg = cv2.bilateralFilter(trapezoid_data, 5, 175, 175) # finds edges of bilaterally filtered image and displays it edgeImg = cv2.Canny(bilatImg, 75, 200) # gets contours (outlines) for shapes and sorts from largest area to smallest area contours, hierarchy = cv2.findContours(edgeImg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) contours = sorted(contours, key=cv2.contourArea, reverse=True) # drawing red contours on the image for con in contours: cv2.drawContours(trapezoid_data, con, -1, (255, 255, 255), 3) '''Detect corners''' dst = cv2.cornerHarris(edges, 30, 31, 0.001) dst = cv2.dilate(dst, None) ret, dst = cv2.threshold(dst, 0.01 * dst.max(), 255, 0) dst = np.uint8(dst) # find centroids ret, labels, stats, centroids = cv2.connectedComponentsWithStats( dst) # define the criteria to stop and refine the corners criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.001) corners = cv2.cornerSubPix(edges, np.float32(centroids), (5, 5), (-1, -1), criteria) good_corners = [] for corner in corners: if (corner[1] < 1000) & (corner[1] > 650) & ( corner[0] > 250) & (corner[0] < 2250): good_corners.append(corner) cv2.circle(edges, (corner[0], corner[1]), 10, (255, 255, 255)) print(good_corners) if len(good_corners) >= 3: corner_combos = itertools.combinations(good_corners, 3) elif len(good_corners) > 1: corner_combos = itertools.combinations(good_corners, 2) best_corner_combo = None best_coef = np.inf for corner_combo in corner_combos: regression = LinearRegression().fit( np.array([corner[0] for corner in corner_combo]).reshape(-1, 1), np.array([corner[1] for corner in corner_combo])) if np.abs(regression.coef_) < best_coef: best_coef = np.abs(regression.coef_) best_corner_combo = np.array( [corner[1] for corner in corner_combo]) y_edge = int(round(np.mean(best_corner_combo))) edges = edges[y_edge:3000, 200:2200] copied_image_data = copied_image_data[y_edge:2500, 200:2200] trapezoid_data = trapezoid_data[y_edge:2500, 200:2200] # and double-checking the outcome cv2.imshow("linesEdges", edges) cv2.imshow("linesDetected", copied_image_data) cv2.imshow("Contours check", trapezoid_data) cv2.waitKey() cv2.destroyWindow("Contours check") # find the perimeter of the first closed contour perim = cv2.arcLength(contours[0], True) # setting the precision epsilon = 0.02 * perim # approximating the contour with a polygon approxCorners = cv2.approxPolyDP(contours[0], epsilon, True) # check how many vertices has the approximate polygon approxCornersNumber = len(approxCorners) for corners in approxCorners: cv2.circle(trapezoid_data, (corners[0], corners[1]), radius=10, color=(255, 255, 255), thickness=-1) cv2.imshow("Vertex position", trapezoid_data) cv2.waitKey() cv2.destroyWindow("Vertex position") cv2.imshow("linesEdges", edges) cv2.imshow("linesDetected", copied_image_data) cv2.waitKey(0) cv2.destroyAllWindows() def _on_exit(self, gui): if gui.program_running: gui.update() return WaitForDrop() else: return None class DragAndDropGUI: """ Object for a simple gui. """ def __init__(self, root): """ Initializing the SimpleGUI object. """ self.root = root w, h = root.winfo_screenwidth(), self.root.winfo_screenheight() self.root.geometry("%dx%d+0+0" % (w, h)) self.root.protocol("WM_DELETE_WINDOW", self.end_program) self.program_running = True def update(self): """ Update the GUI. :return: """ self.root.update_idletasks() self.root.update() return self.root def end_program(self): """ Ends the program. :return: """ if self.entry_sv.get() != " ": self.entry_sv.set(" ") else: self.entry_sv.set("!") self.root.destroy() self.program_running = False '''Initialize and run GUI object''' root = tkinterdnd2.Tk() # Maximize window while maintaining title bar gui = DragAndDropGUI(root) state_machine = StateMachine(initial_state=InitialState()) state_machine.run(gui)