Пример #1
0
 def draw(self, painter, draw_polygon=False):
     if isinstance(painter, QPainter):
         if Settings.show_voronoi:
             pen = QPen(Settings.default_pen)
             if Settings.show_delaunay:
                 pen.setStyle(Qt.DashLine)
             painter.setPen(pen)
             if draw_polygon and self.is_closed() and self.hull:
                 painter.setBrush(Color.get(self.idx))
                 painter.drawPolygon(
                     QPolygon(
                         QPoint(*p)
                         for p in self.hull.points[self.hull.vertices]))
                 return
             for i, ((x1, y1), (x2, y2)) in enumerate(self.ridges):
                 if self.idx > self.ngbrs[i]:
                     painter.drawLine(x1, y1, x2, y2)
         if Settings.show_delaunay:
             pen = QPen(Settings.default_pen)
             painter.setPen(pen)
             for nbr in self.ngbrs:
                 if self.idx > nbr:
                     (x1, y1), (x2, y2) = self.ps.points[
                         self.idx], self.ps.points[nbr]
                     painter.drawLine(x1, y1, x2, y2)
Пример #2
0
 def draw(self, painter):
     if isinstance(painter, QPainter):
         try:
             color = Color.get(self.idx) if not self.ps.region(
                 self.idx).is_closed() else Settings.default_brush
         except IndexError:
             color = Settings.default_brush
         painter.setBrush(color)
         painter.drawEllipse(self.x - Settings.point_size,
                             self.y - Settings.point_size,
                             2 * Settings.point_size,
                             2 * Settings.point_size)
Пример #3
0
class DiscoBehaviour(Behaviour):
    def __init__(self, prefs=None):
        self.color = Color()
        super().__init__(prefs)
        self.set_preferences(prefs)
        self.last_change = None

    def reset(self):
        self.last_change = -1
        pass

    def update(self, fallback_color, now):
        if self.last_change is None:
            self.last_change = now

        delta = (now - self.last_change).total_seconds()
        if delta > self.color_duration:
            self.color.get_next()
            self.last_change = now

        return self.color.get(), False

    def set_preferences(self, preferences):
        super().set_preferences(preferences)
        prefs = safe_load(preferences, "{}".format(self.id(), {}))

        self.bpm = safe_load(prefs, 'bpm', 60)
        self.color.set_colors(safe_load(prefs, 'colors', None))

        self.color_duration = self._bpm_to_pulse_duration(self.bpm)

    def _bpm_to_pulse_duration(self, bpm):
        pulse = 60 / bpm
        while pulse < Behaviour.MIN_BEAT_DURATION:
            pulse = pulse * 2

        return pulse

    def to_string(self):
        return "DiscoBehaviour[bpm:{}, color_duration:{}]"\
            .format(self.bpm, self.color_duration)

    def id(self):
        return Behaviour.DISCO