Exemple #1
0
 def toggle_node_color_reg(self):
     """Update the node color for regression trees"""
     def_color = QColor(192, 192, 255)
     if self.regression_colors == self.COL_DEFAULT:
         brush = QBrush(def_color.lighter(100))
         for node in self.scene.nodes():
             node.backgroundBrush = brush
     elif self.regression_colors == self.COL_INSTANCE:
         max_insts = len(self.model.instances)
         for node in self.scene.nodes():
             node.backgroundBrush = QBrush(
                 def_color.lighter(120 - 20 * len(node.node_inst.subset) /
                                   max_insts))
     elif self.regression_colors == self.COL_MEAN:
         minv = np.nanmin(self.dataset.Y)
         maxv = np.nanmax(self.dataset.Y)
         fact = 1 / (maxv - minv) if minv != maxv else 1
         colors = self.scene.colors
         for node in self.scene.nodes():
             node.backgroundBrush = QBrush(
                 colors[fact * (node.node_inst.value[0] - minv)])
     else:
         nodes = list(self.scene.nodes())
         variances = [node.node_inst.value[1] for node in nodes]
         max_var = max(variances)
         for node, var in zip(nodes, variances):
             node.backgroundBrush = QBrush(
                 def_color.lighter(120 - 20 * var / max_var))
     self.scene.update()
Exemple #2
0
 def toggle_node_color_reg(self):
     """Update the node color for regression trees"""
     def_color = QColor(192, 192, 255)
     if self.regression_colors == self.COL_DEFAULT:
         brush = QBrush(def_color.lighter(100))
         for node in self.scene.nodes():
             node.backgroundBrush = brush
     elif self.regression_colors == self.COL_INSTANCE:
         max_insts = len(self.tree_adapter.get_instances_in_nodes(
             [self.tree_adapter.root]))
         for node in self.scene.nodes():
             node_insts = len(self.tree_adapter.get_instances_in_nodes(
                 [node.node_inst]))
             node.backgroundBrush = QBrush(def_color.lighter(
                 120 - 20 * node_insts / max_insts))
     elif self.regression_colors == self.COL_MEAN:
         minv = np.nanmin(self.dataset.Y)
         maxv = np.nanmax(self.dataset.Y)
         colors = self.scene.colors
         for node in self.scene.nodes():
             node_mean = self.tree_adapter.get_distribution(node.node_inst)[0][0]
             color = colors.value_to_qcolor(node_mean, minv, maxv)
             node.backgroundBrush = QBrush(color)
     else:
         nodes = list(self.scene.nodes())
         variances = [self.tree_adapter.get_distribution(node.node_inst)[0][1]
                      for node in nodes]
         max_var = max(variances)
         for node, var in zip(nodes, variances):
             node.backgroundBrush = QBrush(def_color.lighter(
                 120 - 20 * var / max_var))
     self.scene.update()
Exemple #3
0
 def toggle_node_color_reg(self):
     """Update the node color for regression trees"""
     def_color = QColor(192, 192, 255)
     if self.regression_colors == self.COL_DEFAULT:
         brush = QBrush(def_color.lighter(100))
         for node in self.scene.nodes():
             node.backgroundBrush = brush
     elif self.regression_colors == self.COL_INSTANCE:
         max_insts = len(self.model.instances)
         for node in self.scene.nodes():
             node.backgroundBrush = QBrush(def_color.lighter(
                 120 - 20 * len(node.node_inst.subset) / max_insts))
     elif self.regression_colors == self.COL_MEAN:
         minv = np.nanmin(self.dataset.Y)
         maxv = np.nanmax(self.dataset.Y)
         fact = 1 / (maxv - minv) if minv != maxv else 1
         colors = self.scene.colors
         for node in self.scene.nodes():
             node.backgroundBrush = QBrush(
                 colors[fact * (node.node_inst.value[0] - minv)])
     else:
         nodes = list(self.scene.nodes())
         variances = [node.node_inst.value[1] for node in nodes]
         max_var = max(variances)
         for node, var in zip(nodes, variances):
             node.backgroundBrush = QBrush(def_color.lighter(
                 120 - 20 * var / max_var))
     self.scene.update()
Exemple #4
0
 def toggle_node_color_reg(self):
     """Update the node color for regression trees"""
     def_color = QColor(192, 192, 255)
     if self.regression_colors == self.COL_DEFAULT:
         brush = QBrush(def_color.lighter(100))
         for node in self.scene.nodes():
             node.backgroundBrush = brush
     elif self.regression_colors == self.COL_INSTANCE:
         max_insts = len(self.tree_adapter.get_instances_in_nodes(
             [self.tree_adapter.root]))
         for node in self.scene.nodes():
             node_insts = len(self.tree_adapter.get_instances_in_nodes(
                 [node.node_inst]))
             node.backgroundBrush = QBrush(def_color.lighter(
                 120 - 20 * node_insts / max_insts))
     elif self.regression_colors == self.COL_MEAN:
         minv = np.nanmin(self.dataset.Y)
         maxv = np.nanmax(self.dataset.Y)
         fact = 1 / (maxv - minv) if minv != maxv else 1
         colors = self.scene.colors
         for node in self.scene.nodes():
             node_mean = self.tree_adapter.get_distribution(node.node_inst)[0][0]
             node.backgroundBrush = QBrush(colors[fact * (node_mean - minv)])
     else:
         nodes = list(self.scene.nodes())
         variances = [self.tree_adapter.get_distribution(node.node_inst)[0][1]
                      for node in nodes]
         max_var = max(variances)
         for node, var in zip(nodes, variances):
             node.backgroundBrush = QBrush(def_color.lighter(
                 120 - 20 * var / max_var))
     self.scene.update()
Exemple #5
0
    def make_color_legend(self):
        if self.attr_color is None:
            return
        use_shape = self.get_shape() == self.get_color()
        if self.attr_color.is_discrete:
            if not self.legend:
                self.create_legend()
            palette = self.discrete_palette
            for i, value in enumerate(self.attr_color.values):
                color = QColor(*palette.getRGB(i))
                brush = color.lighter(self.DarkerValue)
                self.legend.addItem(
                    ScatterPlotItem(
                        pen=color,
                        brush=brush,
                        size=10,
                        symbol=self.CurveSymbols[i] if use_shape else "o"),
                    escape(value))
        else:
            legend = self.color_legend = LegendItem()
            legend.setParentItem(self.plot_widget.getViewBox())
            legend.restoreAnchor(self.__color_legend_anchor)

            label = PaletteItemSample(self.continuous_palette, self.scale)
            legend.addItem(label, "")
            legend.setGeometry(label.boundingRect())
Exemple #6
0
    def show_selection(self):
        self.plot_mark.clear()
        if not self.is_valid:  # though if it's not, selection is empty anyway
            return

        blue = QColor(Qt.blue)
        pen = QPen(QBrush(blue), 3)
        pen.setCosmetic(True)
        brush = QBrush(blue.lighter(190))

        for group in self.grouped_selection():
            group = list(group)
            left_idx, right_idx = group[0], group[-1]
            left_pad, right_pad = self._determine_padding(left_idx, right_idx)
            x0 = self.bar_items[left_idx].x0 - left_pad
            x1 = self.bar_items[right_idx].x1 + right_pad
            item = QGraphicsRectItem(x0, 0, x1 - x0, 1)
            item.setPen(pen)
            item.setBrush(brush)
            if self.var.is_continuous:
                valname = self.str_int(
                    x0, x1, not left_idx, right_idx == len(self.bar_items) - 1)
                inside = sum(np.sum(self.bar_items[i].freqs) for i in group)
                total = len(self.valid_data)
                item.setToolTip(
                    "<p style='white-space:pre;'>"
                    f"<b>{escape(valname)}</b>: "
                    f"{inside} ({100 * inside / total:.2f} %)")
            self.plot_mark.addItem(item)
    def make_color_legend(self):
        color_index = self.get_color_index()
        if color_index == -1:
            return
        color_var = self.domain[color_index]
        use_shape = self.get_shape_index() == color_index
        if color_var.is_discrete:
            if not self.legend:
                self.create_legend()
            palette = self.discrete_palette
            for i, value in enumerate(color_var.values):
                color = QColor(*palette.getRGB(i))
                brush = color.lighter(self.DarkerValue)
                self.legend.addItem(
                    ScatterPlotItem(
                        pen=color, brush=brush, size=10,
                        symbol=self.CurveSymbols[i] if use_shape else "o"),
                    escape(value))
        else:
            legend = self.color_legend = LegendItem()
            legend.setParentItem(self.plot_widget.getViewBox())
            legend.restoreAnchor(self.__color_legend_anchor)

            label = PaletteItemSample(self.continuous_palette, self.scale)
            legend.addItem(label, "")
            legend.setGeometry(label.boundingRect())
Exemple #8
0
 def __init__(self, data: np.ndarray, density: np.ndarray, color: QColor,
              orientation: Qt.Orientations):
     _, indices = np.unique(data, return_inverse=True)
     density = density[indices]
     self.__xdata = x = np.random.RandomState(0).uniform(-density, density)
     self.__ydata = data
     x, y = (x, data) if orientation == Qt.Vertical else (data, x)
     color = color.lighter(150)
     super().__init__(x=x, y=y, size=5, brush=pg.mkBrush(color))
Exemple #9
0
 def set_pen_colors(self):
     self.pen_normal.clear()
     self.pen_subset.clear()
     self.pen_selected.clear()
     color_var = self._current_color_var()
     if color_var != "(Same color)":
         colors = color_var.colors
         discrete_palette = ColorPaletteGenerator(
             number_of_colors=len(colors), rgb_colors=colors)
         for v in color_var.values:
             basecolor = discrete_palette[color_var.to_val(v)]
             basecolor = QColor(basecolor)
             basecolor.setAlphaF(0.9)
             self.pen_subset[v] = pg.mkPen(color=basecolor, width=1)
             self.pen_selected[v] = pg.mkPen(color=basecolor, width=2, style=Qt.DotLine)
             notselcolor = basecolor.lighter(150)
             notselcolor.setAlphaF(0.5)
             self.pen_normal[v] = pg.mkPen(color=notselcolor, width=1)
Exemple #10
0
        def add_points():
            nonlocal cur, image_token
            if image_token != self._image_token:
                return
            batch = visible[cur:cur + self.N_POINTS_PER_ITER]

            batch_lat = lat[batch]
            batch_lon = lon[batch]

            x, y = self.Projection.latlon_to_easting_northing(batch_lat, batch_lon)
            x, y = self.Projection.easting_northing_to_pixel(x, y, zoom, origin, map_pane_pos)

            if self._jittering:
                dx, dy = self._jittering_offsets[batch].T
                x, y = x + dx, y + dy

            colors = (self._colorgen.getRGB(self._scaled_color_values[batch]).tolist()
                      if self._color_attr else
                      repeat((0xff, 0, 0)))
            sizes = self._size_coef * \
                (self._sizes[batch] if self._size_attr else np.tile(10, len(batch)))

            opacity_subset, opacity_rest = self._opacity, int(.8 * self._opacity)
            for x, y, is_selected, size, color, _in_subset in \
                    zip(x, y, selected[batch], sizes, colors, in_subset[batch]):

                pensize2, selpensize2 = (.35, 1.5) if size >= 5 else (.15, .7)
                pensize2 *= self._size_coef
                selpensize2 *= self._size_coef

                size2 = size / 2
                if is_selected:
                    painter.setPen(QPen(QBrush(Qt.green), 2 * selpensize2))
                    painter.drawEllipse(x - size2 - selpensize2,
                                        y - size2 - selpensize2,
                                        size + selpensize2,
                                        size + selpensize2)
                color = QColor(*color)
                if _in_subset:
                    color.setAlpha(opacity_subset)
                    painter.setBrush(QBrush(color))
                    painter.setPen(QPen(QBrush(color.darker(180)), 2 * pensize2))
                else:
                    color.setAlpha(opacity_rest)
                    painter.setBrush(Qt.NoBrush)
                    painter.setPen(QPen(QBrush(color.lighter(120)), 2 * pensize2))

                painter.drawEllipse(x - size2 - pensize2,
                                    y - size2 - pensize2,
                                    size + pensize2,
                                    size + pensize2)

            im.save(self._overlay_image_path, 'PNG')
            self.evalJS('markersImageLayer.setUrl("{}#{}"); 0;'
                        .format(self.toFileURL(self._overlay_image_path),
                                np.random.random()))

            cur += self.N_POINTS_PER_ITER
            if cur < len(visible):
                QTimer.singleShot(10, add_points)
                self._owwidget.progressBarAdvance(100 / n_iters, None)
            else:
                self._owwidget.progressBarFinished(None)
    def _setup_plot(self):
        """Setup the plot with new curve data."""
        assert self.data is not None

        data, domain = self.data, self.data.domain
        if is_discrete(domain.class_var):
            class_col_data, _ = data.get_column_view(domain.class_var)

            group_indices = [np.flatnonzero(class_col_data == i)
                             for i in range(len(domain.class_var.values))]
        else:
            group_indices = [np.arange(len(data))]

        X = np.arange(1, len(domain.attributes)+1)
        groups = []

        for i, indices in enumerate(group_indices):
            if self.classes:
                color = self.class_colors[i]
            else:
                color = QColor(Qt.darkGray)
            group_data = data[indices, :]
            plot_x, plot_y, connect = disconnected_curve_data(group_data.X, x=X)

            color.setAlpha(200)
            lightcolor = QColor(color.lighter(factor=150))
            lightcolor.setAlpha(150)
            pen = QPen(color, 2)
            pen.setCosmetic(True)

            lightpen = QPen(lightcolor, 1)
            lightpen.setCosmetic(True)
            hoverpen = QPen(pen)
            hoverpen.setWidth(2)

            curve = pg.PlotCurveItem(
                x=plot_x, y=plot_y, connect=connect,
                pen=lightpen, symbolSize=2, antialias=True,
            )
            self.graph.addItem(curve)

            hovercurves = []
            for index, profile in zip(indices, group_data.X):
                hcurve = HoverCurve(x=X, y=profile, pen=hoverpen,
                                    antialias=True)
                hcurve.setToolTip('{}'.format(index))
                hcurve._data_index = index
                hovercurves.append(hcurve)
                self.graph.addItem(hcurve)

            mean = np.nanmean(group_data.X, axis=0)

            meancurve = pg.PlotDataItem(
                x=X, y=mean, pen=pen, size=5, symbol="o", pxMode=True,
                symbolSize=5, antialias=True
            )
            hoverpen = QPen(hoverpen)
            hoverpen.setWidth(5)

            hc = HoverCurve(x=X, y=mean, pen=hoverpen, antialias=True)
            hc.setFlag(QGraphicsItem.ItemIsSelectable, False)
            self.graph.addItem(hc)

            self.graph.addItem(meancurve)
            self.legend_items.append(meancurve)
            q1, q2, q3 = np.nanpercentile(group_data.X, [25, 50, 75], axis=0)
            # TODO: implement and use a box plot item
            errorbar = pg.ErrorBarItem(
                x=X, y=mean,
                bottom=np.clip(mean - q1, 0, mean - q1),
                top=np.clip(q3 - mean, 0, q3 - mean),
                beam=0.5
            )
            self.graph.addItem(errorbar)
            groups.append(
                namespace(
                    data=group_data, indices=indices, profiles=curve,
                    hovercurves=hovercurves, mean=meancurve, boxplot=errorbar)
            )

        self.__groups = groups
        self.__update_visibility()
        self.__update_tooltips()
Exemple #12
0
        def add_points():
            nonlocal cur, image_token
            if image_token != self._image_token:
                return
            batch = visible[cur:cur + self.N_POINTS_PER_ITER]

            batch_lat = lat[batch]
            batch_lon = lon[batch]

            x, y = self.Projection.latlon_to_easting_northing(batch_lat, batch_lon)
            x, y = self.Projection.easting_northing_to_pixel(x, y, zoom, origin, map_pane_pos)

            if self._jittering:
                dx, dy = self._jittering_offsets[batch].T
                x, y = x + dx, y + dy

            colors = (self._colorgen.getRGB(self._scaled_color_values[batch]).tolist()
                      if self._color_attr else
                      repeat((0xff, 0, 0)))
            sizes = self._size_coef * \
                (self._sizes[batch] if self._size_attr else np.tile(10, len(batch)))

            opacity_subset, opacity_rest = self._opacity, int(.8 * self._opacity)
            for x, y, is_selected, size, color, _in_subset in \
                    zip(x, y, selected[batch], sizes, colors, in_subset[batch]):

                pensize2, selpensize2 = (.35, 1.5) if size >= 5 else (.15, .7)
                pensize2 *= self._size_coef
                selpensize2 *= self._size_coef

                size2 = size / 2
                if is_selected:
                    painter.setPen(QPen(QBrush(Qt.green), 2 * selpensize2))
                    painter.drawEllipse(x - size2 - selpensize2,
                                        y - size2 - selpensize2,
                                        size + selpensize2,
                                        size + selpensize2)
                color = QColor(*color)
                if _in_subset:
                    color.setAlpha(opacity_subset)
                    painter.setBrush(QBrush(color))
                    painter.setPen(QPen(QBrush(color.darker(180)), 2 * pensize2))
                else:
                    color.setAlpha(opacity_rest)
                    painter.setBrush(Qt.NoBrush)
                    painter.setPen(QPen(QBrush(color.lighter(120)), 2 * pensize2))

                painter.drawEllipse(x - size2 - pensize2,
                                    y - size2 - pensize2,
                                    size + pensize2,
                                    size + pensize2)

            im.save(self._overlay_image_path, 'PNG')
            self.evalJS('markersImageLayer.setUrl("{}#{}"); 0;'
                        .format(self.toFileURL(self._overlay_image_path),
                                np.random.random()))

            cur += self.N_POINTS_PER_ITER
            if cur < len(visible):
                QTimer.singleShot(10, add_points)
                self._owwidget.progressBarAdvance(100 / n_iters, None)
            else:
                self._owwidget.progressBarFinished(None)
                self._image_token = None
    def _setup_plot(self):
        """Setup the plot with new curve data."""
        assert self.data is not None

        data, domain = self.data, self.data.domain
        if is_discrete(domain.class_var):
            class_col_data, _ = data.get_column_view(domain.class_var)

            group_indices = [
                np.flatnonzero(class_col_data == i)
                for i in range(len(domain.class_var.values))
            ]
        else:
            group_indices = [np.arange(len(data))]

        X = np.arange(1, len(domain.attributes) + 1)
        groups = []

        for i, indices in enumerate(group_indices):
            if self.classes:
                color = self.class_colors[i]
            else:
                color = QColor(Qt.darkGray)
            group_data = data[indices, :]
            plot_x, plot_y, connect = disconnected_curve_data(group_data.X,
                                                              x=X)

            color.setAlpha(200)
            lightcolor = QColor(color.lighter(factor=150))
            lightcolor.setAlpha(150)
            pen = QPen(color, 2)
            pen.setCosmetic(True)

            lightpen = QPen(lightcolor, 1)
            lightpen.setCosmetic(True)
            hoverpen = QPen(pen)
            hoverpen.setWidth(2)

            curve = pg.PlotCurveItem(
                x=plot_x,
                y=plot_y,
                connect=connect,
                pen=lightpen,
                symbolSize=2,
                antialias=True,
            )
            self.graph.addItem(curve)

            hovercurves = []
            for index, profile in zip(indices, group_data.X):
                hcurve = HoverCurve(x=X,
                                    y=profile,
                                    pen=hoverpen,
                                    antialias=True)
                hcurve.setToolTip('{}'.format(index))
                hcurve._data_index = index
                hovercurves.append(hcurve)
                self.graph.addItem(hcurve)

            mean = np.nanmean(group_data.X, axis=0)

            meancurve = pg.PlotDataItem(x=X,
                                        y=mean,
                                        pen=pen,
                                        size=5,
                                        symbol="o",
                                        pxMode=True,
                                        symbolSize=5,
                                        antialias=True)
            hoverpen = QPen(hoverpen)
            hoverpen.setWidth(5)

            hc = HoverCurve(x=X, y=mean, pen=hoverpen, antialias=True)
            hc.setFlag(QGraphicsItem.ItemIsSelectable, False)
            self.graph.addItem(hc)

            self.graph.addItem(meancurve)
            self.legend_items.append(meancurve)
            q1, q2, q3 = np.nanpercentile(group_data.X, [25, 50, 75], axis=0)
            # TODO: implement and use a box plot item
            errorbar = pg.ErrorBarItem(x=X,
                                       y=mean,
                                       bottom=np.clip(mean - q1, 0, mean - q1),
                                       top=np.clip(q3 - mean, 0, q3 - mean),
                                       beam=0.5)
            self.graph.addItem(errorbar)
            groups.append(
                namespace(data=group_data,
                          indices=indices,
                          profiles=curve,
                          hovercurves=hovercurves,
                          mean=meancurve,
                          boxplot=errorbar))

        self.__groups = groups
        self.__update_visibility()
        self.__update_tooltips()
    def _setup_plot(self):
        """Setup the plot with new curve data."""
        assert self.data is not None
        self.graph.clear()

        data, domain = self.data, self.data.domain
        var = domain[self.group_var]
        class_col_data, _ = data.get_column_view(var)
        group_indices = [
            np.flatnonzero(class_col_data == i)
            for i in range(len(self.classes))
        ]

        self.graph.getAxis('bottom').setTicks([[
            (i + 1, str(a)) for i, a in enumerate(self.graph_variables)
        ]])

        X = np.arange(1, len(self.graph_variables) + 1)
        groups = []

        for i, indices in enumerate(group_indices):
            if len(indices) == 0:
                groups.append(None)
            else:
                if self.classes:
                    color = self.class_colors[i]
                else:
                    color = QColor(Qt.darkGray)
                group_data = data[indices, self.graph_variables]
                plot_x, plot_y, connect = disconnected_curve_data(group_data.X,
                                                                  x=X)

                color.setAlpha(200)
                lightcolor = QColor(color.lighter(factor=150))
                lightcolor.setAlpha(150)
                pen = QPen(color, 2)
                pen.setCosmetic(True)

                lightpen = QPen(lightcolor, 1)
                lightpen.setCosmetic(True)

                curve = pg.PlotCurveItem(
                    x=plot_x,
                    y=plot_y,
                    connect=connect,
                    pen=lightpen,
                    symbolSize=2,
                    antialias=True,
                )
                self.graph.addItem(curve)

                mean = np.nanmean(group_data.X, axis=0)

                meancurve = pg.PlotDataItem(x=X,
                                            y=mean,
                                            pen=pen,
                                            size=5,
                                            symbol="o",
                                            pxMode=True,
                                            symbolSize=5,
                                            antialias=True)
                self.graph.addItem(meancurve)

                q1, q2, q3 = np.nanpercentile(group_data.X, [25, 50, 75],
                                              axis=0)
                # TODO: implement and use a box plot item
                errorbar = pg.ErrorBarItem(x=X,
                                           y=mean,
                                           bottom=np.clip(
                                               mean - q1, 0, mean - q1),
                                           top=np.clip(q3 - mean, 0,
                                                       q3 - mean),
                                           beam=0.5)
                self.graph.addItem(errorbar)
                groups.append(
                    namespace(data=group_data,
                              indices=indices,
                              profiles=curve,
                              mean=meancurve,
                              boxplot=errorbar))

        self.__groups = groups
        self.__update_visibility()