Beispiel #1
0
    def draw_filled_hexagon(self, position, fill_color, number=None):
        qpainter = self.painter

        pen = data.QPen(data.Qt.SolidLine)
        pen.setColor(fill_color)
        brush = data.QBrush(data.Qt.SolidPattern)
        brush.setColor(fill_color)
        qpainter.setBrush(brush)
        qpainter.setPen(pen)
        hex_points = list(
            HexBuilder.generate_hexagon_points(self.edge_length, position))
        x_correction = self.edge_length / 2
        y_correction = self.edge_length / (2 * math.tan(math.radians(30)))
        hex_points = [(x - x_correction, y - y_correction)
                      for x, y in hex_points]
        hex_qpoints = [data.QPoint(*x) for x in hex_points]
        qpainter.drawPolygon(*hex_qpoints)

        if (self.SHOW_FIELD_NUMBERS == True) and (number != None):
            font = data.QFont('Courier', 8)
            font.setBold(True)
            qpainter.setFont(font)
            pen = data.QPen(data.Qt.SolidLine)
            pen.setColor(data.QColor(0, 0, 0))
            qpainter.setPen(pen)

            font_metric = data.QFontMetrics(font)
            x = position[0] - font_metric.width(str(number)) / 2
            y = position[1] + font_metric.height() / 4

            qpainter.drawText(data.QPoint(x, y), str(number))
Beispiel #2
0
 def draw_line_hexagon(self, 
                       position, 
                       line_width, 
                       line_color,
                       paint_enabled=[True,True,True,True,True,True],
                       shadow=False):
     qpainter = self.painter
     
     if line_width == 0:
         return
     
     pen = data.QPen(data.Qt.SolidLine)
     pen.setCapStyle(data.Qt.RoundCap)
     pen.setJoinStyle(data.Qt.RoundJoin)
     pen.setWidth(line_width)
     pen.setColor(line_color)
     qpainter.setPen(pen)
     hex_points = list(
         HexBuilder.generate_hexagon_points(self.edge_length, position)
     )
     x_correction = self.edge_length / 2
     y_correction = self.edge_length / (2 * math.tan(math.radians(30)))
     hex_points = [(x-x_correction, y-y_correction) for x, y in hex_points]
     hex_lines = []
     
     for i in range(len(hex_points)):
         if paint_enabled[i] == False:
             continue
         n = i + 1
         if n > (len(hex_points)-1):
             n = 0
         hex_lines.append(
             data.QLine(
                 data.QPoint(*hex_points[i]), 
                 data.QPoint(*hex_points[n])
             )
         )
     if hex_lines:
         if shadow == True:
             shadow_0_color = data.QColor(line_color)
             shadow_0_color.setAlpha(64)
             shadow_1_color = data.QColor(line_color)
             shadow_1_color.setAlpha(128)
             
             pen.setWidth(line_width*2.0)
             pen.setColor(shadow_0_color)
             qpainter.setPen(pen)
             qpainter.drawLines(*hex_lines)
             pen.setWidth(line_width*1.5)
             pen.setColor(shadow_1_color)
             qpainter.setPen(pen)
             qpainter.drawLines(*hex_lines)
             pen.setWidth(line_width)
             pen.setColor(line_color)
             qpainter.setPen(pen)
             qpainter.drawLines(*hex_lines)
         else:
             qpainter.drawLines(*hex_lines)
Beispiel #3
0
    def draw_full_hexagon(self, position, fill_color, line_width, line_color):
        qpainter = self.painter

        pen = data.QPen(data.Qt.SolidLine)
        pen.setColor(line_color)
        pen.setCapStyle(data.Qt.RoundCap)
        pen.setWidth(line_width)
        brush = data.QBrush(data.Qt.SolidPattern)
        brush.setColor(fill_color)
        qpainter.setBrush(brush)
        qpainter.setPen(pen)
        hex_points = list(
            HexBuilder.generate_hexagon_points(self.edge_length, position))
        x_correction = self.edge_length / 2
        y_correction = self.edge_length / (2 * math.tan(math.radians(30)))
        hex_points = [(x - x_correction, y - y_correction)
                      for x, y in hex_points]
        hex_qpoints = [data.QPoint(*x) for x in hex_points]
        qpainter.drawPolygon(*hex_qpoints)
Beispiel #4
0
    def draw_line_hexagon_no_double_paint(
            self,
            position,
            line_width,
            line_color,
            paint_enabled=[True, True, True, True, True, True],
            shadow=False):
        qpainter = self.painter

        if line_width == 0:
            return

        pen = data.QPen(data.Qt.SolidLine)
        pen.setCapStyle(data.Qt.RoundCap)
        pen.setJoinStyle(data.Qt.RoundJoin)
        pen.setWidth(line_width)
        pen.setColor(line_color)
        qpainter.setPen(pen)
        hex_points = list(
            HexBuilder.generate_hexagon_points(self.edge_length, position))
        x_correction = self.edge_length / 2
        y_correction = self.edge_length / (2 * math.tan(math.radians(30)))
        hex_points = [(x - x_correction, y - y_correction)
                      for x, y in hex_points]
        hex_lines = []

        def line_test(in_line):
            DIFF = 3
            line = in_line
            reversed_line = (line[1], line[0])
            x1, y1 = line[0]
            x2, y2 = line[1]
            xr1, yr1 = reversed_line[0]
            xr2, yr2 = reversed_line[1]
            for l in self.stored_lines:
                xl1, yl1 = l[0]
                xl2, yl2 = l[1]
                if (abs(xl1 - x1) < DIFF and abs(yl1 - y1) < DIFF
                        and abs(xl2 - x2) < DIFF and abs(yl2 - y2) < DIFF):
                    if not (line in self.stored_lines):
                        self.stored_lines.append(line)
                        #self.stored_lines.append(reversed_line)
                    return False
                elif (abs(xl1 - xr1) < DIFF and abs(yl1 - yr1) < DIFF
                      and abs(xl2 - xr2) < DIFF and abs(yl2 - yr2) < DIFF):
                    if not (reversed_line in self.stored_lines):
                        self.stored_lines.append(line)
                        #self.stored_lines.append(reversed_line)
                    return False
            else:
                self.stored_lines.append(line)
                self.stored_lines.append(reversed_line)
                return True

        for i in range(len(hex_points)):
            if paint_enabled[i] == False:
                continue
            n = i + 1
            if n > (len(hex_points) - 1):
                n = 0
            if line_test((hex_points[i], hex_points[n])) == True:
                hex_lines.append(
                    data.QLine(data.QPoint(*hex_points[i]),
                               data.QPoint(*hex_points[n])))
        if hex_lines:
            if shadow == True:
                shadow_0_color = data.QColor(line_color)
                shadow_0_color.setAlpha(64)
                shadow_1_color = data.QColor(line_color)
                shadow_1_color.setAlpha(128)

                pen.setWidth(line_width * 2.0)
                pen.setColor(shadow_0_color)
                qpainter.setPen(pen)
                qpainter.drawLines(*hex_lines)
                pen.setWidth(line_width * 1.5)
                pen.setColor(shadow_1_color)
                qpainter.setPen(pen)
                qpainter.drawLines(*hex_lines)
                pen.setWidth(line_width)
                pen.setColor(line_color)
                qpainter.setPen(pen)
                qpainter.drawLines(*hex_lines)
            else:
                qpainter.drawLines(*hex_lines)