def init_assignment(ass, name): assignment_dir = dir_name(ass) os.mkdir(assignment_dir) course_dir = config_dir(".", "canvas.yaml") with open(os.path.join(course_dir, "canvas.yaml"), "r") as f: conf = yaml.load(f) course_id = conf['id'] # with open(os.path.join(course_dir, "token"), "r") as f: # api_token = f.read().strip() assignment = Canvas().course(id=course_id).assignment(name=ass) subs = assignment.submissions() # get the ids of the students in # group set <assignment name>, group <instructor name> #members = get_members(name, assignment, course_id, api_token) #student_ids = [m['id'] for m in members] #subs = [sub for sub in subs if sub['user_id'] in student_ids] make_sub_dirs(assignment_dir, subs) return subs
class CreateGUI(tk.Tk): """The main class for the program Instance variables: edof: An noe x 7 array on the form array([[el_1, dof1, dof2...dof6], [el_noe, dof1, dof2...dof6]]) """ def __init__(self): tk.Tk.__init__(self) self.title("Frame 2000") self.state('zoomed') self.iconbitmap('icon_beam_2000.ico') self.resizable(False, False) # Create a list for storing instances of the element class self.element_list = [] # Create a dictionary to store the topology information self.edof = np.empty((0, 7), float) # Create instances of window content self.menubar = Menubar(self) self.canvas = Canvas(self) self.main_menu = MainMenu(self) # Place the instances in the window self.canvas.pack(side="left", fill="both", expand=1, pady=20, padx=20) self.main_menu.pack(side="right", fill=tk.Y, padx=10)
class RenderWin(QMainWindow): def __init__(self, loc, img, w, h, r, parent=None): super(RenderWin, self).__init__(parent) self.parent = parent self.setWindowTitle(" ") self.setGeometry(loc) self.move(parent.x() + parent.width() / 2, parent.y() + parent.height() / 2) self.canvas = Canvas(img, w, h, r, self) self.scrollview = QScrollArea(self) bar_w = self.scrollview.style().subControlRect( QStyle.CC_ScrollBar, QStyleOptionSlider(), QStyle.SC_ScrollBarGroove, self).x() self.scrollview.setWidget(self.canvas) self.setCentralWidget(self.scrollview) default_max_w, default_max_h = 300, 300 self.setFixedSize( QSize(clip(w + bar_w, 0, default_max_w), clip(h + bar_w, 0, default_max_h))) self.setMaximumSize(QSize(w + bar_w, h + bar_w)) self.canvas.update() def closeEvent(self, event): self.parent.on_finish_editing() self.parent.on_child_destroyed() self.canvas.reset_mask() event.accept() self.destroy()
def __init__(self, loc, img, w, h, r, parent=None): super(RenderWin, self).__init__(parent) self.parent = parent self.setWindowTitle(" ") self.setGeometry(loc) self.move(parent.x() + parent.width() / 2, parent.y() + parent.height() / 2) self.canvas = Canvas(img, w, h, r, self) self.scrollview = QScrollArea(self) bar_w = self.scrollview.style().subControlRect( QStyle.CC_ScrollBar, QStyleOptionSlider(), QStyle.SC_ScrollBarGroove, self).x() self.scrollview.setWidget(self.canvas) self.setCentralWidget(self.scrollview) default_max_w, default_max_h = 300, 300 self.setFixedSize( QSize(clip(w + bar_w, 0, default_max_w), clip(h + bar_w, 0, default_max_h))) self.setMaximumSize(QSize(w + bar_w, h + bar_w)) self.canvas.update()
def __init__(self, themefile, styleconfig, activation_event): super().__init__() self.setWindowTitle('fckthms and not in a good way') self.themefile = themefile validate_theme(themefile, styleconfig) activation_event.connect(self.reload_data) layout = QtGui.QHBoxLayout(self) common.kill_theming(layout) paintstack = generate_paintstack(themefile) self.listwidget = ColorList(self, paintstack) self.canvas = Canvas(self, paintstack, self.listwidget.get_color) self.listwidget.request_repaint.connect(self.canvas.update) layout.addWidget(self.canvas, stretch=1) listlayout = QtGui.QVBoxLayout() common.kill_theming(listlayout) listlayout.addWidget(self.listwidget) highlightbtn = QtGui.QPushButton('Highlight items') highlightbtn.setCheckable(True) highlightbtn.toggled.connect(self.listwidget.set_highlight) listlayout.addWidget(highlightbtn) colorbtn = QtGui.QPushButton('Set color') colorbtn.clicked.connect(self.listwidget.set_color) listlayout.addWidget(colorbtn) resetbtn = QtGui.QPushButton('Reset color') resetbtn.clicked.connect(self.listwidget.reset_color) listlayout.addWidget(resetbtn) layout.addLayout(listlayout) self.show()
def initUI(self): QToolTip.setFont(QFont('Lato', 12)) # WINDOW homeWidget = QWidget() self.setCentralWidget(homeWidget) self.resize(800, 600) self.center() self.setWindowTitle('Bezier Program!') self.canvas = Canvas(self) # MENU menuBar = self.menuBar() showLinesMenu = menuBar.addMenu(' ') self.guideBox = QCheckBox('Show guide', self) bezierMenu = menuBar.addMenu('Bezier menu') bezierAction = QAction('Bézier curve', self) bezierMenu.addAction(bezierAction) bezierAction.triggered.connect(self.canvas.addBCurve) self.guideBox.stateChanged.connect(self.canvas.toggleGuide) # AREA DE DESENHO mainLayout = QHBoxLayout() self.canvas.setStyleSheet("QWidget { background-color: %s }" % QColor(255, 255, 255).name()) self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) mainLayout.addWidget(self.canvas) homeWidget.setLayout(mainLayout) self.show()
class MainWidget(QtGui.QScrollArea): """ La clase MainWidget es una derivada de la clase QScrollArea. En este widget se pone, centrado, el lienzo del dibujo (Canvas). Además, éste es el widget alrededor del cual se centra la MainWindow. """ def __init__(self, w, h, image, com, color, Parent=None): super(MainWidget,self).__init__() self.canvas = Canvas(w, h, image, com, color, self) self.setWidget(self.canvas) def resizeEvent(self, event): super(MainWidget,self).resizeEvent(event) self.calcNewCanvasGeometry() def paintEvent(self, event): super(MainWidget,self).paintEvent(event) self.calcNewCanvasGeometry() def calcNewCanvasGeometry(self): g = self.frameGeometry() w = g.width() h = g.height() self.canvas.move( (w-self.canvas.width*self.canvas.zoom)/2, (h-self.canvas.height*self.canvas.zoom)/2 ); print self.frameGeometry()
def __init__(self, master): self.width = int(config['window']['width']) self.height = int(config['window']['height']) self.fps = int(config['frame']['fps']) self.currentScreenID = ScreenID.START self.beforeScreenID = None self.canControl = False self.chatUI = None self.actions = {} self.shot1Image = tkinter.PhotoImage( file='resources/shots/explosive.gif') self.shot2Image = tkinter.PhotoImage(file='resources/shots/fish.gif') self.shot1ID = None self.shot2ID = None self.help = False super().__init__(master=master, width=self.width, height=self.height) self.bind("<Key>", self.key) # listen keyborad self.pack() # create a canvas to draw all item self.canvas = Canvas(self, self.width, self.height) self.startPage() self.focus_set() # focus on this frame self.run() # this function handler all game event logic self.mainloop()
def __init__(self, width=300, height=300): if not glfw.init(): print("Init failed") # This trick borrowed from `cmu_112_graphics` self._callersGlobals = inspect.stack()[1][0].f_globals glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE) self.window = glfw.create_window(width, height, "Hello, world", None, None) glfw.make_context_current(self.window) self.width, self.height = width, height self.timerDelay = 200 self.lastTimer = time.time() glEnable(GL_DEPTH_TEST) glEnable(GL_CULL_FACE) glFrontFace(GL_CW) glEnable(GL_BLEND) self.canvas = Canvas(self.width, self.height) self.run()
def test_unknown_method(self): # EXEC canvas = Canvas() with self.assertRaisesRegex( AttributeError, "(Canvas instance|'Canvas' object) has no attribute 'create_wirple'"): canvas.create_wirple(1, 'floop')
def __init__(self, parent=None): wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = wx.EmptyString, pos = wx.DefaultPosition, size = wx.Size( -1,-1 ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL ) self.SetSizeHintsSz( wx.DefaultSize, wx.DefaultSize ) self.SetBackgroundColour( wx.Colour( 255, 255, 255 ) ) sizer = wx.BoxSizer( wx.VERTICAL ) self.txt_info = wx.StaticText( self, wx.ID_ANY, u'500*500 pixels 173k', wx.DefaultPosition, wx.DefaultSize, 0 ) self.txt_info.Wrap( -1 ) sizer.Add( self.txt_info, 0, wx.ALL, 0 ) self.canvas = Canvas(self) self.canvas.fit = self sizer.Add( self.canvas, 1, wx.EXPAND |wx.ALL, 0 ) self.page = wx.ScrollBar( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.SB_HORIZONTAL) self.page.SetScrollbar(0,0,0,0, refresh=True) sizer.Add( self.page, 0, wx.ALL|wx.EXPAND, 0 ) #self.page.Hide() self.SetSizer(sizer) self.Layout() self.Bind(wx.EVT_IDLE, self.on_idle) self.Bind(wx.EVT_SCROLL_THUMBTRACK, self.on_scroll) self.Bind(wx.EVT_ACTIVATE, self.on_valid) self.Bind(wx.EVT_CLOSE, self.on_close) self.canvas.Bind(wx.EVT_CHAR, self.on_key) self.canvas.SetFocus() # panel.Bind(wx.EVT_CHAR, self.OnKeyDown) self.opage = 0 self.Fit() WindowsManager.add(self)
def run(self): print 'RUNNING' r = lambda: random.randint(0, 255) while True: Canvas.clear() Canvas.draw_rect((0, 0), (200, 200), fill_style='#%02X%02X%02X' % (r(), r(), r())) sleep(random.uniform(0.03, 1))
def init_docks(self): '''初始化的一部分,执行浮动子窗口和canvas的初始化,单列一个函数以提升可读性''' self.database_widget = DatabaseWidget() self.dataset_tree_dock.setWidget(self.database_widget) self.menuView.addAction(self.dataset_tree_dock.toggleViewAction()) self.series_list_widget = SeriesListWidget() self.series_list_dock.setWidget(self.series_list_widget) self.menuView.addAction(self.series_list_dock.toggleViewAction()) self.annotations_list_widget = AnnotationsListWidget() self.annotations_list_dock.setWidget(self.annotations_list_widget) self.menuView.addAction(self.annotations_list_dock.toggleViewAction()) self.label_edit_widget = LabelEditWidget() self.label_edit_dock.setWidget(self.label_edit_widget) self.menuView.addAction(self.label_edit_dock.toggleViewAction()) self.canvas_area = QScrollArea() # TODO: 原理?看了文档还是不懂,需要进行更多研究 self.canvas_area.setWidgetResizable(True) self.scroll_bars = { Qt.Vertical: self.canvas_area.verticalScrollBar(), Qt.Horizontal: self.canvas_area.horizontalScrollBar() } self.canvas_widget = Canvas() self.canvas_area.setWidget(self.canvas_widget) self.setCentralWidget(self.canvas_area)
def __init__(self, cfg_game, screen): # arguments self.cfg_game = cfg_game self.screen = screen # colors self.color_bag = ColorBag() # canvas self.canvas = Canvas(self.screen) # game logic self.game_logic = MenuGameLogic(self) # actual up down click self.ud_click = 0 self.lr_click = 0 # click self.click = False # selection self.button_state = 0 # button dict, selection: button in canvas self.button_state_dict = {'start_button': 0, 'help_button': 1, 'end_button': 2} # set button state self.button_state = self.button_state_dict['start_button']
def main(**args): ventana = Ventana((800, 600)) canvas = Canvas((800, 450), (0, 150)) particula = Particula() canvas.add_particula(particula, 0) ventana.add_canvas(canvas, "0") ventana.run()
def __init__(self): self.gladefile = os.path.join(__location__, "pt3.glade") self.builder = Gtk.Builder() self.builder.add_from_file(self.gladefile) #Create & Link canvas self.canvas_box = self.builder.get_object("canvasBox") self.canvas = Canvas() self.watcher = VarWatcher(self.canvas) self.canvas.show() self.canvas_box.pack_start(self.canvas, True, True, 0) # Automatically connect signals to functions defined above # as specified in the glade file self.builder.connect_signals(self) # Get the main window self.window = self.builder.get_object("ptWindow") self.window.show() self.window.connect("key-press-event", self.key_press) #Ctrl+C handling def handler(signum, frame): self.log.warning("INTERRUPT: exiting gracefully") self.window_destroy() signal.signal(signal.SIGTERM, handler) signal.signal(signal.SIGINT, handler) #Fire up the main window self.log.info("Launching GUI. Welcome to PT3! Press %s for help" % conf.key_binds["help"]) Gtk.main()
def search(): if request.method == "POST": RESULTS_ARRAY = [] # get url f = request.files["img"] f.save(f.filename) image_url = f.filename try: c = Canvas() results = c.search(image_url) for (_, image) in results: RESULTS_ARRAY.append({"image": image}) return jsonify(results=RESULTS_ARRAY[:20]) except: # return error jsonify({"sorry": "Sorry, no results! Please try again."}), 500
def __init__(self,parent,dpi=100.0): Canvas.__init__(self,parent,dpi) self.has_data = False self.sqplot = None self.cb = None self.colormap = customcolormap.make_colormap("mymap", 1.0, 0.001, 10) self.cmaplimits = 2.0
def test_canvas_draw_point(): width, height = 50, 50 canvas = Canvas(width, height) x, y = 2, 3 point = Point(x, y) canvas._draw_point(point) assert canvas.cells[x][y] == (CanvasCellContentType.Line, 'x')
def initUI(self): mainLay = widgets.QVBoxLayout() self.mainLay = mainLay mainLay.setContentsMargins(0, 0, 0, 0) mainLay.setSpacing(0) self.optionslay = widgets.QVBoxLayout() self.optionslay.setContentsMargins(0, 0, 0, 0) self.optionslay.setSpacing(0) self.optionswidget = widgets.QWidget() self.optionswidget.setLayout(self.optionslay) self.optionswidget.setMaximumHeight(220) self.canvas = Canvas() self.canvas.setPointsData(self.pages.getPage()) self.connectCanvas() mainLay.addWidget(self.canvas) self.genHideBar() mainLay.addWidget(self.optionswidget) self.genDoUndoBar() self.genPageBar() self.genSliderGrid() self.generateColorPicker() self.genColorPickerGrid() self.generateStrokeWidthSlider() self.genSaveBar() self.setLayout(mainLay) self.optionswidget.setVisible(not self.optionsHidden) self.setGeometry(300, 300, 800, 600) self.setWindowTitle('Hand Writing Notes') self.show()
def paned_window(self): self.panedwindow = ttk.Panedwindow(self.parent, orient = tk.HORIZONTAL) self.panedwindow.pack(expand = True, fill = tk.BOTH) self.left_pane = ttk.Frame(self.panedwindow, height = root.winfo_screenheight() - 140, relief = tk.SUNKEN) self.middle_pane = ttk.Frame(self.panedwindow, height = (root.winfo_screenheight() - 140), relief = tk.SUNKEN) self.right_pane = ttk.Frame(self.panedwindow, height = (root.winfo_screenheight() - 140), relief = tk.SUNKEN) self.panedwindow.add(self.left_pane, weight = 1) self.panedwindow.add(self.middle_pane, weight = 1) self.panedwindow.add(self.right_pane, weight = 10) self.panedwindow_left = ttk.Panedwindow(self.left_pane, orient = tk.VERTICAL) self.panedwindow_left.pack(expand = True, fill = tk.BOTH) self.pane_projects = ttk.Frame(self.panedwindow_left, height = (root.winfo_screenheight() - 140) / 2, relief = tk.SUNKEN) self.pane_actions = ttk.Frame(self.panedwindow_left, height = (root.winfo_screenheight() - 140) / 2, relief = tk.SUNKEN) self.panedwindow_left.add(self.pane_projects, weight = 1) self.panedwindow_left.add(self.pane_actions, weight = 1) self.panewindow_middle = ttk.PanedWindow(self.middle_pane, orient = tk.VERTICAL) self.panewindow_middle.pack(expand = True, fill = tk.BOTH) self.pane_canvas = ttk.Frame(self.panewindow_middle, relief = tk.SUNKEN) self.pane_resources = ttk.Frame(self.panewindow_middle, width = 100, relief = tk.SUNKEN) self.panewindow_middle.add(self.pane_canvas, weight = 5) self.panewindow_middle.add(self.pane_resources, weight = 1) self.menubar = Menubar(self.parent) self.properties = Properties(self.right_pane) self.canvas = Canvas(self.properties) self.toolbar = Toolbar(self.pane_canvas, self.canvas) self.project_explorer = ProjectExplorer(self.pane_projects) self.canvas.create_Ui(self.pane_canvas) self.actions = Actions(self.pane_actions, self.canvas, self.properties) self.resources = Resources(self.pane_resources)
def __init__(self, parent, *args, **kwargs): tk.Frame.__init__(self, parent, *args, **kwargs) self.parent = parent self.defaultVideoCapture = VideoCapture(0) self.webcamCanvas = Canvas(self.parent, self.defaultVideoCapture) self.maskCanvas = Canvas(self.parent, self.defaultVideoCapture) self.lowHueSlider = Slider(self.parent, "Low Hue", 10, 0, 180) self.highHueSlider = Slider(self.parent, "High Hue", 25, 0, 180) self.lowSaturationSlider = Slider(self.parent, "Low Saturation", 100, 0, 255) self.highSaturationSlider = Slider(self.parent, "High Saturation", 255, 0, 255) self.lowValueSlider = Slider(self.parent, "Low Value", 20, 0, 255) self.highValueSlider = Slider(self.parent, "High Value", 255, 0, 255) self.button = tk.Button(self.parent, text="Get histogram", fg="blue", command=self.drawHSVHHistogram) self.button.pack(anchor=tk.CENTER) self.updateFrame()
def refresh(self): text = self.get_displayed_text() c = Canvas(self.o) self.draw_text(text, c, self.v_scrollbar.width) self.v_scrollbar.draw(c) self.h_scrollbar.draw(c) self.o.display_image(c.get_image())
def refresh(self): self.update_throbber_angle() c = Canvas(self.o) self.draw_throbber(c) if self.message: self.draw_message(c) self.o.display_image(c.get_image())
def test_unknown_method(self): # EXEC canvas = Canvas() with self.assertRaisesRegexp( AttributeError, "(Canvas instance|'Canvas' object) has no attribute 'create_wirple'" ): canvas.create_wirple(1, 'floop')
def modify_image_if_needed(self, ui_el, image): n = ui_el.name if not self.uie[n].active: return image c = Canvas(ui_el.o, base_image=image) self.draw_text(c, ui_el) image = c.get_image() return image
def test_create_empty_matrix(self): expected = [['O', 'O', 'O'], ['O', 'O', 'O'], ['O', 'O', 'O']] c = Canvas(3, 3) self.assertEqual(expected, c.area) c = Canvas(3, 4) expected.append(['O', 'O', 'O']) self.assertEqual(expected, c.area)
def test_drawline_inverted_ok(self): canvas = Canvas() canvas.create(8, 4) canvas.draw_line(5, 1, 5, 3) canvas2 = Canvas() canvas2.create(8, 4) canvas2.draw_line(5, 3, 5, 1) self.assertTrue((canvas.data == canvas2.data).all())
def test_canvas_add_stem(): dwg = svgwrite.Drawing("foo") canvas = Canvas(dwg) stem = Stem('acguacgu', [[1, 8], [2, 7], [3, 6], [4, 5]]) canvas.add_stem(stem) assert (len(canvas.nucleotides) == 8)
def new(self): # Start a new game self.all_sprites = pg.sprite.Group() self.canvas = Canvas() self.all_sprites.add(self.canvas) self.playing = True #self.painting = False self.run()
def test_set_line_out_of_bounds_high(self): c = 10 out_start = Pixel(x=600, y=600, c_flag=c) end = Pixel(x=100, y=100, c_flag=c) result = Canvas(width=500, height=500).set_line(out_start, end) for i in range(100, 500): self.assertEqual(result.get_pixel(x=i, y=i).c_flag, c) self.assertNotEqual(result.get_pixel(x=100, y=101).c_flag, c)
def __init__(self, renderer, max_update_delay=0.2, *args, **keys): ''' Inits this canvas. Things setupped: background color, default camera, node factory, model/view/primitve renderer registries, adapter registry and render/update policies. ''' if 'name' not in keys: keys['name'] = 'unnamed canvas' self.renderer = renderer if 'backgroundColor' in keys: self.backgroundColor = keys['backgroundColor'] del keys['backgroundColor'] else: self.backgroundColor = None if 'renderPolicy' in keys: self.renderPolicy = keys['renderPolicy'] del keys['renderPolicy'] else: #self.renderPolicy = DefaultRenderPolicy() self.renderPolicy = CullingRenderPolicy() Canvas.__init__(self, self.renderer, False, None, None, None, None, observables.ObservableLinearTransform2D(), *args, **keys) self.camera = observables.ObservableCamera( observables.ObservableLinearTransform2D(), name='default camera') self.addChild(self.camera) self.model_kinds = [ 'Rectangle', 'RoundedRectangle', 'Circle', 'Ellipse', 'Arc', 'Text', 'Line', 'LineLength', 'Lines', 'LinesList', 'LineSegments', 'LineSegmentsSeparate', 'Bitmap', 'CubicSpline', 'QuadraticSpline', 'Polygon', 'PolygonList', 'Arrow', 'AngleArrow' ] self.primitive_kinds = [ 'Rectangle', 'RoundedRectangle', 'Ellipse', 'Arc', 'Text', 'LinesList', 'LineSegmentsSeparate', 'Bitmap', 'CubicSpline', 'QuadraticSpline', 'PolygonList', 'Arrow' ] self._setupRegistries() self._setupNodeFactory() self._setupAdapters() if 'updatePolicy' in keys: self.updatePolicy = keys['updatePolicy'] del keys['updatePolicy'] else: self.updatePolicy = DefaultUpdatePolicy(self, max_update_delay) self.controllers = [] self.subscribe(self.onDirty, 'attribChanged')
def do_I(self, line): M, N = (int(x) for x in line.split(' ')) limits = LimitValidator() try: limits.validate(M, N) except ValueError as e: print(str(e)) return False self.canvas = Canvas(M, N)
def prepareString(self, str, font): """Returns a Canvas object with the rasterized string""" tmpCanvas = Canvas(8*len(str), 8) offset = 0 for char in str: glyph = font.getChar(char) tmpCanvas.fromBytes(glyph, offset) offset += font.getCharSize(char) + font.getLetterSpace(char) return tmpCanvas
def __init__(self, varname, player_1='human', player_2='random', id=None, width=300, height=300): valid_players = ('human', 'random', 'alphabeta') if player_1 not in valid_players or player_2 not in valid_players: raise TypeError("Players must be one of {}".format(valid_players)) Canvas.__init__(self, varname, id, width, height) self.ttt = TicTacToe() self.state = self.ttt.initial self.turn = 0 self.strokeWidth(5) self.players = (player_1, player_2) self.draw_board() self.font("Ariel 30px")
def test_bounds(self): # SETUP expected_width = 800 expected_height = 600 # EXEC canvas = Canvas(expected_width, expected_height) width = canvas.cget('width') height = canvas.cget('height') # VERIFY self.assertEqual(expected_width, width) self.assertEqual(expected_height, height)
def __init__(self, parent): Canvas.__init__(self, parent) self.pen_cadre_1 = Pen((0,0,250), 2) self.pen_cadre_2 = Pen(width=3) self.pen_aiguille_1 = Pen(width=6) self.pen_aiguille_2 = Pen(width=5) self.pen_aiguille_3 = Pen(width=2, color=(255,0,0)) self.bind(size=self.on_size) #self._draw_cadre() self.aiguille_draw_op = CombineDrawOperation(self, []) self.scheduler = Thread(target=self.schedule) self.scheduler.start()
class Window(object): def __init__(self, width: int, height: int, pixels: ndarray): self.pixels = pixels self.width = width self.height = height self.canvas = Canvas(width, height, pixels) # setup key handlers key_esc = 27 self.handlers = { key_esc: self.exit } # self.v1 = Vertex(Vector(0, 0), Color.cyan()) # self.v2 = Vertex(Vector(300, 100), Color.red()) # self.v3 = Vertex(Vector(200, 300), Color.green()) model_path = "illidan.model" texture_path = "illidan.texture" self.mesh = Mesh(model_path, texture_path) def clear(self): self.canvas.clear() pass def update(self, dt): pass def draw(self): # self.canvas.draw_triangle(self.v1, self.v2, self.v3) self.canvas.draw_mesh(self.mesh) def mouse_event(self, button, state, x, y): print('mouse event', button, state, x, y) # 0, left button # 2, right button # 0, state press # 1, state release def exit(self): sys.exit(0) def cmd404(self): pass def key_event(self, key, key_is_down): print('key event', key, key_is_down) cmd = self.handlers.get(key, self.cmd404) cmd()
def main(): global screen pygame.init() pygame.mixer.quit() pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=128) can = Canvas() for c in can.channels: can.channels[c].set_volume(0.1) screen = pygame.display.set_mode((640, 200)) while True: screen.fill((0, 0, 0)) can.update(screen) pygame.display.update() clock.tick(30)
class Window(object): def __init__(self, pixels, width, height): self.pixels = pixels self.width = width self.height = height self.canvas = Canvas(width, height, pixels) # setup key handlers key_esc = 27 self.handlers = { key_esc: self.exit } self.v1 = Vertex(Vector(0, 0), Color.cyan()) self.v2 = Vertex(Vector(300, 100), Color.red()) self.v3 = Vertex(Vector(200, 300), Color.white()) self.v4 = Vertex(Vector(300, 0), Color.green()) def clear(self): self.canvas.clear() pass def update(self, dt): pass def draw(self): self.canvas.draw_triangle(self.v1, self.v2, self.v4) self.canvas.draw_triangle(self.v1, self.v2, self.v3) def mouse_event(self, button, state, x, y): print('mouse event', button, state, x, y) # 0, left button # 2, right button # 0, state press # 1, state release def exit(self): sys.exit(0) def cmd404(self): pass def key_event(self, key, key_is_down): print('key event', key, key_is_down) cmd = self.handlers.get(key, self.cmd404) cmd()
class MainWindow(QMainWindow): def __init__(self): QMainWindow.__init__(self) self._create_actions() self._create_toolbar() self._canvas = Canvas() self._canvas.scale(16, 16) self.setCentralWidget(self._canvas) def _create_actions(self): self._delete_action = QAction("Delete", None) self._delete_action.setShortcuts(QKeySequence.Delete) self._delete_action.triggered.connect(self._delete) self._select_action = QAction("Select", None) self._select_action.setCheckable(True) self._select_action.triggered.connect(self._use_select_tool) self._pen_action = QAction("Pen", None) self._pen_action.setCheckable(True) self._pen_action.setChecked(True) self._pen_action.triggered.connect(self._use_pen_tool) self._new_shape_action = QAction("New Shape", None) self._new_shape_action.triggered.connect(self._new_shape) self._tool_group = QActionGroup(None) self._tool_group.addAction(self._select_action) self._tool_group.addAction(self._pen_action) def _create_toolbar(self): toolbar = self.addToolBar("Tools") toolbar.addAction(self._delete_action) toolbar.addAction(self._select_action) toolbar.addAction(self._pen_action) toolbar.addAction(self._new_shape_action) def _use_select_tool(self): self._canvas.use_tool(SelectTool) def _use_pen_tool(self): self._canvas.use_tool(PenTool) def _new_shape(self): self._canvas.new_shape() def _delete(self): self._canvas.delete_selection()
class Filler(object): def __init__(self, bits, starting_pixel_count): self.colorset = Colorset(bits) # This is technically only correct for an even number of bits, but # it rounds down for an odd number of bits, and there are simply some colors # that we never use. Shrug. height = width = int(math.sqrt(self.colorset.size())) self.canvas = Canvas(width, height) self.starting_pixel_count = starting_pixel_count self.add_starting_pixels() self.start_time = time.time() self.last_save_time = time.time() self.time_color = 0.0 self.time_point = 0.0 def add_starting_pixels(self): # Grab some random starting colors just by making a randomly-sorted # list of all the colors and taking the first few. # Not the most efficient, but doesn't really matter. colors = [x for x in self.colorset.iterate()] random.shuffle(colors) height = width = self.canvas.height self.starting_pixel_list = [] for i in xrange(self.starting_pixel_count): starting_color = self.colorset.get_nearest(colors[i]) x = random.randint(0, width-1) y = random.randint(0, height-1) self.starting_pixel_list.append((x, y)) self.canvas.set(x, y, starting_color) def write_image(self, i): bits = self.colorset.bits name = '/tmp/colors-%s.%d.%d.%d.png' % (self.__class__.__name__, bits, self.starting_pixel_count, i) avg_rate = i / (time.time() - self.start_time) print (name, time.time() - self.last_save_time, int(avg_rate), int(self.time_color), int(self.time_point)) self.canvas.save(name) self.last_save_time = time.time()
def test_create_line(self): # SETUP expected_report = """\ create_line 1 2 100 200""" # EXEC canvas = Canvas() canvas.create_line(1, 2, 100, 200) report = canvas.report # VERIFY self.assertEqual(expected_report.splitlines(), report)
def __init__(self, matrixobject, positioninmatrix, weatherdefinition, hours_from_now, update_interval, getweatherobject): logging.info('Creating new Weather instance') self.__Matrix = matrixobject self.__MatrixPosition = positioninmatrix self.__WeatherDefinition = weatherdefinition self.__HoursFromNow = hours_from_now self.__UpdateInterval = update_interval self.__WeatherCanvas = Canvas(weatherdefinition['Size']) self.__ImageChanged = True self.__GetWeatherObject = getweatherobject self.__WeatherData = [] self.__WeatherForecast = {} self.__CurrentWeatherIcon = '' self.__CurrentWeatherWind = -1 self.__CurrentWeatherRain = -1.0 self.__CurrentWeatherSnow = -1.0 self.__CurrentWeatherMaxTemp = 999.0 self.__CurrentWeatherMinTemp = -999.0 self.__CurrentWeatherTime = -1 self.__WeatherReadError = False self.__LastUpdateTime = 0 self.__WindSpeedIcon = -1 self.__RainSnowIcon = ''
def __init__(self, parent, name, height=0): Pathetic.__init__(self, parent, name) self.height = height self.canvas = Canvas(height) self.fields = {} self.boxes = []
class Shelf(Pathetic): def __init__(self, parent, name, height=0): Pathetic.__init__(self, parent, name) self.height = height self.canvas = Canvas(height) self.fields = {} self.boxes = [] def add_box(self, *args, **kw): for k, v in {'line': 0, 'column': 0, 'width': 0, 'height': 0, 'align': -1, 'vfill': 0, 'raw': 0, 'wrap': 0}.items(): kw.setdefault(k, v) kw['parent'] = self box = Box(*args, **kw) self.boxes.append(box) self.canvas(box) return box def add_fields(self, *maybefields): for i in maybefields: if isinstance(i, Field): self.fields[i.name] = i def render(self, **kw): self.canvas.height = self.height self(**kw) return self.canvas.render() def __call__(self, **kw): for k, v in kw.items(): try: self.fields[k].value = v except KeyError, msg: raise UnknownFieldError, msg
def __init__(self): QMainWindow.__init__(self) self._create_actions() self._create_toolbar() self._canvas = Canvas() self._canvas.scale(16, 16) self.setCentralWidget(self._canvas)
def __init__(self): self.width = 800 self.height = 600 self.window = window.Window(self.width-1, self.height-1) self.window.register_event_type('on_update') pyglet.clock.schedule(self.update) self.canvas = Canvas(self.width, self.height, "Filename", "Path") #Create event handlers self.on_mouse_drag = self.window.event(self.on_mouse_drag) self.on_draw = self.window.event(self.on_draw) self.on_mouse_press = self.window.event(self.on_mouse_press) self.on_mouse_release = self.window.event(self.on_mouse_release) #Import theme self.cobalt = kytten.Theme(os.path.join(os.getcwd(), 'theme'), override={ "font_size": 10 }) self.bg_group = pyglet.graphics.OrderedGroup(0) self.fg_group = pyglet.graphics.OrderedGroup(500) #Create GUI self.mainDialog() self.layerDialog()
def __init__(self): self.current_step = 0 self.molecules = MoleculeGenerator.generate() print self.molecules self.canvas = Canvas() self.canvas.setup_timer(self.do_movement) self.verlet = Verlet()
class MaxDraw(): def __init__(self, display_count=1, spi_port=0, spi_clock=1000000): self.__displayCount = display_count self._displayCanvas = Canvas(8*display_count, 8) self._max = Max7219(spi_port, spi_clock, display_count) self.width = self._displayCanvas.getWidth() self.height = self._displayCanvas.getHeight() #self._displayCanvas = self._max._displayCanvas def __del__(self): #self.stop() pass def init(self): """Initializes the display""" self._max.init(0x00) def stop(self): """Stops using the display""" self._max.shutdown() def prepareString(self, str, font): """Returns a Canvas object with the rasterized string""" tmpCanvas = Canvas(8*len(str), 8) offset = 0 for char in str: glyph = font.getChar(char) tmpCanvas.fromBytes(glyph, offset) offset += font.getCharSize(char) + font.getLetterSpace(char) return tmpCanvas def paintCanvas(self): """Sends _displayCanvas to the MAX7219 to be displayed""" for d in range(self._max.getDisplayCount()): self._max.setDisplay(d+1) for x in range(8): #print "X: " + str(x) + " - COL: " + str(d*8+x) + " - BIN: " + str(self._displayCanvas.getCol(d*8 + x)) self._max.send(self._max.DIGIT_0 + x, ord(self._displayCanvas.getCol(d*8 + x).tobytes())) def paintNoise(self, ratio): """Returns a canvas filled with random noise using ratio as threshold.""" tmpCanvas = Canvas(self.width, self.height) for b in range(tmpCanvas.getSize()): tmpCanvas._c[b] = False if random.random() > ratio else True return tmpCanvas
class MainWindow(GladeWindow): glade_file = os.path.join("gui", "pybotlearn.glade") def __init__(self): super(MainWindow, self).__init__() self.canvas = Canvas() self.canvas.connect("key-press-event", self.on_key) self.robot = self.canvas.robot execution.robot = self.robot self.canvas_sw.add(self.canvas) self.console = PythonConsole(execution.namespace) self.main_paned.pack2(self.console) self.show_all() self.canvas.get_hadjustment().connect("value-changed", self.on_scroll) self.canvas.get_vadjustment().connect("value-changed", self.on_scroll) def on_up(self, *args): self.console.eval("move_up()", True) def on_down(self, *args): self.console.eval("move_down()", True) def on_right(self, *args): self.console.eval("move_right()", True) def on_left(self, *args): self.console.eval("move_left()", True) def on_key(self, sender, event): if event.keyval == gtk.keysyms.Up: self.on_up() return True elif event.keyval == gtk.keysyms.Down: self.on_down() return True elif event.keyval == gtk.keysyms.Left: self.on_left() return True elif event.keyval == gtk.keysyms.Right: self.on_right() return True def on_say(self, button): text = self.say_textview.get_buffer() text = text.get_text(text.get_start_iter(), text.get_end_iter()) self.console.eval("say(%s)" % repr(text), True) def on_scroll(self, *args): scroll_x = self.canvas.get_hadjustment() scroll_y = self.canvas.get_vadjustment() robot_x = self.robot.get_pixel_x() robot_y = self.robot.get_pixel_y() self.hruler.set_range(scroll_x.value, scroll_x.value + scroll_x.page_size, robot_x, self.canvas.width) self.vruler.set_range(scroll_y.value, scroll_y.value + scroll_y.page_size, robot_y, self.canvas.height)
def __init__(self, input = {'rows':[[]], 'cols':[[]]}, max_iterations=10): self.cols = input['cols'] self.width = len(self.cols) self.rows = input['rows'] self.height = len(self.rows) self.grid = Canvas(self.width, self.height, self.unknown_char) self.input = input self.max_iterations = max_iterations
def __init__(self, renderer, max_update_delay = 0.2, *args, **keys): ''' Inits this canvas. Things setupped: background color, default camera, node factory, model/view/primitve renderer registries, adapter registry and render/update policies. ''' if 'name' not in keys: keys['name'] = 'unnamed canvas' self.renderer = renderer if 'backgroundColor' in keys: self.backgroundColor = keys['backgroundColor'] del keys['backgroundColor'] else: self.backgroundColor = None if 'renderPolicy' in keys: self.renderPolicy = keys['renderPolicy'] del keys['renderPolicy'] else: #self.renderPolicy = DefaultRenderPolicy() self.renderPolicy = CullingRenderPolicy() Canvas.__init__(self, self.renderer, False, None, None, None, None, observables.ObservableLinearTransform2D(), *args, **keys) self.camera = observables.ObservableCamera( observables.ObservableLinearTransform2D(), name = 'default camera' ) self.addChild( self.camera ) self.model_kinds = [ 'Rectangle', 'RoundedRectangle', 'Circle', 'Ellipse', 'Arc', 'Text', 'Line', 'LineLength', 'Lines', 'LinesList', 'LineSegments', 'LineSegmentsSeparate', 'Bitmap', 'CubicSpline', 'QuadraticSpline', 'Polygon', 'PolygonList', 'Arrow', 'AngleArrow' ] self.primitive_kinds = [ 'Rectangle', 'RoundedRectangle', 'Ellipse', 'Arc', 'Text', 'LinesList', 'LineSegmentsSeparate', 'Bitmap', 'CubicSpline', 'QuadraticSpline', 'PolygonList', 'Arrow' ] self._setupRegistries() self._setupNodeFactory() self._setupAdapters() if 'updatePolicy' in keys: self.updatePolicy = keys['updatePolicy'] del keys['updatePolicy'] else: self.updatePolicy = DefaultUpdatePolicy( self, max_update_delay ) self.controllers = [] self.subscribe( self.onDirty, 'attribChanged' )
def new_tab(self): canvas = Canvas(self.data_singleton) self.mUndoStackGroup.addStack(canvas.getUndoStack()) canvas.send_cursor_pos.connect(self.send_cursor_pos) canvas.send_new_image_size.connect(self.send_new_image_size) canvas.send_change_edited.connect(self.update_states) scroll_area = QScrollArea() scroll_area.setWidget(canvas) scroll_area.setBackgroundRole(QPalette.Dark) file_name = canvas.get_file_name() title = self.data_singleton.UNTITLED if file_name is None else file_name self.ui.tabWidget.addTab(scroll_area, title) self.update_states()
def __init__(self, width, height): self.canvas = Canvas(); handler = MeterEventHandler(self); self.canvas.setup("below", handler); self.canvas.set_size(width, height); self.width = width; self.height = height; self.widgets = [];
def main(): """Set up a screen for a good entity named a to walk around randomly on. Until we tell him what moves are valid (because we have electro- shock boarders on right now (and always)) he will die always!""" c = Canvas() a = Entity(15,15,c) c.start() screen = c() for i in range(10000): a.move() screen.addch(a.y,a.x,a.char()) screen.refresh() if c is ord('q'): c.stop()
def _create_canvas(self, canvas_name): canvas = Canvas() canvas.set_size_request(self.DEFAULT_CANVAS_WIDTH, self.DEFAULT_CANVAS_WIDTH) canvas.connect("button-press-event", self._on_canvas_button_press, canvas_name) canvas.connect("drawing-stopped", self._on_canvas_drawing_stopped, canvas_name) canvas.connect("stroke-added", self._on_canvas_stroke_added, canvas_name) setattr(self, canvas_name, canvas) frame = gtk.Frame() frame.add(canvas) setattr(self, canvas_name + "_frame", frame)
def __init__(self): pygame.init() self.imgs = Images() self.canvas = Canvas() self.netw = Network() self.fonts = Fonts() self.events = PCEvents() self.buttons = Buttons() self.screen = pygame.display.set_mode(SCREEN_SIZE)