コード例 #1
0
ファイル: dataset.py プロジェクト: xsyann/mediocre
 def generateData(self, canvas, lines, params):
     scene = QGraphicsScene()
     scene.setSceneRect(canvas)
     group = scene.createItemGroup([])
     for line in lines:
         clone = QGraphicsLineItem(line)
         clone.setLine(line.line())
         clone.setPen(line.pen())
         scene.addItem(clone)
         group.addToGroup(clone)
     pixmaps = []
     for i in xrange(params.count):
         pixmaps.append(self.generateRandom(scene, group, canvas, params))
     return pixmaps
コード例 #2
0
class MarkedHistogram(QWidget):
    """Histogram with color-indication markers

       MarkedHistogram shows a histogram of a data set and an optional
       label for the numeric range of the data set.  Color markers can
       be placed on the histogram by the user and moved interactively,
       either with the mouse or by typing in a particular data value.
       A color button is used to control the color of the "current" marker
       (the one most recently selected with the mouse).  Markers can
       either be vertical bars or squares.  Vertical bars can only be
       moved left/right whereas squares can also be moved up/down.
       Squares are also connected from left to right by line segments.

       A row of associated widgets (such as the marker color button) is
       placed below the histogram.  User-specified widgets can also be
       placed in this row with the add_custom_widget() method.

       Individual markers are grouped into HistogramMarkers instances,
       and several HistogramMarkers instances can be associated with
       a single histogram, though only one instance is active/shown at
       a time.

       MarkedHistogram has the following constructor options:
           [Options noted as init options can only be specified at
        widget creation.  Others can be changed later via the corresponding
        property name.]

        color_button --  controls whether a color button is offered in
            the user interface for changing marker colors.
            default: True

        data_source -- either a string or a 3-tuple.  If a string, then
            no histogram is displayed and instead the string is
            displayed in the histogram area as a text message.
            The first 2 components of a 3-tuple should be the
            minimum and maximum values of the histogram,  The
            third component should either be an array of numbers
            (i.e. the histogram) or a callback function that
            takes as its single argument the number of bins to
            histogram into and that returns a histogram array.
            default: 'no data'

        layout -- [init option] how to organize the megawidget layout.
            Choices are 'single', 'top', and 'below'.  'single'
            should be used when you are using a single histogram
            in your GUI, or histograms that aren't arrayed
            vertically.  'top' and 'below' should be used for
            histograms that are laid out in a vertical array
            ('top' for the top-most one, and 'below' for all
            others).  Certain repeated elements will be omitted
            in 'below' histograms (e.g. some widget labels).
            default: single

        max_label/min_label [init options] show the max/min histogram
            values as labels below the histogram on the right/left.
            If neither is True, then the range will be shown in a
            single label widget below the histogram.
            default: False

        redraw_delay -- amount of time (in seconds) to delay between
            needing to redraw and actually starting to redraw.
            Used to avoid multiple (possibly slow) redraws during
            a resize.
            default: 0.25

        scaling -- how to scale the vertical height of the histogram.
            Either 'logarithmic' or 'linear'.
            default: logarithmic

        select_callback -- [init option] function to call when the
            "current" marker changes.  The function receives 4
            argments:  previous active marker set/marker,
            new active marker set/marker.  The marker set can
            be None to indicate no active marker set and the
            marker can be None if no marker was/is current.

        show_marker_help -- [init option] whether to show the help
            text over the histogram describing how to add/delete
            markers.
            default: True

        status_line -- function to use to output messages (such as
            warning when trying to add more markers than allowed).
            The function should take a single string argument.
            default: None

        value_label -- [init option] label to use next to the
            entry widget describing the current marker value.
            default: 'Value'

        value_width -- width of the current marker value entry widget.
            default: 7

       Constructor options that begin with 'Markers_' specify default
       constructor options for HistogramMarkers objects created in the
       add_markers method (e.g. Markers_connect_color='red' will supply
       connect_color='red' to the HistogramMarkers constructor).  Options
       for specific instances can still be provided to the add_ markers()
       method as keyword arguments (without the 'Markers_' prefix).
    """
    def __init__(self,
                 *args,
                 color_button=True,
                 data_source='no data',
                 layout='single',
                 max_label=False,
                 min_label=False,
                 redraw_delay=0.25,
                 scaling='logarithmic',
                 select_callback=None,
                 show_marker_help=True,
                 status_line=None,
                 value_label='Value',
                 value_width=7,
                 **kw):

        # Get HistogramMarkers options and initialise base class
        self._histogram_markers_kw = markers_kw = {}
        for opt_name in list(kw.keys()):
            if opt_name.startswith('Markers_'):
                markers_kw[opt_name[8:]] = kw.pop(opt_name)
        super().__init__(*args, **kw)

        # initialize variables
        self._layout = layout
        self.status_line = status_line
        self._show_marker_help = show_marker_help
        self._active_markers = None
        self._markers = []
        self._markable = False
        self._drag_marker = None
        self._scaling = scaling
        self._select_callback = select_callback
        if select_callback:
            self._prev_markers = None
            self._prev_marker = None

        overall_layout = QVBoxLayout()
        self.setLayout(overall_layout)

        # Create the add/delete marker help
        if show_marker_help and layout != 'below':
            self._marker_help = QLabel(
                "Ctrl-click on histogram to add or delete thresholds")
            self._marker_help.setAlignment(Qt.AlignCenter)
            overall_layout.addWidget(self._marker_help)
        else:
            self._marker_help = None

        # Create the data area
        class HistFrame(QFrame):
            def sizeHint(self):
                return QSize(300, 64)

        data_frame = QFrame()
        data_frame.setLineWidth(1)
        data_frame.setMidLineWidth(2)
        data_frame.setFrameStyle(data_frame.Panel | data_frame.Sunken)
        data_frame.setContentsMargins(0, 0, 0, 0)
        data_frame_layout = QHBoxLayout()
        data_frame.setLayout(data_frame_layout)
        self._data_widgets = QStackedWidget()
        data_frame_layout.addWidget(self._data_widgets)

        # Crate the histogram widget
        self._hist_scene = QGraphicsScene()
        self._hist_bars = self._hist_scene.createItemGroup([])
        self._hist_view = QGraphicsView(self._hist_scene)
        self._hist_view.resizeEvent = self._redraw
        self._hist_scene.mousePressEvent = lambda event: self._add_or_delete_marker_cb(event) \
            if event.modifiers() & mod_key_info("control")[0] else self._select_marker_cb(event)
        self._hist_scene.mouseMoveEvent = lambda event: self._move_marker_cb(event) \
            if self._drag_marker else super().mouseMoveEvent(event)
        self._hist_scene.mouseReleaseEvent = self._button_up_cb
        self._redraw_timer = QTimer()
        self._redraw_timer.timeout.connect(self._redraw_cb)
        self._redraw_timer.start(1000 * redraw_delay)
        self._redraw_timer.stop()
        self._data_widgets.addWidget(self._hist_view)

        # Create the histogram replacement label
        self._no_histogram_label = QLabel()
        self._no_histogram_label.setAlignment(Qt.AlignCenter)
        self._data_widgets.addWidget(self._no_histogram_label)
        overall_layout.addWidget(self._data_widgets, stretch=1)

        # Create range label(s)
        self._widget_area = QWidget()
        self._widget_layout = QHBoxLayout()
        self._min_label = self._max_label = None
        if min_label or max_label:
            min_max_layout = QHBoxLayout()
            if min_label:
                self._min_label = QLabel()
                min_max_layout.addWidget(self._min_label,
                                         alignment=Qt.AlignLeft & Qt.AlignTop)

            if max_label:
                self._max_label = QLabel()
                min_max_layout.addWidget(self._max_label,
                                         alignment=Qt.AlignRight & Qt.AlignTop)
            overall_layout.addLayout(min_max_layout)
        else:
            self._range_label = QLabel()
            if layout == 'below':
                self._widget_layout.addWidget(self._range_label)
            else:
                lab = QLabel("Range")
                if layout == 'single':
                    self._widget_layout.addWidget(lab, alignment=Qt.AlignRight)
                    self._widget_layout.addWidget(self._range_label,
                                                  alignment=Qt.AlignLeft)
                else:  # layout == 'top'
                    range_layout = QVBoxLayout()
                    range_layout.addWidget(lab, alignment=Qt.AlignBottom)
                    range_layout.addWidget(self._range_label,
                                           alignment=Qt.AlignTop)
                    self._widget_layout.addLayout(range_layout)
        self._widget_area.setLayout(self._widget_layout)
        overall_layout.addWidget(self._widget_area)

        # Create value widget
        self._value_entry = QLineEdit()
        self._value_entry.setEnabled(False)
        self._value_entry.returnPressed.connect(self._set_value_cb)
        self.value_width = value_width
        if layout == 'below':
            self._widget_layout.addWidget(self._value_entry)
        else:
            lab = QLabel(value_label)
            if layout == 'single':
                self._widget_layout.addWidget(lab, alignment=Qt.AlignRight)
                self._widget_layout.addWidget(self._value_entry,
                                              alignment=Qt.AlignLeft)
            else:
                value_layout = QVBoxLayout()
                value_layout.addWidget(lab, alignment=Qt.AlignBottom)
                value_layout.addWidget(self._value_entry,
                                       alignment=Qt.AlignTop)
                self._widget_layout.addLayout(value_layout)

        # Create color button widget
        from .color_button import ColorButton
        self._color_button = cb = ColorButton()
        cb.color_changed.connect(
            lambda rgba8: self._color_button_cb([c / 255.0 for c in rgba8]))
        cb.setEnabled(False)
        self._color_button_label = cbl = QLabel("Color")
        if layout == 'below':
            self._widget_layout.addWidget(self._color_button)
        else:
            if layout == 'single':
                self._widget_layout.addWidget(cbl, alignment=Qt.AlignRight)
                self._widget_layout.addWidget(cb, alignment=Qt.AlignLeft)
            else:
                color_layout = QVBoxLayout()
                color_layout.addWidget(cbl, alignment=Qt.AlignBottom)
                color_layout.addWidget(cb, alignment=Qt.AlignTop)
                self._widget_layout.addLayout(color_layout)
        self._color_button_shown = True

        # Show the histogram or the no-data label
        self.data_source = data_source

    def activate(self, markers):
        """Make the given set of markers the currently active set

           Any previously-active set will be hidden.
        """

        if markers is not None and markers not in self._markers:
            raise ValueError("activate() called with bad value")
        if markers == self._active_markers:
            return
        if self._active_markers is not None:
            self._active_markers._hide()
        elif self.layout != 'below' and self._show_marker_help:
            self._marker_help.setHidden(False)
        self._active_markers = markers
        if self._active_markers is not None:
            self._active_markers.shown = True
            self._set_sel_marker(self._active_markers._sel_marker)
        else:
            if self.layout != 'below' and self._show_marker_help:
                self._marker_help.setHidden(True)
            if self._select_callback:
                if self._prev_marker is not None:
                    self._select_callback(self._prev_markers,
                                          self._prev_marker, None, None)
                self._prev_markers = None
                self._prev_marker = None

    def add_custom_widget(self, widget, left_side=True):
        self._widget_layout.addWidget(0 if left_side else -1, widget)

    def add_markers(self, activate=True, **kw):
        """Create and return a new set of markers.

           If 'activate' is true, the new set will also become
           the active set.  Other keyword arguments will be passed
           to the HistogramMarkers constructor.
        """
        final_kw = {k: v for k, v in self._histogram_markers_kw.items()}
        final_kw.update(kw)
        final_kw['histogram'] = self
        markers = HistogramMarkers(**final_kw)
        self._markers.append(markers)
        if activate:
            self.activate(markers)
        return markers

    @property
    def color_button(self):
        return self._color_button_shown

    @color_button.setter
    def color_button(self, show):
        if show == self._color_button_shown:
            return
        if self.layout != 'below':
            self._color_button_label.setHidden(not show)
        self._color_button.setHidden(not show)
        self._color_button_shown = show

    def current_marker_info(self):
        """Identify the marker currently selected by the user.
           
           Returns a HistogramMarkers instance and a marker.
           The instance will be None if no marker set has been
           activated.  The marker will be None if no marker has
           been selected by the user.
        """
        if self._active_markers is None:
            return None, None
        return self._active_markers, self._active_markers._sel_marker

    @property
    def data_source(self):
        return self._data_source

    @data_source.setter
    def data_source(self, data_source):
        self._data_source = data_source
        self._new_data()

    def delete_markers(self, markers):
        """Delete the given set of markers.

           If the markers were active, there will be no active set
           of markers afterward.
        """
        if markers not in self._markers:
            raise ValueError("Bad value for delete()")
        if markers == self._active_markers:
            self.activate(None)
        self._markers.remove(markers)

    @property
    def layout(self):
        return self._layout

    @property
    def redraw_delay(self):
        return self._redraw_timer.interval() / 1000.0

    @redraw_delay.setter
    def redraw_delay(self, secs):
        self._redraw_timer.setInterval(secs * 1000)

    @property
    def scaling(self):
        return self._scaling

    @scaling.setter
    def scaling(self, scaling):
        if self._scaling != scaling:
            self._scaling = scaling
            self._redraw_cb()

    def snapshot_data(self):
        info = {
            'version': 1,
            'draw_min': self._draw_min,
            'draw_max': self._draw_max,
            'markers': [markers.snapshot_data() for markers in self._markers],
        }
        if self._active_markers is None:
            info['active markers'] = None
        else:
            info['active markers'] = self._markers.index(self._active_markers)
        if self['color_button']:
            info['color well'] = self._color_button.color
        else:
            info['color well'] = None
        return info

    def snapshot_restore(self, data):
        self._draw_min = data['draw_min']
        self._draw_max = data['draw_max']
        if data['color well'] is not None:
            self._color_button.color = data['color well']
        if len(data['markers']) != len(self._markers):
            # don't know how to deal with this situation
            return
        for markers, markers_data in zip(self._markers, data['markers']):
            markers.snapshot_restore(markers_data)
        if data['active markers'] is not None:
            self.activate(self._markers[data['active markers']])
            self._set_sel_marker(self._active_markers._sel_marker)

    @property
    def value_width(self):
        return self._value_width

    @value_width.setter
    def value_width(self, vw):
        self._value_width = vw
        ve = self._value_entry
        fm = ve.fontMetrics()
        tm = ve.textMargins()
        cm = ve.contentsMargins()
        w = vw * fm.width('w') + tm.left() + tm.right() + cm.left() + cm.right(
        ) + 8
        ve.setMaximumWidth(w)

    def _abs2rel(self, abs_xy):
        x, y = abs_xy
        rel_x = (x - self._min_val) / float(self._max_val - self._min_val)
        rel_y = y / float(self._ymax)
        return rel_x, rel_y

    def _abs_xy(self, scene_xy):
        scene_x, scene_y = scene_xy
        dy = min(max(self._bottom - scene_y, 0), self._hist_height - 1)
        if self.scaling == 'logarithmic':
            exp = dy / float(self._hist_height - 1)
            abs_y = (self._max_height + 1)**exp - 1
        else:
            abs_y = self._max_height * dy / float(self._hist_height - 1)

        cx = scene_x - self._border
        num_bins = len(self._bins)
        if num_bins == self._hist_width:
            fract = cx / (num_bins - 1)
            abs_x = self._min_val + fract * (self._max_val - self._min_val)
        elif num_bins == 2:
            abs_x = self._min_val + (self._max_val - self._min_val) * (
                2 * cx / self._hist_width - 0.5)
        else:
            extra = self._hist_width / (2.0 * (num_bins - 1))
            abs_x = self._min_val + (self._max_val - self._min_val) * (
                cx - extra) / (self._hist_width - 2.0 * extra)
        abs_x = max(self._min_val, abs_x)
        abs_x = min(self._max_val, abs_x)
        return abs_x, abs_y

    def _add_or_delete_marker_cb(self, event=None):
        if self._active_markers is None:
            return

        marker = self._active_markers._pick_marker(event.scenePos())

        if marker is None:
            max_marks = self._active_markers.max_marks
            if max_marks is not None and len(
                    self._active_markers) >= max_marks:
                if self.status_line:
                    self.status_line("Maximum of %d markers\n" % max_marks)
                return
            xy = self._abs_xy((event.scenePos().x(), event.scenePos().y()))
            if self._active_markers.coord_type == 'relative':
                xy = self._abs2rel(xy)
            sel_marker = self._active_markers._sel_marker
            if sel_marker:
                color = sel_marker.rgba
            else:
                color = self._active_markers.new_color
            marker = self._active_markers.append((xy, color))
            self._set_sel_marker(marker, drag_start=event)
        else:
            min_marks = self._active_markers.min_marks
            if min_marks is not None and len(
                    self._active_markers) <= min_marks:
                if self.status_line:
                    self.status_line("Minimum of %d markers\n" % min_marks)
                return
            self._active_markers.remove(marker)
            self._set_sel_marker(None)

    def _button_up_cb(self, event=None):
        if self._drag_marker:
            self._drag_marker = None
            if self._active_markers.move_callback:
                self._active_markers.move_callback('end')

    def _scene_xy(self, abs_xy):
        # minimum is in the _center_ of the first bin,
        # likewise, maximum is in the center of the last bin

        abs_x, abs_y = abs_xy

        abs_y = max(0, abs_y)
        abs_y = min(self._max_height, abs_y)
        if self.scaling == 'logarithmic':
            import math
            abs_y = math.log(abs_y + 1)
        scene_y = self._bottom - (self._hist_height - 1) * (abs_y /
                                                            self._max_height)

        abs_x = max(self._min_val, abs_x)
        abs_x = min(self._max_val, abs_x)
        num_bins = len(self._bins)
        if num_bins == self._hist_width:
            bin_width = (self._max_val - self._min_val) / float(num_bins - 1)
            left_edge = self._min_val - 0.5 * bin_width
            scene_x = int((abs_x - left_edge) / bin_width)
        else:
            # histogram is effectively one bin wider (two half-empty bins on each end)
            if num_bins == 1:
                scene_x = 0.5 * (self._hist_width - 1)
            else:
                extra = (self._max_val - self._min_val) / (2.0 *
                                                           (num_bins - 1))
                eff_min_val = self._min_val - extra
                eff_max_val = self._max_val + extra
                eff_range = float(eff_max_val - eff_min_val)
                scene_x = (self._hist_width - 1) * (abs_x -
                                                    eff_min_val) / eff_range
        return self._border + scene_x, scene_y

    def _color_button_cb(self, rgba):
        m = self._active_markers._sel_marker
        if not m:
            if self.status_line:
                self.status_line("No marker selected")
            return
        m.rgba = rgba

    def _marker2abs(self, marker):
        if self._active_markers.coord_type == 'absolute':
            return marker.xy
        else:
            return self._rel2abs(marker.xy)

    def _move_cur_marker(self, x, yy=None):
        #
        # Don't allow dragging out of the scene box.
        #
        m = self._active_markers._sel_marker
        if x < self._min_val:
            x = self._min_val
        elif x > self._max_val:
            x = self._max_val
        if yy is None:
            y = m.xy[1]
        else:
            y = yy
            if y < 0:
                y = 0
            elif y > self._ymax:
                y = self._ymax

        if self._active_markers.coord_type == 'absolute':
            m.xy = (x, y)
        else:
            m.xy = self._abs2rel((x, y))
        if yy is None:
            m.xy = (m.xy[0], y)

        self._set_value_entry(x)

        self._active_markers._update_plot()

        if self._active_markers.move_callback:
            self._active_markers.move_callback(m)

    def _move_marker_cb(self, event):
        mouse_xy = self._abs_xy((event.scenePos().x(), event.scenePos().y()))
        dx = mouse_xy[0] - self._last_mouse_xy[0]
        dy = mouse_xy[1] - self._last_mouse_xy[1]
        self._last_mouse_xy = mouse_xy

        if event.modifiers() & mod_key_info("shift")[0]:
            dx *= .1
            dy *= .1

        m = self._drag_marker
        mxy = self._marker2abs(m)
        x, y = mxy[0] + dx, mxy[1] + dy

        self._move_cur_marker(x, y)

    def _new_data(self):
        ds = self.data_source
        if isinstance(ds, str):
            self._no_histogram_label.setText(ds)
            self._data_widgets.setCurrentWidget(self._no_histogram_label)
            if self._min_label:
                self._min_label.setText("")
            if self._max_label:
                self._max_label.setText("")
            if self.layout != 'below' and self._show_marker_help:
                self._marker_help.setHidden(True)
            self._widget_area.setHidden(True)
        else:
            self._data_widgets.setCurrentWidget(self._hist_view)
            if self.layout != 'below' and self._show_marker_help:
                self._marker_help.setHidden(False)
            self._widget_area.setHidden(False)
        self._draw_min = self._draw_max = None
        self._redraw_cb()

    def _redraw(self, event=None):
        self._markable = False
        self._redraw_timer.start()

    def _redraw_cb(self):
        self._redraw_timer.stop()
        ds = self.data_source
        if isinstance(ds, str):
            # displaying a text label right now
            return
        view = self._hist_view
        scene = self._hist_scene
        hist_size = view.viewport().size()
        self._hist_width, self._hist_height = hist_width, hist_height = hist_size.width(
        ), hist_size.height()
        self._min_val, self._max_val, self._bins = ds
        filled_range = self._max_val - self._min_val
        empty_ranges = [0, 0]
        if self._draw_min != None:
            empty_ranges[0] = self._min_val - self._draw_min
            self._min_val = self._draw_min
        if self._draw_max != None:
            empty_ranges[1] = self._draw_max - self._max_val
            self._max_val = self._draw_max
        if callable(self._bins):
            if empty_ranges[0] or empty_ranges[1]:
                full_range = filled_range + empty_ranges[0] + empty_ranges[1]
                filled_bins = self._bins(
                    int(hist_width * filled_range / full_range))
                left = [0] * int(hist_width * empty_ranges[0] / full_range)
                right = [0] * (hist_width - len(filled_bins) - len(left))
                self._bins = left + filled_bins + right
            else:
                self._bins = self._bins(hist_width)
        elif empty_ranges[0] or empty_ranges[1]:
            full_range = filled_range + empty_ranges[0] + empty_ranges[1]
            left = [0] * int(len(self._bins) * empty_ranges[0] / full_range)
            right = [0] * int(len(self._bins) * empty_ranges[1] / full_range)
            self._bins = left + self._bins + right
        if self._min_label:
            self._min_label.setText(self._str_val(self._min_val))
        if self._max_label:
            self._max_label.setText(self._str_val(self._max_val))
        if not self._min_label and not self._max_label:
            self._range_label.setText(
                "%s - %s" %
                (self._str_val(self._min_val), self._str_val(self._max_val)))

        bars = self._hist_bars.childItems()
        for bar in bars:
            self._hist_bars.removeFromGroup(bar)
            self._hist_scene.removeItem(bar)

        self._ymax = max(self._bins)
        if self.scaling == 'logarithmic':
            from numpy import array, log, float32
            self._bins = array(self._bins, float32)
            self._bins += 1.0
            log(self._bins, self._bins)

        max_height = max(self._bins)
        self._max_height = max_height
        h_scale = float(hist_height - 1) / max_height
        self._border = border = 0
        bottom = hist_height + border - 1
        self._bottom = bottom

        num_bins = len(self._bins)
        if num_bins == hist_width:
            for b, n in enumerate(self._bins):
                x = border + b
                h = int(h_scale * n)
                line = self._hist_scene.addLine(x, bottom, x, bottom - h)
                self._hist_bars.addToGroup(line)
                line.setZValue(-1)  # keep bars below markers
        else:
            x_scale = (hist_width - 1) / float(num_bins)
            for b, n in enumerate(self._bins):
                x1 = border + b * x_scale
                x2 = border + (b + 1) * x_scale
                h = int(h_scale * n)
                rect = self._hist_scene.addRect(x1, bottom - h, x2 - x1, h)
                self._hist_bars.addToGroup(rect)
                rect.setZValue(-1)  # keep bars below markers
        self._markable = True
        if self._active_markers is not None:
            self._active_markers._update_plot()
            marker = self._active_markers._sel_marker
            if marker:
                self._set_value_entry(self._marker2abs(marker)[0])
        self._hist_scene.setSceneRect(self._hist_scene.itemsBoundingRect())

    def _rel2abs(self, rel_xy):
        x, y = rel_xy
        abs_x = self._min_val * (1 - x) + x * self._max_val
        abs_y = y * self._ymax
        return abs_x, abs_y

    def _select_marker_cb(self, event=None):
        if self._active_markers is not None:
            marker = self._active_markers._pick_marker(event.scenePos())
            self._set_sel_marker(marker, drag_start=event)
            if marker is not None:
                return
        # show value where histogram clicked
        self._set_value_entry(self._abs_xy((event.scenePos().x(), 0))[0])

    def _set_sel_marker(self, marker, drag_start=None):
        self._active_markers._sel_marker = marker
        if not marker:
            self._color_button.color = "gray"
            self._color_button.setEnabled(False)
            self._set_value_entry("")
            self._value_entry.setEnabled(False)
        else:
            self._color_button.setEnabled(True)
            self._color_button.color = marker.rgba
            self._value_entry.setEnabled(True)
            self._set_value_entry(self._marker2abs(marker)[0])
        if self._select_callback:
            if marker is not None or self._prev_marker is not None:
                self._select_callback(self._prev_markers, self._prev_marker,
                                      self._active_markers, marker)
            self._prev_markers = self._active_markers
            self._prev_marker = marker
        if not drag_start:
            return
        self._drag_marker = marker
        if not marker:
            return

        self._last_mouse_xy = self._abs_xy(
            (drag_start.scenePos().x(), drag_start.scenePos().y()))
        if self._active_markers.move_callback:
            self._active_markers.move_callback('start')

    def _set_value_cb(self):
        try:
            v = eval(self._value_entry.text())
        except Exception:
            raise ValueError("Invalid histogram value")
        if type(self._min_val) != type(v):
            v = type(self._min_val)(v)
        if v < self._min_val:
            self._draw_min = v
            self._redraw_cb()
        elif v > self._max_val:
            self._draw_max = v
            self._redraw_cb()
        self._move_cur_marker(v)

    def _set_value_entry(self, val):
        if isinstance(val, str):
            self._value_entry.setText(val)
            return
        if isinstance(self._min_val, int):
            val = int(val + 0.5)
        self._value_entry.setText("%g" % val)

    def _str_val(self, val):
        if isinstance(val, (int, bool)):
            return str(val)
        return "%g" % val
コード例 #3
0
class MainWindow(QtWidgets.QMainWindow):
    def __init__(self, qApp):
        super(MainWindow, self).__init__()
        self.ui = wnd.Ui_MainWindow()  #создаём простой объект ui
        self.ui.setupUi(self)
        self.qApp = qApp
        self.scn = QGraphicsScene(self)
        self.scn.setSceneRect(0, 0, self.width() - 2, self.height() - 2)
        self.gv = QtWidgets.QGraphicsView(self)
        self.gv.setObjectName("gv")
        self.gv.setStyleSheet(
            "border-width: 0px; border-style: none; outline:0px;")
        self.gv.setRenderHint(QPainter.Antialiasing)
        self.gv.setScene(self.scn)
        self.gv.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.gv.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setCentralWidget(self.gv)
        self.gv.show()
        self.gv.mousePressEvent = self.mousePress
        self.gv.mouseMoveEvent = self.mouseMove

        set = QSettings("Tree", "config")
        x = int(set.value("Main/Left", "-1"))
        y = int(set.value("Main/Top", "-1"))
        if x > 0 and y > 0:
            self.move(x, y)
        else:
            self.move(QApplication.desktop().screen().rect().center() -
                      self.rect().center())

        self.elimg = self.scn.addPixmap(QPixmap(":/images/Tree.png"))
        self.elimg.setTransformationMode(QtCore.Qt.SmoothTransformation)
        self.elimg.setZValue(2)

        self.gv.setContextMenuPolicy(Qt.CustomContextMenu)
        self.gv.customContextMenuRequested.connect(self.initContextMenu)

        self.mx = 0
        self.my = 0
        self.ps = None
        self.lamps = []
        self.setLamps()
        self.curlight = -1
        self.snowalphach_len = self.height() / 3
        self.snows = []
        self.snowgroups = []
        self.snowing = set.value("Main/Snowing", "true") == "true"
        self.setSnows()

        self.timer = QTimer(self)
        self.timer.timeout.connect(self.onTimer)
        self.timerinterval = 50
        self.timer.start(self.timerinterval)
        self.speed = int(set.value("Main/speed", "1"))
        self.lampturn = int(set.value("Main/turncnt", "1"))
        self.sparr = [0.1, 0.4, 0.6]
        self.cols = 6
        self.snowfallspeed = [2, 1.25, 0.8]

    def initContextMenu(self, pos):
        menu = QMenu(self)
        menu.setStyleSheet("background: #333; color: white;")

        smenu = menu.addMenu("Скорость")
        act = QAction("Медленно", self)
        act.triggered.connect(self.slowspeed)
        smenu.addAction(act)
        act = QAction("Средне", self)
        act.triggered.connect(self.midspeed)
        smenu.addAction(act)
        act = QAction("Быстро", self)
        act.triggered.connect(self.fastspeed)
        smenu.addAction(act)

        kmenu = menu.addMenu("Переключения")
        act = QAction("По 1 лампочке", self)
        act.triggered.connect(self.onelamp)
        kmenu.addAction(act)
        act = QAction("По 2 лампочки", self)
        act.triggered.connect(self.twolamp)
        kmenu.addAction(act)
        act = QAction("По 3 лампочки", self)
        act.triggered.connect(self.treelamp)
        kmenu.addAction(act)
        act = QAction("По 4 лампочки", self)
        act.triggered.connect(self.forelamp)
        kmenu.addAction(act)
        act = QAction("Снег", self)
        act.triggered.connect(self.snowOffOn)
        menu.addAction(act)

        menu.addSeparator()
        act = QAction("Закрыть", self)
        act.triggered.connect(self.close)
        menu.addAction(act)

        p = self.mapToGlobal(pos)
        p.setX(p.x() + 1)
        p.setY(p.y() + 1)
        menu.exec_(p)

    def slowspeed(self):
        self.speed = 0

    def midspeed(self):
        self.speed = 1

    def fastspeed(self):
        self.speed = 2

    def snowOffOn(self):
        #i = QtWidgets.QGraphicsItem
        self.snowing = not self.snowing
        for snows in self.snows:
            for snow in snows:
                if self.snowing:
                    snow.item.show()
                else:
                    snow.item.hide()

    def setlampsTurn(self, n):
        self.timer.stop()
        self.lampturn = n
        for lamps in self.lamps:
            for lamp in lamps:
                lamp.alpha = 0
                lamp.item.setOpacity(0)
        self.curlight = -1
        self.timer.start(self.timerinterval)

    def onelamp(self):
        self.setlampsTurn(1)

    def twolamp(self):
        self.setlampsTurn(2)

    def treelamp(self):
        self.setlampsTurn(3)

    def forelamp(self):
        self.setlampsTurn(4)

    def setLamps(self):
        '''
        pts = [[vect(22,239),vect(86,281),vect(169,256),vect(46,224),vect(122,240),vect(50,178),
            vect(122,200),vect(74,157),vect(138,149),vect(119,133),vect(90,95),vect(85,47)],
            [vect(32,255),vect(110,281),vect(181,240),vect(59,237),vect(137,236),vect(62,192),
            vect(139,192),vect(87,165),vect(65,108),vect(136,123),vect(106,98),vect(102,54)],
            [vect(49,271),vect(133,274),vect(22,191),vect(79,242),vect(153,224),vect(82,200),
            vect(156,182),vect(106,165),vect(78,125),vect(126,92),vect(150,109),vect(119,45)],
            [vect(65,278),vect(152,268),vect(32,208),vect(100,243),vect(168,217),vect(103,204),
            vect(57,149),vect(124,160),vect(97,134),vect(73,83),vect(137,77),vect(99,25)]]
        '''
        pts = [[
            vect(25, 238),
            vect(120, 277),
            vect(44, 218),
            vect(147, 236),
            vect(82, 201),
            vect(59, 133),
            vect(149, 153),
            vect(128, 125),
            vect(113, 94),
            vect(111, 63)
        ],
               [
                   vect(36, 250),
                   vect(137, 271),
                   vect(54, 232),
                   vect(161, 225),
                   vect(101, 204),
                   vect(72, 147),
                   vect(160, 137),
                   vect(141, 116),
                   vect(126, 92),
                   vect(126, 58)
               ],
               [
                   vect(51, 263),
                   vect(156, 267),
                   vect(71, 241),
                   vect(175, 215),
                   vect(121, 202),
                   vect(87, 158),
                   vect(55, 95),
                   vect(158, 105),
                   vect(134, 80),
                   vect(93, 32)
               ],
               [
                   vect(64, 275),
                   vect(172, 256),
                   vect(88, 246),
                   vect(43, 157),
                   vect(140, 199),
                   vect(100, 169),
                   vect(74, 114),
                   vect(73, 66),
                   vect(149, 71),
                   vect(108, 40)
               ],
               [
                   vect(80, 277),
                   vect(187, 245),
                   vect(108, 245),
                   vect(51, 178),
                   vect(154, 192),
                   vect(116, 167),
                   vect(89, 123),
                   vect(86, 79),
                   vect(89, 47),
                   vect(121, 34)
               ],
               [
                   vect(101, 279),
                   vect(28, 198),
                   vect(129, 244),
                   vect(66, 191),
                   vect(171, 179),
                   vect(135, 161),
                   vect(108, 127),
                   vect(99, 88),
                   vect(100, 59),
                   vect(108, 17)
               ]]
        clrs = [["red1", "red2", "red3", "red4", "red5"],
                ["aqua1", "aqua2", "aqua2", "aqua4", "aqua5"],
                ["fuji1", "fuji2", "fuji3", "fuji4", "fuji5"],
                ["green1", "green2", "green3", "green4", "green5"],
                ["blue1", "blue2", "blue3", "blue4", "blue5"],
                ["yellow1", "yellow2", "yellow3", "yellow4", "yellow5"]]
        cv = 0
        for c in range(len(pts)):
            lamps = []
            for v in pts[c]:
                lamp = Lamp(self.scn, ":/images/" + clrs[c][cv] + ".png", v.y,
                            v.x)
                lamp.item.setZValue(4)
                lamps.append(lamp)
                cv += 1
                if cv > 4: cv = 0
            self.lamps.append(lamps)

    def setSnows(self):
        maxminsnows = 50
        sc = [
            random.randint(0, 14) + maxminsnows,
            random.randint(0, 14) + maxminsnows,
            random.randint(0, 14) + maxminsnows
        ]

        for i in range(len(sc)):
            snows = []
            items = []
            for j in range(sc[i]):
                imgfn = ":/images/snow" + str(i + 1) + ".png"
                x = random.randint(8, self.width() - 8)
                y = random.randint(10, self.height())
                a = 1
                hl = self.height() - self.snowalphach_len
                if y > hl:
                    a = 1 - (y - hl) / self.snowalphach_len
                lamp = Lamp(self.scn, imgfn, x, y, a)
                if not self.snowing:
                    lamp.item.hide()
                snows.append(lamp)
                items.append(lamp.item)
            group = self.scn.createItemGroup(items)
            if i < 2:
                group.setZValue(4)
            else:
                group.setZValue(0)

            self.snows.append(snows)
            self.snowgroups.append(items)

    def onTimer(self):
        finished = False
        nl = 0
        if self.curlight == self.cols - 1: nl = 0
        else: nl = self.curlight + 1

        for lamp in self.lamps[nl]:
            lamp.alpha += self.sparr[self.speed]
            if lamp.alpha >= 1.0:
                lamp.alpha = 1.0
                finished = True
            lamp.item.setOpacity(lamp.alpha)
        #for t in range(self.lampturn):
        if self.curlight >= 0:
            n = self.curlight - self.lampturn + 1
            if n < 0: n = self.cols + n
            for lamp in self.lamps[n]:
                if lamp.alpha > 0:
                    lamp.alpha -= self.sparr[self.speed]
                    if lamp.alpha < 0: lamp.alpha = 0
                    lamp.item.setOpacity(lamp.alpha)
        if finished:
            self.curlight += 1
            if self.curlight >= self.cols: self.curlight = 0

        if self.snowing:
            for i in range(len(self.snows)):
                for snow in self.snows[i]:
                    a = snow.alpha
                    snow.y += self.snowfallspeed[i]
                    if snow.y > self.height():
                        snow.y = -10 - random.randint(0, 15)
                        snow.x = random.randint(8, self.width() - 8)
                        snow.alpha = 1
                    else:
                        hl = self.height() - self.snowalphach_len
                        if snow.y > hl:
                            snow.alpha = 1 - (snow.y -
                                              hl) / self.snowalphach_len
                    snow.item.setPos(
                        QPointF(snow.x - snow.hw, snow.y - snow.hh))
                    if snow.alpha != a:
                        snow.item.setOpacity(snow.alpha)

    def mousePress(self, event):
        """Событие нажатия мыши на QGraphicsView,
           в данной функции  переменным присваивается глобальная
           позиция мыши и позиция окна, для того, чтобы при
           перемещении мыши вызывать перемещение главного окна."""
        self.mx = event.globalPos().x()
        self.my = event.globalPos().y()
        self.ps = self.pos()

    def mouseMove(self, event):
        """Событие перемещения мыши на QGraphicsView,
           в данной функции перемещаем главное окно по экрану."""
        x = event.globalPos().x() - self.mx
        y = event.globalPos().y() - self.my
        self.move(self.ps.x() + x, self.ps.y() + y)

    def closeEvent(self, event):
        set = QSettings("Tree", "config")
        p = self.pos()
        set.setValue("Main/Left", p.x())
        set.setValue("Main/Top", p.y())
        set.setValue("Main/Snowing", self.snowing)
        set.setValue("Main/speed", self.speed)
        set.setValue("Main/turncnt", self.lampturn)
        self.qApp.quit()
コード例 #4
0
ファイル: extended_pyGISS.py プロジェクト: qdhqf/pyGISS
class View(QGraphicsView):

    projections = OrderedDict([
        ('Spherical', Proj('+proj=ortho +lat_0=48 +lon_0=17')),
        ('Mercator', Proj(init='epsg:3395')),
        ('WGS84', Proj(init='epsg:3857')),
        ('ETRS89 - LAEA Europe', Proj("+init=EPSG:3035"))
    ])

    def __init__(self, controller):
        super().__init__()
        self.controller = controller
        self.scene = QGraphicsScene(self)
        self.setScene(self.scene)
        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
        self.setRenderHint(QPainter.Antialiasing)
        self.proj = 'Spherical'
        self.ratio, self.offset = 1 / 400, (0, 0)
        self.display = True
        self.shapefile = join(controller.path_shapefiles,
                              'World countries_1.shp')

        # brush for water and lands
        self.water_brush = QBrush(QColor(64, 164, 223))
        self.land_brush = QBrush(QColor(52, 165, 111))
        self.land_pen = QPen(QColor(0, 0, 0))

        # draw the map
        self.polygons = self.scene.createItemGroup(self.draw_polygons())
        self.draw_water()

        # set of graphical nodes
        self.nodes = set()

    ## Zoom system

    def zoom_in(self):
        self.scale(1.25, 1.25)

    def zoom_out(self):
        self.scale(1 / 1.25, 1 / 1.25)

    def wheelEvent(self, event):
        self.zoom_in() if event.angleDelta().y() > 0 else self.zoom_out()

    ## Mouse bindings

    def mouseMoveEvent(self, event):
        # sliding the scrollbar with the right-click button
        if event.buttons() == Qt.RightButton:
            self.trigger_menu = False
            offset = self.cursor_pos - event.pos()
            self.cursor_pos = event.pos()
            x_value = self.horizontalScrollBar().value() + offset.x()
            y_value = self.verticalScrollBar().value() + offset.y()
            self.horizontalScrollBar().setValue(x_value)
            self.verticalScrollBar().setValue(y_value)
        super().mouseMoveEvent(event)

    def mousePressEvent(self, event):
        # activate rubberband for selection
        # by default, the rubberband is active for both clicks, we have to
        # deactivate it explicitly for the right-click
        if event.buttons() == Qt.LeftButton:
            self.setDragMode(QGraphicsView.RubberBandDrag)
        if event.button() == Qt.RightButton:
            self.cursor_pos = event.pos()
        super().mousePressEvent(event)

    ## Drag & Drop system

    def dragEnterEvent(self, event):
        if event.mimeData().hasFormat('application/x-dnditemdata'):
            event.acceptProposedAction()

    dragMoveEvent = dragEnterEvent

    def dropEvent(self, event):
        pos = self.mapToScene(event.pos())
        geo_pos = self.to_geographical_coordinates(pos.x(), pos.y())
        if event.mimeData().hasFormat('application/x-dnditemdata'):
            new_node = Node(self.controller, pos)

    ## Map functions

    def to_geographical_coordinates(self, x, y):
        px, py = (x - self.offset[0]) / self.ratio, (self.offset[1] -
                                                     y) / self.ratio
        return self.projections[self.proj](px, py, inverse=True)

    def to_canvas_coordinates(self, longitude, latitude):
        px, py = self.projections[self.proj](longitude, latitude)
        return px * self.ratio + self.offset[
            0], -py * self.ratio + self.offset[1]

    def move_to_geographical_coordinates(self):
        for node in self.nodes:
            node.setPos(
                QPointF(*self.to_canvas_coordinates(node.longitude,
                                                    node.latitude)))

    def draw_polygons(self):
        sf = shapefile.Reader(self.shapefile)
        polygons = sf.shapes()
        for polygon in polygons:
            # convert shapefile geometries into shapely geometries
            # to extract the polygons of a multipolygon
            polygon = shapely.geometry.shape(polygon)
            # if it is a polygon, we use a list to make it iterable
            if polygon.geom_type == 'Polygon':
                polygon = [polygon]
            for land in polygon:
                qt_polygon = QPolygonF()
                for lon, lat in land.exterior.coords:
                    px, py = self.to_canvas_coordinates(lon, lat)
                    if px > 1e+10:
                        continue
                    qt_polygon.append(QPointF(px, py))
                polygon_item = QGraphicsPolygonItem(qt_polygon)
                polygon_item.setBrush(self.land_brush)
                polygon_item.setPen(self.land_pen)
                polygon_item.setZValue(1)
                yield polygon_item

    def draw_water(self):
        if self.proj in ('Spherical', 'ETRS89 - LAEA Europe'):
            cx, cy = self.to_canvas_coordinates(17, 48)
            # if the projection is ETRS89, we need the diameter and not the radius
            R = 6371000 * self.ratio * (1 if self.proj == 'Spherical' else 2)
            earth_water = QGraphicsEllipseItem(cx - R, cy - R, 2 * R, 2 * R)
            earth_water.setZValue(0)
            earth_water.setBrush(self.water_brush)
            self.polygons.addToGroup(earth_water)
        else:
            # we compute the projected bounds of the Mercator (3395) projection
            # upper-left corner x and y coordinates:
            ulc_x, ulc_y = self.to_canvas_coordinates(-180, 84)
            # lower-right corner x and y coordinates
            lrc_x, lrc_y = self.to_canvas_coordinates(180, -84.72)
            # width and height of the map (required for the QRectItem)
            width, height = lrc_x - ulc_x, lrc_y - ulc_y
            earth_water = QGraphicsRectItem(ulc_x, ulc_y, width, height)
            earth_water.setZValue(0)
            earth_water.setBrush(self.water_brush)
            self.polygons.addToGroup(earth_water)

    def show_hide_map(self):
        self.display = not self.display
        self.polygons.show() if self.display else self.polygons.hide()

    def delete_map(self):
        self.scene.removeItem(self.polygons)

    def redraw_map(self):
        self.delete_map()
        self.polygons = self.scene.createItemGroup(self.draw_polygons())
        self.draw_water()
        # replace the nodes at their geographical location
        self.move_to_geographical_coordinates()
コード例 #5
0
class Editor(QWidget):
    def __init__(self, song):
        super().__init__()

        self.initUI(song)

    def initUI(self, song):
        self.songLenInBeats = 100
        self.songBeatsPBar = 4
        self.reverse = 1
        self.pixPSec = 1000.0
        self.disp8 = True
        self.disp12 = False
        self.disp16 = True
        self.disp24 = False
        self.disp32 = False
        self.disp48 = False
        self.disp64 = False
        self.spectrogramDisplay = True
        self.cursorExists = False
        self.framecount = 0
        self.timeOutLength = 17

        self.timer = QTimer()
        self.editorTheme = self.getTheme()
        self.boxw = self.editorTheme['BoxWidth']
        self.topLayout = QVBoxLayout()
        self.topLayout.setContentsMargins(0, 0, 0, 0)

        self.song = song
        self.song.pos = 0
        self.setLayout(self.topLayout)
        self.gs = QGraphicsScene()
        self.gv = QGraphicsView(self.gs)
        self.drawBG()
        self.song = song
        #        self.drawArrowDemo()
        self.boxes = []
        self.topLayout.addWidget(self.gv)

    def update(self, song, level):
        self.gs.clear()
        print(self.song.pos)
        self.song = song
        self.cursorExists = False
        self.song.pos = 0
        self.play(0)
        self.pause()
        self.updatescreen()

        if self.spectrogramDisplay:
            self.spectrogramPixMap = QPixmap(spectrogram_dir + song.audioFile +
                                             '.png')
            width = self.spectrogramPixMap.width()
            height = self.spectrogramPixMap.height()

            self.spectrogramPixMap = self.gs.addPixmap(self.spectrogramPixMap)
            self.spectrogramPixMap.setRotation(90)
            self.spectrogramPixMap.setTransform(QTransform().scale(
                -1, (self.song.lengthInSeconds * self.pixPSec) / width))
        self.drawGrid(self.song.levels[level])
        self.drawArrowDemo(self.song.levels[level])
        #self.play(0)

    def levelSelected(self, level):
        print("Selected ", level)
        if level in self.song.levels:
            print('switching')
            self.update(self.song, level)
        else:
            print('creating new level')

    def play(self, pos):
        self.timer.timeout.connect(self.updatescreen)
        self.timer.start(self.timeOutLength)
        self.song.playSong(pos)

    def pause(self):
        self.timer.stop()
        self.song.pauseSong()

    def keyPressEvent(self, event):
        key = event.key()
        shiftPressed = event.modifiers() == Qt.ShiftModifier
        ctrlPressed = event.modifiers() == Qt.ControlModifier
        altPressed = event.modifiers() == Qt.AltModifier
        restart = self.song.isPlaying

        if key == Qt.Key_Space:
            if self.song.isPlaying:
                self.pause()
            else:
                self.play(self.song.pos / 1000)
        elif key == Qt.Key_BracketRight:
            restart = self.song.isPlaying
            self.pause()
            if ctrlPressed:
                self.song.pos += 10000
            elif shiftPressed:
                self.song.pos += 1000
            elif altPressed:
                self.song.pos += 10
            else:
                self.song.pos += 100

            if not (self.song.pos > self.song.lengthInSeconds * 1000):
                if restart:
                    self.play(self.song.pos / 1000)
                else:
                    self.play(self.song.pos / 1000)
                    self.pause()
            else:
                self.song.pos = self.song.lengthInSeconds * 1000 - 1
                self.play(self.song.pos / 1000)
                self.pause()
            self.updatescreen()
        elif key == Qt.Key_BracketLeft:
            self.pause()
            if ctrlPressed:
                self.song.pos -= 10000
            elif shiftPressed:
                self.song.pos -= 1000
            elif altPressed:
                self.song.pos -= 10
            else:
                self.song.pos -= 100
            if self.song.pos < 0:
                self.song.pos = 0
            if restart:
                self.play(self.song.pos / 1000)
            else:
                self.play(self.song.pos / 1000)
                self.pause()
            self.updatescreen()
        elif key == Qt.Key_BraceRight:
            restart = self.song.isPlaying
            self.pause()
            if ctrlPressed:
                self.song.pos += 10000
            elif shiftPressed:
                self.song.pos += 1000
            elif altPressed:
                self.song.pos += 10
            else:
                self.song.pos += 200

            if not (self.song.pos > self.song.lengthInSeconds * 1000):
                if restart:
                    self.play(self.song.pos / 1000)
                else:
                    self.play(self.song.pos / 1000)
                    self.pause()
            else:
                self.song.pos = self.song.lengthInSeconds * 1000 - 1
                self.play(self.song.pos / 1000)
                self.pause()

            self.updatescreen()
        elif key == Qt.Key_BraceLeft:
            self.pause()
            if ctrlPressed:
                self.song.pos -= 10000
            elif shiftPressed:
                self.song.pos -= 1000
            elif altPressed:
                self.song.pos += 10
            else:
                self.song.pos -= 200
            if self.song.pos < 0:
                self.song.pos = 0
            if restart:
                self.play(self.song.pos / 1000)
            else:
                self.play(self.song.pos / 1000)
                self.pause()

            self.updatescreen()

    def updatescreen(self):
        self.song.updatePos()

        if self.song.isPlaying:
            self.framecount += 1
            curTime = time.time()
            if (curTime - self.song.time > 1):
                print('FPS: ', self.framecount)
                self.framecount = 0
                self.song.time = curTime

        if self.cursorExists:
            self.gs.removeItem(self.cursorLine)
        ypos = (self.song.pos / 1000.0 * self.pixPSec)
        self.gv.centerOn(0, ypos)
        self.cursorLine = self.gs.addLine(0, ypos, 1000, ypos,
                                          self.editorTheme['GridMeasure'])
        self.cursorExists = True
        self.cursor = True
        if self.song.pos < 0:
            self.song.pos = 0
            self.gv.centerOn(0, 0)
            self.pause()

    def drawArrowDemo(self, level):

        boxRotation = [180, 0, 90, 270, 225, 135, 315, 45, 0]

        for beatBox in level.notes:
            if beatBox.type == 0:
                if beatBox.cutDirection == 8:
                    notePixmap = QPixmap(graphics_dir + 'redcircle.png')
                else:
                    notePixmap = QPixmap(graphics_dir + 'redarrow.png')
            elif beatBox.type == 1:
                if beatBox.cutDirection == 8:
                    notePixmap = QPixmap(graphics_dir + 'bluecircle.png')
                else:
                    notePixmap = QPixmap(graphics_dir + 'bluearrow.png')
            else:
                notePixmap = QPixmap(graphics_dir + 'mine.png')

            notePixmap = notePixmap.scaled(40, 40)
            noteBox = NoteBox()
            noteBox.setPixmap(notePixmap)
            noteBox.setBox(beatBox)
            box = self.gs.addItem(noteBox)
            print(type(noteBox))
            noteBox.setTransformOriginPoint(20, 20)
            noteBox.setRotation(boxRotation[beatBox.cutDirection])
            boxy = (level.beatToSec(beatBox.time) * self.pixPSec -
                    (self.reverse * 20)) * self.reverse

            boxx = 40 * beatBox.lineIndex + 170 * beatBox.lineLayer
            noteBox.setPos(boxx, boxy)
            self.boxes.append(noteBox)

    def drawBG(self):
        self.gs.setBackgroundBrush(self.editorTheme['BG'])

    def drawGrid(self, level):
        #DEBUG need to through a clear grid in here

        self.drawGridConstantTime(level)

    def drawGridConstantBeat(self):
        pass

    def drawGridConstantTime(self, level):

        # DONT FORGET TO ADD REVERSE SCROLL

        #        self.disp192 = True
        self.noteLayer1 = self.gs.createItemGroup([])
        self.noteLayer2 = self.gs.createItemGroup([])
        self.noteLayer3 = self.gs.createItemGroup([])
        self.obstacleLayer = self.gs.createItemGroup([])
        self.eventLayer = self.gs.createItemGroup([])
        width = self.editorTheme['BoxWidth'] * 4
        spacing = self.editorTheme['LaneSpacing']
        self.noteLayer1Values = LayerValue(0, 0, width)
        self.noteLayer2Values = LayerValue((width + spacing), 0, width)
        self.noteLayer3Values = LayerValue((width + spacing) * 2, 0, width)
        self.obstacleLayerValues = LayerValue((width + spacing) * 3, 0, width)
        self.eventLayerValues = LayerValue((width + spacing) * 4, 0, width)

        self.drawGridLaneConstantTime(self.noteLayer1, self.noteLayer1Values,
                                      level)
        self.drawGridLaneConstantTime(self.noteLayer2, self.noteLayer2Values,
                                      level)
        self.drawGridLaneConstantTime(self.noteLayer3, self.noteLayer3Values,
                                      level)
        self.drawGridLaneConstantTime(self.obstacleLayer,
                                      self.obstacleLayerValues, level)
        self.drawGridLaneConstantTime(self.eventLayer, self.eventLayerValues,
                                      level)

    def drawGridLaneConstantTime(self, lane, values, level):
        #debug songlen not a int need to address leftover time
        for beat in range(int(self.song.lengthInBeats)):
            if beat % self.song.beatsPerBar == 0:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat)) *
                        self.pixPSec, self.editorTheme['GridMeasure']))
            else:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat)) *
                        self.pixPSec, self.editorTheme['Grid4']))
            if self.disp8:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .5)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .5)) *
                        self.pixPSec, self.editorTheme['Grid8']))
            if self.disp16:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .25)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .25)) *
                        self.pixPSec, self.editorTheme['Grid16']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .75)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .75)) *
                        self.pixPSec, self.editorTheme['Grid16']))
            if self.disp32:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .125)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .125)) *
                        self.pixPSec, self.editorTheme['Grid32']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .375)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .375)) *
                        self.pixPSec, self.editorTheme['Grid32']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .625)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .625)) *
                        self.pixPSec, self.editorTheme['Grid32']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .875)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .875)) *
                        self.pixPSec, self.editorTheme['Grid32']))
            if self.disp64:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .0625)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .0625)) *
                        self.pixPSec, self.editorTheme['Grid64']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .1875)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .1875)) *
                        self.pixPSec, self.editorTheme['Grid64']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .3125)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .3125)) *
                        self.pixPSec, self.editorTheme['Grid64']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .4375)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .4375)) *
                        self.pixPSec, self.editorTheme['Grid64']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .5625)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .5625)) *
                        self.pixPSec, self.editorTheme['Grid64']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .6875)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .6875)) *
                        self.pixPSec, self.editorTheme['Grid64']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .8125)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .8125)) *
                        self.pixPSec, self.editorTheme['Grid64']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .9375)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .9375)) *
                        self.pixPSec, self.editorTheme['Grid64']))
            if self.disp12:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 1 / 3)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 1 / 3)) *
                        self.pixPSec, self.editorTheme['Grid12']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 2 / 3)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 2 / 3)) *
                        self.pixPSec, self.editorTheme['Grid12']))
            if self.disp24:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 1 / 6)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 1 / 6)) *
                        self.pixPSec, self.editorTheme['Grid24']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .5)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .5)) *
                        self.pixPSec, self.editorTheme['Grid24']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 5 / 6)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 5 / 6)) *
                        self.pixPSec, self.editorTheme['Grid24']))
            if self.disp48:
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 1 / 12)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 1 / 12)) *
                        self.pixPSec, self.editorTheme['Grid48']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .25)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .25)) *
                        self.pixPSec, self.editorTheme['Grid48']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 5 / 12)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 5 / 12)) *
                        self.pixPSec, self.editorTheme['Grid48']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 7 / 12)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 7 / 12)) *
                        self.pixPSec, self.editorTheme['Grid48']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .75)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + .75)) *
                        self.pixPSec, self.editorTheme['Grid48']))
                lane.addToGroup(
                    self.gs.addLine(
                        values.x + self.editorTheme['GridLineWidth'],
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 11 / 12)) *
                        self.pixPSec, values.x + values.w -
                        self.editorTheme['GridLineWidth'] * 2,
                        self.reverse *
                        (self.song.offset + level.beatToSec(beat + 11 / 12)) *
                        self.pixPSec, self.editorTheme['Grid48']))
        lane.addToGroup(
            self.gs.addLine(
                values.x, values.y, values.x,
                self.reverse *
                (self.song.offset + level.beatToSec(self.song.lengthInBeats)) *
                self.pixPSec, self.editorTheme['GridLayer1Vert']))
        lane.addToGroup(
            self.gs.addLine(
                values.x + values.w * .25, values.y, values.x + values.w * .25,
                self.reverse *
                (self.song.offset + level.beatToSec(self.song.lengthInBeats)) *
                self.pixPSec, self.editorTheme['GridLayer1Vert']))
        lane.addToGroup(
            self.gs.addLine(
                values.x + values.w * .5, values.y, values.x + values.w * .5,
                self.reverse *
                (self.song.offset + level.beatToSec(self.song.lengthInBeats)) *
                self.pixPSec, self.editorTheme['GridLayer1Vert']))
        lane.addToGroup(
            self.gs.addLine(
                values.x + values.w * .75, values.y, values.x + values.w * .75,
                self.reverse *
                (self.song.offset + level.beatToSec(self.song.lengthInBeats)) *
                self.pixPSec, self.editorTheme['GridLayer1Vert']))
        lane.addToGroup(
            self.gs.addLine(
                values.x + values.w, values.y, values.x + values.w,
                self.reverse *
                (self.song.offset + level.beatToSec(self.song.lengthInBeats)) *
                self.pixPSec, self.editorTheme['GridLayer1Vert']))

    def getTheme(self):
        return {
            'BoxWidth': 60,
            'LaneSpacing': 20,
            'BG': QBrush(QColor(0, 0, 0), Qt.SolidPattern),
            'GridLayer1Vert': QPen(QBrush(QColor(255, 255, 255)), 1,
                                   Qt.SolidLine),
            'GridLayer1BG': QBrush(Qt.black, Qt.SolidPattern),
            'GridLayer2Vert': QPen(Qt.white, Qt.SolidLine),
            'GridLayer2BG': QBrush(Qt.black, Qt.SolidPattern),
            'GridLayer3Vert': QPen(Qt.white, Qt.SolidLine),
            'GridLayer3BG': QBrush(Qt.black, Qt.SolidPattern),
            'GridObs': QPen(Qt.blue, Qt.SolidLine),
            'GridObsBG': QBrush(Qt.black, Qt.SolidPattern),
            'GridEventVert': QPen(Qt.red, Qt.SolidLine),
            'GridEventBG': QBrush(Qt.black, Qt.SolidPattern),
            'GridMeasure': QPen(QBrush(QColor(255, 0, 0)), 2, Qt.SolidLine),
            'Grid4': QPen(QBrush(QColor(255, 255, 255)), 2, Qt.DashLine),
            'Grid8': QPen(QBrush(QColor(0, 150, 255)), 2, Qt.DotLine),
            'Grid12': QPen(QBrush(QColor(100, 255, 50)), 2, Qt.DotLine),
            'Grid16': QPen(QBrush(QColor(255, 255, 50)), 2, Qt.DotLine),
            'Grid24': QPen(QBrush(QColor(150, 100, 255)), 2, Qt.DotLine),
            'Grid32': QPen(QBrush(QColor(0, 255, 150)), 2, Qt.DotLine),
            'Grid48': QPen(QBrush(QColor(255, 100, 150)), 2, Qt.DotLine),
            'Grid64': QPen(QBrush(QColor(150, 200, 100)), 2, Qt.DotLine),
            #                    'Grid192': QPen(Qt.red,Qt.SolidLine),
            'GridLineWidth': 1
        }