Python canvas.Canvas类代码示例

 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_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 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))

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 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 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()

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()

 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, 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 = ''