Beispiel #1
0
    def _placeDocs(self):
        """
        Places documentation blocks on the documentation layer
        """
        try:
            docs_dict = config.brd['documentation']
        except:
            return

        for key in docs_dict:

            location = utils.toPoint(docs_dict[key]['location'])
            docs_dict[key]['location'] = [0, 0]

            shape_group = et.SubElement(self._layers['documentation']['layer'], 'g')
            shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'module-shapes')            
            shape_group.set('{'+config.cfg['ns']['pcbmode']+'}doc-key', key)
            shape_group.set('transform', "translate(%s,%s)" % (location.x, config.cfg['invert-y']*location.y))

            location = docs_dict[key]['location']
            docs_dict[key]['location'] = [0, 0]

            shape = Shape(docs_dict[key])
            style = Style(docs_dict[key], 'documentation')
            shape.setStyle(style)
            element = place.placeShape(shape, shape_group)
 def fit(self, test_image, tol=0.1, max_iters=10000, initial_shape=None):
     """
     Fits the shape model to the test image to find the shape
     :param test_image: The test image in the form of a numpy matrix
     :param tol: Fraction of points changed
     :param max_iters: Maximum number of iterations
     :param initial_shape: The starting Shape - if None get_default_initial_shape() is used
     :return: The final Shape, the fit error and the number of iterations performed
     """
     if initial_shape is None:
         current_shape = self.get_default_initial_shape()
     else:
         current_shape = initial_shape.round()
     num_iter = 0
     fit_error = float("inf")
     for num_iter in range(max_iters):
         previous_shape = Shape(current_shape.as_numpy_matrix().copy())
         new_shape_grey, error_list = self._gm.search(test_image, current_shape)
         current_shape, fit_error, num_iters = self._pdm.fit(new_shape_grey)
         moved_points = np.sum(
             np.sum(current_shape.as_numpy_matrix().round() - previous_shape.as_numpy_matrix().round(),
                    axis=1) > 0)
         if moved_points / float(self._pdm.get_size()) < tol:
             break
     return current_shape, fit_error, num_iter
 def __init__(self, geometricName, contour):
     Shape.__init__(self, geometricName, contour)
     cornerList = []
     self.minX = 1000
     self.maxX = 0
     self.minY = 1000
     self.maxY = 0
     contourCopy = contour
     if len(contourCopy) > 1:
         for corner in contourCopy:
             cornerList.append((corner.item(0), corner.item(1)))
         for corner in cornerList:
             if corner[0] > self.maxX:
                 self.maxX = corner[0]
             if corner[1] > self.maxY:
                 self.maxY = corner[1]
             if corner[0] < self.minX:
                 self.minX = corner[0]
             if corner[1] < self.minY:
                 self.minY = corner[1]
     else:
         self.minX = 0
         self.maxX = 960
         self.minY = 0
         self.maxY = 720
Beispiel #4
0
    def _processShapes(self):
        """
        """

        sheets = ['conductor', 'silkscreen', 'soldermask']

        for sheet in sheets:

            try:
                shapes = self._footprint['layout'][sheet]['shapes']
            except:
                shapes = []
     
            for shape_dict in shapes:
                layers = utils.getExtendedLayerList(shape_dict.get('layers') or ['top'])
                for layer in layers:
                    # Mirror the shape if it's text and on bottom later,
                    # but let explicit shape setting override
                    if layer == 'bottom':
                        if shape_dict['type'] == 'text':
                            shape_dict['mirror'] = shape_dict.get('mirror') or 'True'
                    shape = Shape(shape_dict)
                    style = Style(shape_dict, sheet)
                    shape.setStyle(style)
                    try:
                        self._shapes[sheet][layer].append(shape)
                    except:
                        self._shapes[sheet][layer] = []
                        self._shapes[sheet][layer].append(shape)
Beispiel #5
0
 def __init__(self, size, rotation, color="blue"):
     texture_path = Shape.build_texture_path(color, Octagon.shape_type)
     Shape.__init__(self, texture_path, size, rotation, Octagon.shape_type, color)
 
     self.sides = 8
     self.color = color
     
Beispiel #6
0
    def __init__(self):
        def initHandle(handle):
            self.handles.append(handle)
            QObject.connect(handle, SIGNAL("moved(QGraphicsObject*)"), self.handleMoved)

        Shape.__init__(self, BubbleItem(self))
        # Item
        self.item.setFlag(QGraphicsItem.ItemIsSelectable)
        self.item.setBrush(COLOR)

        # Text item
        self.textItem = QGraphicsTextItem(self.item)
        self.textItem.setTextInteractionFlags(Qt.TextEditorInteraction)
        QObject.connect(self.textItem.document(), SIGNAL("contentsChanged()"), \
            self.adjustSizeFromText)

        # Handles
        self.anchorHandle = Handle(self.item, 0, 0)
        # Position the bubble to the right of the anchor so that it can grow
        # vertically without overflowing the anchor
        self.bubbleHandle = Handle(self.item, ANCHOR_THICKNESS, -ANCHOR_THICKNESS)
        initHandle(self.anchorHandle)
        initHandle(self.bubbleHandle)
        self.setHandlesVisible(False)

        self.adjustSizeFromText()
Beispiel #7
0
 def addShapes(self):
   """adds more shapes to the world"""
   # how many shapes to generate
   # we want roughly one piece per screen
   screenArea = self.displayGridSize[0] * self.displayGridSize[1]
   worldArea = self.world.cols * self.world.rows
   minTotalShapes = 1 + int(worldArea / screenArea)
   #logging.debug("generating {0} shape pieces...".format(minTotalShapes))
   curTotalShapes = 0
   shapes = []
   while curTotalShapes < minTotalShapes:
   # until enough shape generated
     # create new shape, placed randomly
     num_sides = random.randint(3,6)
     newShape = Shape(self.display, self, self.character_size, num_sides)
     newShape.autonomous = True  # all new shapes will be autonomous by default
     
     # add shape to the list of objects
     if(self.world.addObject(newShape)):
       curTotalShapes += 1
       shapes.append(newShape)
       logging.debug ("shape #{0} added to the map, id {1} with position {2} and rect={3}".format(curTotalShapes, newShape, newShape.getMapTopLeft(), newShape.rect))
   # now there's enough shape in the world
   self.shapes = shapes
   return shapes
Beispiel #8
0
 def __init__(self, ps, color=None):
     Shape.__init__(self, color)
     self.vs = ps
     self.bound = AABox.from_vectors(*self.vs)
     self.half_planes = []
     for i in xrange(len(self.vs)):
         h = HalfPlane(self.vs[i], self.vs[(i+1) % len(self.vs)])
         self.half_planes.append(h)
Beispiel #9
0
 def __init__(self, ps, color=None):
     Shape.__init__(self, color)
     mn = min(enumerate(ps), key=lambda (i,v): (v.y, v.x))[0]
     self.vs = list(ps[mn:]) + list(ps[:mn])
     self.bound = Vector.union(*self.vs)
     self.half_planes = []
     for i in xrange(len(self.vs)):
         h = HalfPlane(self.vs[i], self.vs[(i+1) % len(self.vs)])
         self.half_planes.append(h)
Beispiel #10
0
    def __init__(self):
        Shape.__init__(self, LineItem(self))
        self.item.setFlag(QGraphicsItem.ItemIsSelectable)

        self.handles.append(Handle(self.item, 0, 0))
        self.handles.append(Handle(self.item, 0, 0))
        self.handles[1].setZValue(self.handles[0].zValue() + 1)
        for handle in self.handles:
            QObject.connect(handle, SIGNAL("moved(QGraphicsObject*)"), self.handleMoved)
        self.setHandlesVisible(False)
Beispiel #11
0
    def __init__(self, theta1=0, theta2=360, *args, **kwargs):
        '''Create an ellipse '''

        self._theta1 = theta1
        self._theta2 = theta2
        Shape.__init__(self, *args, **kwargs)
        self._fill_mode = GL_TRIANGLES
        self._line_mode = GL_LINE_LOOP
        self._update_position()
        self._update_shape()
Beispiel #12
0
    def __init__(self, radius=0, *args, **kwargs):
        '''Create an (optionable) round rectangle.

        :Parameters:        
            `radius` : int or tuple of 4 int
                Radius of corners.
        '''
        self._radius = radius
        Shape.__init__(self,*args,**kwargs)
        self._update_position()
        self._update_shape()
Beispiel #13
0
 def translate_errors(self, physical_error):
   encoded_error = Shape([])
   for triplet in self.triplets:
     anticommute_count = 0
     for op in triplet:
       if (not op.commutes_with(physical_error)):
         anticommute_count = anticommute_count + 1
         if (anticommute_count > 1):
           raise RuntimeError("Invalid triplet\n" + str(triplet))
         encoded_error.multiply_with_self(op)
     return encoded_error
Beispiel #14
0
    def __init__(self, corners):
        """
        Create Square self with vertices corners.

        Assume all sides are equal and corners are square.

        @param Square self: this Square object
        @param list[Point] corners: corners that define this Square
        @rtype: None

        >>> s = Square([Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 0)])
        """
        Shape.__init__(self, corners)
Beispiel #15
0
    def __init__(self, direction='up', *args, **kwargs):
        '''Create an oriented triangle.

        :Parameters:
            `direction` : str
               The triangle is oriented relative to its center to this property,
               which must be one of the alignment constants `left`, `right`,
               `up` or `down`.
        '''

        self._direction = direction
        Shape.__init__(self,*args, **kwargs)
        self._update_position()
        self._update_shape()
Beispiel #16
0
    def _processAssemblyShapes(self):
        """
        """
        try:
            shapes = self._footprint['layout']['assembly']['shapes']
        except:
            return

        for shape_dict in shapes:
            layers = shape_dict.get('layer') or ['top']
            for layer in layers:
                shape = Shape(shape_dict)
                style = Style(shape_dict, 'assembly')
                shape.setStyle(style)
                self._shapes['assembly'][layer].append(shape)
Beispiel #17
0
    def __init__(self, thickness=.4, branches=5, *args, **kwargs):
        '''Create a cross.

        :Parameters:
            `thickness` : int
                Thickness of the cross
            `branches` : int
                Number of branches
        '''
        self._thickness = thickness
        self._branches = branches
        Shape.__init__(self, *args, **kwargs)
        self._fill_mode = GL_TRIANGLES
        self._update_position()
        self._update_shape()
    def __init__(self, corners):
        """
        Create RightAngleTriangle self with vertices corners.

        Overrides Shape.__init__

        Assume corners[0] is the 90 degree angle.

        @param RightAngleTriangle self: this RightAngleTriangle object
        @param list[Point] corners: corners that define this RightAngleTriangle
        @rtype: None

        >>> s = RightAngleTriangle([Point(0, 0), Point(1, 0), Point(0, 2)])
        """
        Shape.__init__(self, corners)
Beispiel #19
0
 def __init__(self, screen):
     self.stat = "game"
     self.WIDTH = self.TILEW * self.W
     self.HEIGHT = self.TILEW * self.H
     self.screen = screen
     self.pause = False
     # the array save current situation
     # same as screen cood
     self.board = []
     for i in xrange(self.H):
         line = [ None ] * self.W
         self.board.append(line)
     # will display
     self.level = 1
     self.killed = 0
     self.score = 0
     # after this time, shape falls
     self.time = self.SPACE * 0.9 ** (self.level - 1)
     # save the elapsed time after last fail
     self.elapsed = 0
     # used for judge pressed firstly or for a  long time
     self.pressing = 0
     # the moving shape
     self.shape = Shape(self.START,
             (self.WIDTH, self.HEIGHT), (self.W, self.H))
     self.shape.set_board(self.board)
     self.board_image = pygame.Surface((self.WIDTH, self.HEIGHT))
     # draw the background once
     self.screen.blit(pygame.image.load(
         util.file_path("background.jpg")).convert(), (0, 0))
     self.display_info()
Beispiel #20
0
 def __init__(self, *args, **kwargs):
     super(Canvas, self).__init__(*args, **kwargs)
     # Initialise local state.
     self.anno = []
     self.mode = self.EDIT
     self.shapes = []
     self.current = None
     self.selectedShape = None  # save the selected shape here
     self.selectedShapeCopy = None
     self.lineColor = QColor(0, 0, 255)
     self.line = Shape(line_color=self.lineColor)
     self.prevPoint = QPointF()
     self.offsets = QPointF(), QPointF()
     self.scale = 1.0
     self.pixmap = QPixmap()
     self.visible = {}
     self._hideBackround = False
     self.hideBackround = False
     self.hShape = None
     self.hVertex = None
     self._painter = QPainter()
     self._cursor = CURSOR_DEFAULT
     # Menus:
     self.menus = (QMenu(), QMenu())
     # Set widget options.
     self.setMouseTracking(True)
     self.setFocusPolicy(Qt.WheelFocus)
Beispiel #21
0
 def __init__(self, screen):
     self.stat = "game"
     self.WIDTH = self.TILEW * self.W
     self.HEIGHT = self.TILEW * self.H
     self.screen = screen
     self.pause = False
     self.board = [] #save current situation same as screen
     for i in xrange(self.H):
         line = [None] * self.W
         self.board.append(line)
     #next to display 
     self.level = 1
     self.killed = 0
     self.score = 0
     #delay for shape fall
     self.time = self.SPACE * 0.8 ** (self.level - 1)
     #save the elapsed time after last fail
     self.elapsed = 0
     #pressd firstly time
     self.pressing = 0
     #moving shape
     self.shape = Shape(self.START,      \
             (self.WIDTH, self.HEIGHT), (self.W, self.H))
     self.shape.set_board(self.board)
     self.board_image = pygame.Surface((self.WIDTH, self.HEIGHT))
     #draw background
     self.screen.blit(pygame.image.load( \
             util.file_path("background.jpg")).convert(), (0, 0))
     self.display_info()
Beispiel #22
0
 def add_shape(self):
     assert not self.shape
     sh, col = random.choice(shape_color)
     self.shape = Shape(sh, self.window, col, self.width/2, 0, self.xinit, self.yinit)
     if self.collides(self.shape):
         raise GameOver()
     self.shape.draw()
Beispiel #23
0
 def mousePressEvent(self, ev):
     pos = self.transformPos(ev.posF())
     if ev.button() == Qt.LeftButton:
         if self.drawing():
             if self.current and self.current.reachMaxPoints() is False:
                 initPos = self.current[0]
                 minX = initPos.x()
                 minY = initPos.y()
                 targetPos = self.line[1]
                 maxX = targetPos.x()
                 maxY = targetPos.y()
                 self.current.addPoint(QPointF(maxX, minY))
                 self.current.addPoint(targetPos)
                 self.current.addPoint(QPointF(minX, maxY))
                 self.current.addPoint(initPos)
                 self.line[0] = self.current[-1]
                 if self.current.isClosed():
                     self.finalise()
             elif not self.outOfPixmap(pos):
                 self.current = Shape()
                 self.current.addPoint(pos)
                 self.line.points = [pos, pos]
                 self.setHiding()
                 self.drawingPolygon.emit(True)
                 self.update()
         else:
             self.selectShapePoint(pos)
             self.prevPoint = pos
             self.repaint()
     elif ev.button() == Qt.RightButton and self.editing():
         self.selectShapePoint(pos)
         self.prevPoint = pos
         self.repaint()
Beispiel #24
0
    def _processSilkscreenShapes(self):
        """
        """
        try:
            shapes = self._footprint['layout']['silkscreen']['shapes']
        except:
            return

        for shape_dict in shapes:
            layers = shape_dict.get('layers') or ['top']
            shape = Shape(shape_dict)
            style = Style(shape_dict, 'silkscreen')
            shape.setStyle(style)

            for layer in layers:
                self._shapes['silkscreen'][layer].append(shape)
Beispiel #25
0
    def _getOutline(self):
        """
        Process the module's outline shape. Modules don't have to have an outline
        defined, so in that case return None.
        """
        shape = None

        outline_dict = self._module_dict.get('outline')
        if outline_dict != None:
            shape_dict = outline_dict.get('shape')
            if shape_dict != None:
                shape = Shape(shape_dict)
                style = Style(shape_dict, 'outline')
                shape.setStyle(style)

        return shape
Beispiel #26
0
 def __init__(self, a=1.0, b=1.0, c=0.0, d=0.0, e=0.0, f=-1.0, color=None):
     Shape.__init__(self, color)
     self.a = a
     self.b = b
     self.c = c
     self.d = d
     self.e = e
     self.f = f
     t = Transform(2 * a, c, 0, c, 2 * b, 0)
     self.center = t.inverse() * Vector(-d, -e)
     l1, l0 = quadratic(1, 2 * (-a - b), 4 * a * b - c * c)
     v = t.eigv()
     axes = [v[0] * ((l0 / 2) ** -0.5), v[1] * ((l1 / 2) ** -0.5)]
     self.bound = Vector.union(self.center - axes[0] - axes[1],
                               self.center - axes[0] + axes[1],
                               self.center + axes[0] - axes[1],
                               self.center + axes[0] + axes[1])
Beispiel #27
0
    def __init__(self, main, x, y, width, height=0):
        Window.__init__(self, main, x, y, width, height)
        self.grid_size = 10
        self.grid_visible = True
        self.selected_point = None
        self.snap_to_grid = False

        self.shape = Shape()
Beispiel #28
0
	def __init__(self, parent):
		QtGui.QFrame.__init__(self, parent)
		
		self.timer = QtCore.QBasicTimer()
		self.isWaitingAfterLine = False
		self.curPiece = Shape()
		self.nextPiece = Shape()
		self.curX = 0
		self.curY = 0
		self.numLinesRemoved = 0
		self.board = []
		
		self.setFocusPolicy(QtCore.Qt.StrongFocus)
		self.isStarted = False
		self.isPaused = False
		self.clearBoard()
		
		self.nextPiece.setRandomShape()
Beispiel #29
0
 def generate(self, factors):
     """
     Generates a shape based on a vector of factors of size
     equal to the number of modes of the model, with element
     values between -1 and 1
     :param factors: A vector of size modes() with values
     between -1 and 1
     :return: A Shape object containing the generated shape
     """
     return Shape.from_collapsed_vector(self._model.generate(factors))
Beispiel #30
0
    def _placeLayerIndex(self):
        """
        Adds a drill index
        """

        text_dict = config.stl['layout']['layer-index']['text']
        text_dict['type'] = 'text'

        # Set the height (and width) of the rectangle (square) to the
        # size of the text
        rect_width = utils.parseDimension(text_dict['font-size'])[0]
        rect_height = rect_width
        rect_gap = 0.25

        # Get location, or generate one
        try:
            location = config.brd['layer-index']['location']
        except:
            # If not location is specified, put the drill index at the
            # top right of the board. The 'gap' defines the extra
            # spcae between the top of the largest drill and the
            # board's edge
            gap = 2
            location = [self._width/2+gap, self._height/2-rect_height/2]
        location = utils.toPoint(location)        

        rect_dict = {}
        rect_dict['type'] = 'rect'
        rect_dict['style'] = 'fill'
        rect_dict['width'] = rect_width
        rect_dict['height'] = rect_height

        # Create group for placing index
        for pcb_layer in utils.getSurfaceLayers():
            for sheet in ['copper', 'soldermask', 'silkscreen', 'assembly', 'solderpaste']:
                layer = self._layers[pcb_layer][sheet]['layer']
                transform = "translate(%s,%s)" % (location.x, config.cfg['invert-y']*location.y)
                group = et.SubElement(layer, 'g',
                                      transform=transform)
                group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'layer-index')

                rect_shape = Shape(rect_dict)
                style = Style(rect_dict, sheet)
                rect_shape.setStyle(style)
                place.placeShape(rect_shape, group)

                text_dict['value'] = "%s %s" % (pcb_layer, sheet)
                #text_dict['location'] = [rect_width+rect_gap+text_width, 0]
                text_shape = Shape(text_dict)
                text_width = text_shape.getWidth()
                style = Style(text_dict, sheet)
                text_shape.setStyle(style)
                element = place.placeShape(text_shape, group)
                element.set("transform", "translate(%s,%s)" % (rect_width/2+rect_gap+text_width/2, 0))

                location.y += config.cfg['invert-y']*(rect_height+rect_gap)

            location.y += config.cfg['invert-y']*(rect_height+rect_gap*2)
Beispiel #31
0
 def detect(self, img, bndbox, initShape):
     mShape = Shape.shapeNorm2Real(self.meanShape, bndbox)
     for reg in self.regressors:
         affineT = Affine.fitGeoTrans(mShape, initShape)
         reg.detect(img, bndbox, initShape, affineT)
Beispiel #32
0
class Board(QFrame):

    msg2Statusbar = pyqtSignal(str)

    BoardWidth = 10
    BoardHeight = 22
    Speed = 300

    def __init__(self, parent):
        super().__init__(parent)

        self.initBoard()

    def initBoard(self):
        '''initiates board'''

        self.timer = QBasicTimer()
        self.isWaitingAfterLine = False

        self.curX = 0
        self.curY = 0
        self.numLinesRemoved = 0
        self.board = []

        self.setFocusPolicy(Qt.StrongFocus)
        self.isStarted = False
        self.isPaused = False
        self.clearBoard()

    def shapeAt(self, x, y):
        '''determines shape at the board position'''

        return self.board[(y * Board.BoardWidth) + x]

    def setShapeAt(self, x, y, shape):
        '''sets a shape at the board'''

        self.board[(y * Board.BoardWidth) + x] = shape

    def squareWidth(self):
        '''returns the width of one square'''

        return self.contentsRect().width() // Board.BoardWidth

    def squareHeight(self):
        '''returns the height of one square'''

        return self.contentsRect().height() // Board.BoardHeight

    def start(self):
        '''starts game'''

        if self.isPaused:
            return

        self.isStarted = True
        self.isWaitingAfterLine = False
        self.numLinesRemoved = 0
        self.clearBoard()

        self.msg2Statusbar.emit(str(self.numLinesRemoved))

        self.newPiece()
        self.timer.start(Board.Speed, self)

    def pause(self):
        '''pauses game'''

        if not self.isStarted:
            return

        self.isPaused = not self.isPaused

        if self.isPaused:
            self.timer.stop()
            self.msg2Statusbar.emit("paused")

        else:
            self.timer.start(Board.Speed, self)
            self.msg2Statusbar.emit(str(self.numLinesRemoved))

        self.update()

    def paintEvent(self, event):
        '''paints all shapes of the game'''

        painter = QPainter(self)
        rect = self.contentsRect()

        boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()

        for i in range(Board.BoardHeight):
            for j in range(Board.BoardWidth):
                shape = self.shapeAt(j, Board.BoardHeight - i - 1)

                if shape != Tetrominoe.NoShape:
                    self.drawSquare(painter,
                                    rect.left() + j * self.squareWidth(),
                                    boardTop + i * self.squareHeight(), shape)

        if self.curPiece.shape() != Tetrominoe.NoShape:

            for i in range(4):

                x = self.curX + self.curPiece.x(i)
                y = self.curY - self.curPiece.y(i)
                self.drawSquare(
                    painter,
                    rect.left() + x * self.squareWidth(), boardTop +
                    (Board.BoardHeight - y - 1) * self.squareHeight(),
                    self.curPiece.shape())

    def keyPressEvent(self, event):
        '''processes key press events'''

        if not self.isStarted or self.curPiece.shape() == Tetrominoe.NoShape:
            super(Board, self).keyPressEvent(event)
            return

        key = event.key()

        if key == Qt.Key_P:
            self.pause()
            return

        if self.isPaused:
            return

        elif key == Qt.Key_Left:
            self.tryMove(self.curPiece, self.curX - 1, self.curY)

        elif key == Qt.Key_Right:
            self.tryMove(self.curPiece, self.curX + 1, self.curY)

        elif key == Qt.Key_Down:
            self.tryMove(self.curPiece.rotateRight(), self.curX, self.curY)

        elif key == Qt.Key_Up:
            self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)

        elif key == Qt.Key_Space:
            self.dropDown()

        elif key == Qt.Key_D:
            self.oneLineDown()

        else:
            super(Board, self).keyPressEvent(event)

    def timerEvent(self, event):
        '''handles timer event'''

        if event.timerId() == self.timer.timerId():

            if self.isWaitingAfterLine:
                self.isWaitingAfterLine = False
                self.newPiece()
            else:
                self.oneLineDown()

        else:
            super(Board, self).timerEvent(event)

    def clearBoard(self):
        '''clears shapes from the board'''

        for i in range(Board.BoardHeight * Board.BoardWidth):
            self.board.append(Tetrominoe.NoShape)

    def dropDown(self):
        '''drops down a shape'''

        newY = self.curY

        while newY > 0:

            if not self.tryMove(self.curPiece, self.curX, newY - 1):
                break

            newY -= 1

        self.pieceDropped()

    def oneLineDown(self):
        '''goes one line down with a shape'''

        if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
            self.pieceDropped()

    def pieceDropped(self):
        '''after dropping shape, remove full lines and create new shape'''

        for i in range(4):

            x = self.curX + self.curPiece.x(i)
            y = self.curY - self.curPiece.y(i)
            self.setShapeAt(x, y, self.curPiece.shape())

        self.removeFullLines()

        if not self.isWaitingAfterLine:
            self.newPiece()

    def removeFullLines(self):
        '''removes all full lines from the board'''

        numFullLines = 0
        rowsToRemove = []

        for i in range(Board.BoardHeight):

            n = 0
            for j in range(Board.BoardWidth):
                if not self.shapeAt(j, i) == Tetrominoe.NoShape:
                    n = n + 1

            if n == 10:
                rowsToRemove.append(i)

        rowsToRemove.reverse()

        for m in rowsToRemove:

            for k in range(m, Board.BoardHeight):
                for l in range(Board.BoardWidth):
                    self.setShapeAt(l, k, self.shapeAt(l, k + 1))

        numFullLines = numFullLines + len(rowsToRemove)

        if numFullLines > 0:

            self.numLinesRemoved = self.numLinesRemoved + numFullLines
            self.msg2Statusbar.emit(str(self.numLinesRemoved))

            self.isWaitingAfterLine = True
            self.curPiece.setShape(Tetrominoe.NoShape)
            self.update()

    def newPiece(self):
        '''creates a new shape'''

        self.curPiece = Shape()
        self.curPiece.setRandomShape()
        self.curX = Board.BoardWidth // 2 + 1
        self.curY = Board.BoardHeight - 1 + self.curPiece.minY()

        if not self.tryMove(self.curPiece, self.curX, self.curY):

            self.curPiece.setShape(Tetrominoe.NoShape)
            self.timer.stop()
            self.isStarted = False
            self.msg2Statusbar.emit("Game over")

    def tryMove(self, newPiece, newX, newY):
        '''tries to move a shape'''

        for i in range(4):

            x = newX + newPiece.x(i)
            y = newY - newPiece.y(i)

            if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
                return False

            if self.shapeAt(x, y) != Tetrominoe.NoShape:
                return False

        self.curPiece = newPiece
        self.curX = newX
        self.curY = newY
        self.update()

        return True

    def drawSquare(self, painter, x, y, shape):
        '''draws a square of a shape'''

        colorTable = [
            0x000000, 0xCC6666, 0x66CC66, 0x6666CC, 0xCCCC66, 0xCC66CC,
            0x66CCCC, 0xDAAA00
        ]

        color = QColor(colorTable[shape])
        painter.fillRect(x + 1, y + 1,
                         self.squareWidth() - 2,
                         self.squareHeight() - 2, color)

        painter.setPen(color.lighter())
        painter.drawLine(x, y + self.squareHeight() - 1, x, y)
        painter.drawLine(x, y, x + self.squareWidth() - 1, y)

        painter.setPen(color.darker())
        painter.drawLine(x + 1, y + self.squareHeight() - 1,
                         x + self.squareWidth() - 1,
                         y + self.squareHeight() - 1)
        painter.drawLine(x + self.squareWidth() - 1,
                         y + self.squareHeight() - 1,
                         x + self.squareWidth() - 1, y + 1)
Beispiel #33
0
 def __init__(self, x, y, color, width, height):
     Shape.__init__(self, x, y, color)
     self.width = width
     self.height = height
Beispiel #34
0
class Canvas(QWidget):
    zoomRequest = pyqtSignal(int)
    scrollRequest = pyqtSignal(int, int)
    newShape = pyqtSignal()
    selectionChanged = pyqtSignal(bool)
    shapeMoved = pyqtSignal()
    drawingPolygon = pyqtSignal(bool)

    CREATE, EDIT = range(2)

    epsilon = 11.0

    def __init__(self, *args, **kwargs):
        super(Canvas, self).__init__(*args, **kwargs)
        # Initialise local state.
        self.mode = self.EDIT
        self.shapes = []
        self.current = None
        self.selectedShape = None  # save the selected shape here
        self.selectedShapeCopy = None
        self.lineColor = QColor(0, 0, 255)
        self.line = Shape(line_color=self.lineColor)
        self.prevPoint = QPointF()
        self.offsets = QPointF(), QPointF()
        self.scale = 1.0
        self.pixmap = QPixmap()
        self.visible = {}
        self._hideBackround = False
        self.hideBackround = False
        self.hShape = None
        self.hVertex = None
        self._painter = QPainter()
        self._cursor = CURSOR_DEFAULT
        # Menus:
        self.menus = (QMenu(), QMenu())
        # Set widget options.
        self.setMouseTracking(True)
        self.setFocusPolicy(Qt.WheelFocus)

    def enterEvent(self, ev):
        self.overrideCursor(self._cursor)

    def leaveEvent(self, ev):
        self.restoreCursor()

    def focusOutEvent(self, ev):
        self.restoreCursor()

    def isVisible(self, shape):
        return self.visible.get(shape, True)

    def drawing(self):
        return self.mode == self.CREATE

    def editing(self):
        return self.mode == self.EDIT

    def setEditing(self, value=True):
        self.mode = self.EDIT if value else self.CREATE
        if not value:  # Create
            self.unHighlight()
            self.deSelectShape()

    def unHighlight(self):
        if self.hShape:
            self.hShape.highlightClear()
        self.hVertex = self.hShape = None

    def selectedVertex(self):
        return self.hVertex is not None

    def mouseMoveEvent(self, ev):
        """Update line with last point and current coordinates."""
        pos = self.transformPos(ev.posF())

        self.restoreCursor()

        # Polygon drawing.
        if self.drawing():
            self.overrideCursor(CURSOR_DRAW)
            if self.current:
                color = self.lineColor
                if self.outOfPixmap(pos):
                    # Don't allow the user to draw outside the pixmap.
                    # Project the point to the pixmap's edges.
                    pos = self.intersectionPoint(self.current[-1], pos)
                elif len(self.current) > 1 and self.closeEnough(
                        pos, self.current[0]):
                    # Attract line to starting point and colorise to alert the user:
                    pos = self.current[0]
                    color = self.current.line_color
                    self.overrideCursor(CURSOR_POINT)
                    self.current.highlightVertex(0, Shape.NEAR_VERTEX)
                self.line[1] = pos
                self.line.line_color = color
                self.repaint()
                self.current.highlightClear()
            return

        # Polygon copy moving.
        if Qt.RightButton & ev.buttons():
            if self.selectedShapeCopy and self.prevPoint:
                self.overrideCursor(CURSOR_MOVE)
                self.boundedMoveShape(self.selectedShapeCopy, pos)
                self.repaint()
            elif self.selectedShape:
                self.selectedShapeCopy = self.selectedShape.copy()
                self.repaint()
            return

        # Polygon/Vertex moving.
        if Qt.LeftButton & ev.buttons():
            if self.selectedVertex():
                self.boundedMoveVertex(pos)
                self.shapeMoved.emit()
                self.repaint()
            elif self.selectedShape and self.prevPoint:
                self.overrideCursor(CURSOR_MOVE)
                self.boundedMoveShape(self.selectedShape, pos)
                self.shapeMoved.emit()
                self.repaint()
            return

        # Just hovering over the canvas, 2 posibilities:
        # - Highlight shapes
        # - Highlight vertex
        # Update shape/vertex fill and tooltip value accordingly.
        self.setToolTip("Image")
        for shape in reversed([s for s in self.shapes if self.isVisible(s)]):
            # Look for a nearby vertex to highlight. If that fails,
            # check if we happen to be inside a shape.
            index = shape.nearestVertex(pos, self.epsilon)
            if index is not None:
                if self.selectedVertex():
                    self.hShape.highlightClear()
                self.hVertex, self.hShape = index, shape
                shape.highlightVertex(index, shape.MOVE_VERTEX)
                self.overrideCursor(CURSOR_POINT)
                self.setToolTip("Click & drag to move point")
                self.setStatusTip(self.toolTip())
                self.update()
                break
            elif shape.containsPoint(pos):
                if self.selectedVertex():
                    self.hShape.highlightClear()
                self.hVertex, self.hShape = None, shape
                self.setToolTip("Click & drag to move shape '%s'" %
                                shape.label)
                self.setStatusTip(self.toolTip())
                self.overrideCursor(CURSOR_GRAB)
                self.update()
                break
        else:  # Nothing found, clear highlights, reset state.
            if self.hShape:
                self.hShape.highlightClear()
                self.update()
            self.hVertex, self.hShape = None, None

    def mousePressEvent(self, ev):
        pos = self.transformPos(ev.posF())
        if ev.button() == Qt.LeftButton:
            if self.drawing():
                if self.current:
                    self.current.addPoint(self.line[1])
                    self.line[0] = self.current[-1]
                    if self.current.isClosed():
                        self.finalise()
                elif not self.outOfPixmap(pos):
                    self.current = Shape()
                    self.current.addPoint(pos)
                    self.line.points = [pos, pos]
                    self.setHiding()
                    self.drawingPolygon.emit(True)
                    self.update()
            else:
                self.selectShapePoint(pos)
                self.prevPoint = pos
                self.repaint()
        elif ev.button() == Qt.RightButton and self.editing():
            self.selectShapePoint(pos)
            self.prevPoint = pos
            self.repaint()

    def mouseReleaseEvent(self, ev):
        if ev.button() == Qt.RightButton:
            menu = self.menus[bool(self.selectedShapeCopy)]
            self.restoreCursor()
            if not menu.exec_(self.mapToGlobal(ev.pos()))\
               and self.selectedShapeCopy:
                # Cancel the move by deleting the shadow copy.
                self.selectedShapeCopy = None
                self.repaint()
        elif ev.button() == Qt.LeftButton and self.selectedShape:
            self.overrideCursor(CURSOR_GRAB)

    def endMove(self, copy=False):
        assert self.selectedShape and self.selectedShapeCopy
        shape = self.selectedShapeCopy
        #del shape.fill_color
        #del shape.line_color
        if copy:
            self.shapes.append(shape)
            self.selectedShape.selected = False
            self.selectedShape = shape
            self.repaint()
        else:
            shape.label = self.selectedShape.label
            self.deleteSelected()
            self.shapes.append(shape)
        self.selectedShapeCopy = None

    def hideBackroundShapes(self, value):
        self.hideBackround = value
        if self.selectedShape:
            # Only hide other shapes if there is a current selection.
            # Otherwise the user will not be able to select a shape.
            self.setHiding(True)
            self.repaint()

    def setHiding(self, enable=True):
        self._hideBackround = self.hideBackround if enable else False

    def canCloseShape(self):
        return self.drawing() and self.current and len(self.current) > 2

    def mouseDoubleClickEvent(self, ev):
        # We need at least 4 points here, since the mousePress handler
        # adds an extra one before this handler is called.
        if self.canCloseShape() and len(self.current) > 3:
            self.current.popPoint()
            self.finalise()

    def selectShape(self, shape):
        self.deSelectShape()
        shape.selected = True
        self.selectedShape = shape
        self.setHiding()
        self.selectionChanged.emit(True)
        self.update()

    def selectShapePoint(self, point):
        """Select the first shape created which contains this point."""
        self.deSelectShape()
        if self.selectedVertex():  # A vertex is marked for selection.
            index, shape = self.hVertex, self.hShape
            shape.highlightVertex(index, shape.MOVE_VERTEX)
            return

        contours_txt = open("#selfshapes.txt", 'w')
        contours_txt.write(str(self.shapes))
        contours_txt.close()

        for shape in reversed(self.shapes):
            if self.isVisible(shape) and shape.containsPoint(point):
                shape.selected = True
                self.selectedShape = shape
                self.calculateOffsets(shape, point)
                self.setHiding()
                self.selectionChanged.emit(True)
                return

    def calculateOffsets(self, shape, point):
        rect = shape.boundingRect()
        x1 = rect.x() - point.x()
        y1 = rect.y() - point.y()
        x2 = (rect.x() + rect.width()) - point.x()
        y2 = (rect.y() + rect.height()) - point.y()
        self.offsets = QPointF(x1, y1), QPointF(x2, y2)

    def boundedMoveVertex(self, pos):
        index, shape = self.hVertex, self.hShape
        point = shape[index]
        if self.outOfPixmap(pos):
            pos = self.intersectionPoint(point, pos)
        shape.moveVertexBy(index, pos - point)

    def boundedMoveShape(self, shape, pos):
        if self.outOfPixmap(pos):
            return False  # No need to move
        o1 = pos + self.offsets[0]
        if self.outOfPixmap(o1):
            pos -= QPointF(min(0, o1.x()), min(0, o1.y()))
        o2 = pos + self.offsets[1]
        if self.outOfPixmap(o2):
            pos += QPointF(min(0,
                               self.pixmap.width() - o2.x()),
                           min(0,
                               self.pixmap.height() - o2.y()))
        # The next line tracks the new position of the cursor
        # relative to the shape, but also results in making it
        # a bit "shaky" when nearing the border and allows it to
        # go outside of the shape's area for some reason. XXX
        #self.calculateOffsets(self.selectedShape, pos)
        dp = pos - self.prevPoint
        if dp:
            shape.moveBy(dp)
            self.prevPoint = pos
            return True
        return False

    def deSelectShape(self):
        if self.selectedShape:
            self.selectedShape.selected = False
            self.selectedShape = None
            self.setHiding(False)
            self.selectionChanged.emit(False)
            self.update()

    def deleteSelected(self):
        if self.selectedShape:
            shape = self.selectedShape
            self.shapes.remove(self.selectedShape)
            self.selectedShape = None
            self.update()
            return shape

    def copySelectedShape(self):
        if self.selectedShape:
            shape = self.selectedShape.copy()
            self.deSelectShape()
            self.shapes.append(shape)
            shape.selected = True
            self.selectedShape = shape
            self.boundedShiftShape(shape)
            return shape

    def boundedShiftShape(self, shape):
        # Try to move in one direction, and if it fails in another.
        # Give up if both fail.
        point = shape[0]
        offset = QPointF(2.0, 2.0)
        self.calculateOffsets(shape, point)
        self.prevPoint = point
        if not self.boundedMoveShape(shape, point - offset):
            self.boundedMoveShape(shape, point + offset)

    def paintEvent(self, event):
        if not self.pixmap:
            return super(Canvas, self).paintEvent(event)

        p = self._painter
        p.begin(self)
        p.setRenderHint(QPainter.Antialiasing)
        p.setRenderHint(QPainter.HighQualityAntialiasing)
        p.setRenderHint(QPainter.SmoothPixmapTransform)

        p.scale(self.scale, self.scale)
        p.translate(self.offsetToCenter())

        p.drawPixmap(0, 0, self.pixmap)
        Shape.scale = self.scale
        for shape in self.shapes:
            if (shape.selected
                    or not self._hideBackround) and self.isVisible(shape):
                shape.fill = shape.selected or shape == self.hShape
                shape.paint(p)
        if self.current:
            self.current.paint(p)
            self.line.paint(p)
        if self.selectedShapeCopy:
            self.selectedShapeCopy.paint(p)

        p.end()

    def transformPos(self, point):
        """Convert from widget-logical coordinates to painter-logical coordinates."""
        return point / self.scale - self.offsetToCenter()

    def offsetToCenter(self):
        s = self.scale
        area = super(Canvas, self).size()
        w, h = self.pixmap.width() * s, self.pixmap.height() * s
        aw, ah = area.width(), area.height()
        x = (aw - w) / (2 * s) if aw > w else 0
        y = (ah - h) / (2 * s) if ah > h else 0
        return QPointF(x, y)

    def outOfPixmap(self, p):
        w, h = self.pixmap.width(), self.pixmap.height()
        return not (0 <= p.x() <= w and 0 <= p.y() <= h)

    def finalise(self):
        assert self.current
        self.current.close()
        self.shapes.append(self.current)
        self.current = None
        self.setHiding(False)
        self.newShape.emit()
        self.update()

    def closeEnough(self, p1, p2):
        #d = distance(p1 - p2)
        #m = (p1-p2).manhattanLength()
        #print "d %.2f, m %d, %.2f" % (d, m, d - m)
        return distance(p1 - p2) < self.epsilon

    def intersectionPoint(self, p1, p2):
        # Cycle through each image edge in clockwise fashion,
        # and find the one intersecting the current line segment.
        # http://paulbourke.net/geometry/lineline2d/
        size = self.pixmap.size()
        points = [(0, 0), (size.width(), 0), (size.width(), size.height()),
                  (0, size.height())]
        x1, y1 = p1.x(), p1.y()
        x2, y2 = p2.x(), p2.y()
        d, i, (x, y) = min(self.intersectingEdges((x1, y1), (x2, y2), points))
        x3, y3 = points[i]
        x4, y4 = points[(i + 1) % 4]
        if (x, y) == (x1, y1):
            # Handle cases where previous point is on one of the edges.
            if x3 == x4:
                return QPointF(x3, min(max(0, y2), max(y3, y4)))
            else:  # y3 == y4
                return QPointF(min(max(0, x2), max(x3, x4)), y3)
        return QPointF(x, y)

    def intersectingEdges(self, (x1, y1), (x2, y2), points):
        """For each edge formed by `points', yield the intersection
        with the line segment `(x1,y1) - (x2,y2)`, if it exists.
        Also return the distance of `(x2,y2)' to the middle of the
        edge along with its index, so that the one closest can be chosen."""
        for i in xrange(4):
            x3, y3 = points[i]
            x4, y4 = points[(i + 1) % 4]
            denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)
            nua = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)
            nub = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)
            if denom == 0:
                # This covers two cases:
                #   nua == nub == 0: Coincident
                #   otherwise: Parallel
                continue
            ua, ub = nua / denom, nub / denom
            if 0 <= ua <= 1 and 0 <= ub <= 1:
                x = x1 + ua * (x2 - x1)
                y = y1 + ua * (y2 - y1)
                m = QPointF((x3 + x4) / 2, (y3 + y4) / 2)
                d = distance(m - QPointF(x2, y2))
                yield d, i, (x, y)
Beispiel #35
0
def create_pyramid(position, size, color):
    pyramid, coordinates, I, n_coords = get_pyramid(size, color)
    pyramid = Shape("pyramid", pyramid, coordinates, I, position, size, color,
                    n_coords)
    return pyramid
Beispiel #36
0
def run(dims: Tuple[int, int] = (400, 400)):
    reduced_dims = (dims[0] // 10, dims[1] // 10)
    pygame.init()
    screen = pygame.display.set_mode(dims)
    display_surf = pygame.Surface(reduced_dims)
    clock = pygame.time.Clock()
    rate = 5
    done = False

    grid = Grid(reduced_dims)
    current_shape = Shape(reduced_dims)

    while not done:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                done = True
            elif event.type == KEYDOWN and event.key == K_LEFT:
                current_shape.move("l", grid.block_positions)
            elif event.type == KEYDOWN and event.key == K_RIGHT:
                current_shape.move("r", grid.block_positions)
            elif event.type == KEYDOWN and event.key == K_UP:
                current_shape.rotate(grid.block_positions)
            elif event.type == KEYDOWN and event.key == K_DOWN:
                current_shape.drop(grid.block_positions)

        grid.draw_grid(display_surf)
        current_shape.draw_shape(display_surf)

        current_shape.step(grid.block_positions)

        if not current_shape.can_move:
            if current_shape.game_over:
                grid.game_over(display_surf, screen, dims, clock)
                for event in pygame.event.get():
                    if event.type == KEYDOWN and event.key == "K_SPACE":
                        print("restarting")
                        grid = Grid(reduced_dims)
                        current_shape = Shape(reduced_dims)
                    else:
                        sys.exit(0)

            grid.update(current_shape)
            current_shape = Shape(reduced_dims)
            rate = grid.clear_line(rate)

        surf = pygame.transform.scale(display_surf, dims)
        screen.blit(surf, (0, 0))
        pygame.display.update()

        clock.tick(int(rate))
Beispiel #37
0
 def __init__(self, centre_x, centre_y, width, height, name='Rectangle'):
     Shape.__init__(self, centre_x, centre_y, name)
     self.height = height
     self.width = width
Beispiel #38
0
	def __init__(self, bbox, m, b, vel=[0.0, 0.0]):
		Shape.__init__(self, bbox, vel=vel)
		self.m = m
		self.b = b
Beispiel #39
0
    def __init__(self, refdef, component):
        """
        """

        self._refdef = refdef
        self._layer = component.get('layer') or 'top'

        self._rotate = component.get('rotate') or 0
        self._rotate_point = utils.toPoint(component.get('rotate-point') or [0, 0])
        self._scale = component.get('scale') or 1
        self._location = component.get('location') or [0, 0]

        # Get footprint definition and shapes
        try:
            self._footprint_name = component['footprint']
        except:
            msg.error("Cannot find a 'footprint' name for refdef %s." % refdef)

        fname = os.path.join(config.cfg['base-dir'],
                             config.cfg['locations']['components'],
                             self._footprint_name + '.json')
        footprint_dict = utils.dictFromJsonFile(fname)
        footprint = Footprint(footprint_dict)
        footprint_shapes = footprint.getShapes()

        #------------------------------------------------        
        # Apply component-specific modifiers to footprint
        #------------------------------------------------
        for sheet in ['copper', 'soldermask', 'solderpaste', 'silkscreen', 'assembly', 'drills']:
            for layer in utils.getSurfaceLayers() + utils.getInternalLayers():
                for shape in footprint_shapes[sheet][layer]:
                    # In order to apply the rotation we need to adust the location
                    # of each element
                    shape.rotateLocation(self._rotate, self._rotate_point)

                    shape.transformPath(self._scale,
                                        self._rotate,
                                        self._rotate_point,
                                        False,
                                        True)

        #--------------------------------------
        # Remove silkscreen and assembly shapes
        #--------------------------------------
        for sheet in ['silkscreen','assembly']:
            
            try:
                shapes_dict = component[sheet].get('shapes') or {}
            except:
                shapes_dict = {}

            # If the setting is to not show silkscreen shapes for the
            # component, delete the shapes from the shapes' dictionary
            if shapes_dict.get('show') == False:
                for pcb_layer in utils.getSurfaceLayers():
                    footprint_shapes[sheet][pcb_layer] = []



        #----------------------------------------------------------
        # Add silkscreen and assembly reference designator (refdef)
        #----------------------------------------------------------
        for sheet in ['silkscreen','assembly']:
            
            try:
                refdef_dict = component[sheet].get('refdef') or {}
            except:
                refdef_dict = {}
     
            if refdef_dict.get('show') != False:
                layer = refdef_dict.get('layer') or 'top'
         
                # Rotate the refdef; if unspecified the rotation is the same as
                # the rotation of the component
                refdef_dict['rotate'] = refdef_dict.get('rotate') or 0
 
                # Sometimes you'd want to keep all refdefs at the same angle
                # and not rotated with the component
                if refdef_dict.get('rotate-with-component') != False:
                    refdef_dict['rotate'] += self._rotate

                refdef_dict['rotate-point'] = utils.toPoint(refdef_dict.get('rotate-point')) or self._rotate_point
     
                refdef_dict['location'] = refdef_dict.get('location') or [0, 0]
                refdef_dict['type'] = 'text'
                refdef_dict['value'] = refdef
                refdef_dict['font-family'] = (config.stl['layout'][sheet]['refdef'].get('font-family') or 
                                              config.stl['defaults']['font-family'])
                refdef_dict['font-size'] = (config.stl['layout'][sheet]['refdef'].get('font-size') or 
                                              "2mm")
                refdef_shape = Shape(refdef_dict)
                refdef_shape.is_refdef = True
                refdef_shape.rotateLocation(self._rotate, self._rotate_point)
                style = Style(refdef_dict, sheet, 'refdef')
                refdef_shape.setStyle(style)

                # Add the refdef to the silkscreen/assembly list. It's
                # important that this is added at the very end since the
                # plcament process assumes the refdef is last
                footprint_shapes[sheet][layer].append(refdef_shape)


        #------------------------------------------------------
        # Invert 'top' and 'bottom' if layer is on the 'bottom'
        #------------------------------------------------------
        if self._layer == 'bottom':
            layers = utils.getSurfaceLayers()
            layers_reversed = reversed(utils.getSurfaceLayers())
           
            for sheet in ['copper', 'soldermask', 'solderpaste', 'silkscreen', 'assembly']:
                sheet_dict = footprint_shapes[sheet]
                # TODO: this nasty hack won't work for more than two
                # layers, so when 2+ are supported this needs to be
                # revisited
                for i in range(0,len(layers)-1):
                    sheet_dict['temp'] = sheet_dict.pop(layers[i])
                    sheet_dict[layers[i]] = sheet_dict.pop(layers[len(layers)-1-i])
                    sheet_dict[layers[len(layers)-1-i]] = sheet_dict.pop('temp')

        self._footprint_shapes = footprint_shapes
Beispiel #40
0
 def __init__(self):
     Shape.__init__(self)
     self.drawing_type = GL_TRIANGLES
     self.setup_buffers()