Orange.widgets.utils.plot.OWPlot

Complexity

Total Complexity

399

Size/Duplication

Total Lines	1794
Duplicated Lines	0 %

116 Methods

Rating	Name	Duplication	Size	Complexity
A	set_axis_scale()	0	15	3
A	set_palette()	0	9	1
D	mousePressEvent()	0	26	8
A	setYRaxisTitle()	0	2	1
A	transform_for_axes()	0	12	2
A	setData()	0	3	1
B	transform_from_rects()	0	13	7
F	mouseStaticClick()	0	35	12
A	start_progress()	0	3	2
A	set_legend_margin()	0	4	1
B	bounds_for_axis()	0	11	5
A	setYLlabels()	0	2	1
A	enableGridXB()	0	3	1
A	inv_transform()	0	17	4
A	set_axis_enabled()	0	5	2
A	removeAllSelections()	0	3	1
A	add_custom_axis()	0	6	1
A	clear()	0	16	3
A	legend()	0	5	1
A	settings_list()	0	2	2
A	set_axis_title()	0	3	2
A	setShowYRaxisTitle()	0	4	3
A	wheelEvent()	0	4	1
A	activate_zooming()	0	6	1
B	get_selected_points()	0	15	5
A	transform_for_zoom()	0	11	2
D	notify_legend_moved()	0	33	8
A	zoom_in()	0	2	1
F	mouseMoveEvent()	0	59	23
A	setCanvasColor()	0	4	1
A	add_marker()	0	7	1
A	set_zoom_rect()	0	4	1
F	mouseReleaseEvent()	0	26	12
A	enableLRaxis()	0	2	1
A	plot_data()	0	2	1
A	send_selection()	0	3	2
A	end_progress()	0	3	2
A	color()	0	5	2
A	update_theme()	0	10	4
A	add_axis()	0	16	3
B	axis_line()	0	17	6
B	update_curves()	0	15	5
A	zoom_to_rect()	0	8	3
A	clear_markers()	0	7	2
A	showEvent()	0	2	1
B	update_legend()	0	30	6
A	zoom()	0	16	4
A	scrollContentsBy()	0	4	1
A	set_show_axis_title()	0	6	3
B	add_curve()	0	37	4
B	remove_all_axes()	0	11	5
A	event()	0	5	2
A	legend_rect()	0	5	2
A	isLegendEvent()	0	6	3
A	shuffle_points()	0	3	2
A	set_main_title()	0	6	1
D	add_custom_curve()	0	29	8
A	add_selection()	0	8	2
A	update_zoom()	0	10	1
A	rect_for_zoom()	0	9	1
C	update_performance()	0	26	7
A	activate_selection()	0	5	1
A	get_zoom_rect()	0	5	2
A	setYLaxisTitle()	0	2	1
A	reset_zoom()	0	3	1
B	ensure_inside()	0	16	7
B	map_from_graph()	0	30	4
A	zoom_back()	0	4	2
A	set_show_main_title()	0	6	1
F	getExampleTooltipText()	0	35	16
A	activate_polygon_selection()	0	5	1
A	save_to_file()	0	3	1
F	mouse_action()	0	23	15
A	setShowYLaxisTitle()	0	4	3
C	data_rect_for_axes()	0	20	10
A	zoom_out()	0	2	1
A	save_to_file_direct()	0	3	1
A	zoom_transform()	0	2	1
A	replot()	0	19	1
A	activate_panning()	0	5	1
A	setXlabels()	0	5	3
A	update_antialiasing()	0	5	2
A	set_progress()	0	8	3
A	activate_rectangle_selection()	0	6	1
A	update_filled_symbols()	0	3	1
B	transform()	0	17	5
D	set_main_curve_data()	0	66	9
A	setGridColor()	0	3	1
A	enableYRaxis()	0	2	1
A	resizeEvent()	0	7	3
B	gestureEvent()	0	15	5
A	enableGridYL()	0	3	1
A	set_state()	0	6	3
A	update_animations()	0	4	2
A	update_grid()	0	4	1
A	enableXaxis()	0	2	1
B	map_to_graph()	0	29	4
A	setYRlabels()	0	2	1
A	set_axis_labels()	0	16	2
A	clear_selection()	0	2	1
A	showTip()	0	2	1
B	__init__()	0	123	3
A	remove_curve()	0	6	1
B	animate()	0	15	6
A	set_axis_autoscale()	0	5	3
A	points_equal()	0	8	3
A	get_legend_margin()	0	2	1
A	setShowXaxisTitle()	0	4	3
A	setXaxisTitle()	0	2	1
A	set_axis_tick_length()	0	3	2
A	is_axis_auto_scale()	0	4	2
A	pan()	0	12	2
A	graph_area_rect()	0	2	1
A	axis_coordinate()	0	8	3
F	update_layout()	0	94	25
F	update_axes()	0	43	18

'''

#################
Plot (``owplot``)
#################

.. autoclass:: OrangeWidgets.plot.OWPlot

'''

from PyQt4 import QtCore, QtGui

The import PyQt4 could not be resolved.

Unused QtCore imported from PyQt4

from Orange.widgets.gui import OWComponent
from Orange.widgets.settings import Setting

LeftLegend = 0
RightLegend = 1
BottomLegend = 2
TopLegend = 3
ExternalLegend = 4

UNUSED_ATTRIBUTES_STR = 'unused attributes'

from .owaxis import *

This seems to re-define the built-in pow.

The usage of wildcard imports like owaxis should generally be avoided.

QGraphicsItem was imported with wildcard, but is not used.

degrees was imported with wildcard, but is not used.

sqrt was imported with wildcard, but is not used.

acosh was imported with wildcard, but is not used.

copysign was imported with wildcard, but is not used.

isfinite was imported with wildcard, but is not used.

QPainterPath was imported with wildcard, but is not used.

pi was imported with wildcard, but is not used.

asinh was imported with wildcard, but is not used.

NoPosition was imported with wildcard, but is not used.

SELECTION_REPLACE was imported with wildcard, but is not used.

e was imported with wildcard, but is not used.

atanh was imported with wildcard, but is not used.

TitleBelow was imported with wildcard, but is not used.

radians was imported with wildcard, but is not used.

isnan was imported with wildcard, but is not used.

QGraphicsPathItem was imported with wildcard, but is not used.

tan was imported with wildcard, but is not used.

trunc was imported with wildcard, but is not used.

ProbabilitiesZValue was imported with wildcard, but is not used.

sinh was imported with wildcard, but is not used.

QGraphicsLineItem was imported with wildcard, but is not used.

TitleAbove was imported with wildcard, but is not used.

SELECTION_REMOVE was imported with wildcard, but is not used.

erf was imported with wildcard, but is not used.

fsum was imported with wildcard, but is not used.

gamma was imported with wildcard, but is not used.

AxisEnd was imported with wildcard, but is not used.

hypot was imported with wildcard, but is not used.

ceil was imported with wildcard, but is not used.

exp was imported with wildcard, but is not used.

fabs was imported with wildcard, but is not used.

expm1 was imported with wildcard, but is not used.

cos was imported with wildcard, but is not used.

frexp was imported with wildcard, but is not used.

log10 was imported with wildcard, but is not used.

modf was imported with wildcard, but is not used.

resize_plot_item_list was imported with wildcard, but is not used.

ldexp was imported with wildcard, but is not used.

factorial was imported with wildcard, but is not used.

SELECTION_TOGGLE was imported with wildcard, but is not used.

fmod was imported with wildcard, but is not used.

AxisZValue was imported with wildcard, but is not used.

HighlightZValue was imported with wildcard, but is not used.

AxisStart was imported with wildcard, but is not used.

log1p was imported with wildcard, but is not used.

lgamma was imported with wildcard, but is not used.

ROTATING was imported with wildcard, but is not used.

log2 was imported with wildcard, but is not used.

SELECTION_ADD was imported with wildcard, but is not used.

PlotZValue was imported with wildcard, but is not used.

sin was imported with wildcard, but is not used.

atan2 was imported with wildcard, but is not used.

atan was imported with wildcard, but is not used.

log was imported with wildcard, but is not used.

acos was imported with wildcard, but is not used.

isinf was imported with wildcard, but is not used.

cosh was imported with wildcard, but is not used.

asin was imported with wildcard, but is not used.

tanh was imported with wildcard, but is not used.

QFontMetrics was imported with wildcard, but is not used.

floor was imported with wildcard, but is not used.

erfc was imported with wildcard, but is not used.

from .owcurve import *

The usage of wildcard imports like owcurve should generally be avoided.

OWPlotItem was imported with wildcard, but is not used.

from .owlegend import *

The usage of wildcard imports like owlegend should generally be avoided.

OWLegendGradient was imported with wildcard, but is not used.

OWLegendTitle was imported with wildcard, but is not used.

OWLegendItem was imported with wildcard, but is not used.

QSizeF was imported with wildcard, but is not used.

PointSymbol was imported with wildcard, but is not used.

QGraphicsObject was imported with wildcard, but is not used.

PointSize was imported with wildcard, but is not used.

move_item_xy was imported with wildcard, but is not used.

PointColor was imported with wildcard, but is not used.

QLinearGradient was imported with wildcard, but is not used.

from .owplotgui import OWPlotGUI
from .owtools import *

The usage of wildcard imports like owtools should generally be avoided.

ColorPaletteDlg was imported with wildcard, but is not used.

QGraphicsPixmapItem was imported with wildcard, but is not used.

qVersion was imported with wildcard, but is not used.

move_item was imported with wildcard, but is not used.

CircleCurve was imported with wildcard, but is not used.

QGraphicsPolygonItem was imported with wildcard, but is not used.

qRgb was imported with wildcard, but is not used.

Orange was imported with wildcard, but is not used.

PolygonCurve was imported with wildcard, but is not used.

get_variable_values_sorted was imported with wildcard, but is not used.

QImage was imported with wildcard, but is not used.

QPolygonF was imported with wildcard, but is not used.

ProbabilitiesItem was imported with wildcard, but is not used.

RectangleCurve was imported with wildcard, but is not used.

QPixmap was imported with wildcard, but is not used.

QGraphicsEllipseItem was imported with wildcard, but is not used.

UnconnectedLinesCurve was imported with wildcard, but is not used.

from ..colorpalette import ColorPaletteGenerator

from PyQt4.QtGui import (

The import PyQt4.QtGui could not be resolved.

    QPen, QBrush, QColor,
    QGraphicsView,  QGraphicsScene, QPainter, QTransform, QPolygonF,
    QGraphicsRectItem)

from PyQt4.QtCore import QPointF, QPropertyAnimation, pyqtProperty, SIGNAL, Qt, QEvent

The import PyQt4.QtCore could not be resolved.

## Color values copied from orngView.SchemaView for consistency
SelectionPen = QPen(QBrush(QColor(51, 153, 255, 192)),
                    1, Qt.SolidLine, Qt.RoundCap)
SelectionBrush = QBrush(QColor(168, 202, 236, 192))

#from OWDlgs import OWChooseImageSizeDlg
#from OWColorPalette import *      # color palletes, ...
#from Orange.utils import deprecated_members, deprecated_attribute

import orangeqt

The import orangeqt could not be resolved.

def n_min(*args):
    lst = args[0] if len(args) == 1 else args
    a = [i for i in lst if i is not None]
    return min(a) if a else None

def n_max(*args):
    lst = args[0] if len(args) == 1 else args
    a = [i for i in lst if i is not None]
    return max(a) if a else None

name_map = {
    "saveToFileDirect": "save_to_file_direct",
    "saveToFile" : "save_to_file",
    "addCurve" : "add_curve",
    "addMarker" : "add_marker",
    "updateLayout" : "update_layout",
    "activateZooming" : "activate_zooming",
    "activateSelection" : "activate_selection",
    "activateRectangleSelection" : "activate_rectangle_selection",
    "activatePolygonSelection" : "activate_polygon_selection",
    "activatePanning" : "activate_panning",
    "getSelectedPoints" : "get_selected_points",
    "setAxisScale" : "set_axis_scale",
    "setAxisLabels" : "set_axis_labels",
    "setAxisAutoScale" : "set_axis_autoscale",
    "setTickLength" : "set_axis_tick_length",
    "updateCurves" : "update_curves",
    "itemList" : "plot_items",
    "setShowMainTitle" : "set_show_main_title",
    "setMainTitle" : "set_main_title",
    "invTransform" : "inv_transform",
    "setAxisTitle" : "set_axis_title",
    "setShowAxisTitle" : "set_show_axis_title"
}

#@deprecated_members(name_map, wrap_methods=list(name_map.keys()))
class OWPlot(orangeqt.Plot, OWComponent):
    """
    The base class for all plots in Orange. It uses the Qt Graphics View Framework
    to draw elements on a graph.

    **Plot layout**

        .. attribute:: show_legend

            A boolean controlling whether the legend is displayed or not

        .. attribute:: show_main_title

            Controls whether or not the main plot title is displayed

        .. attribute:: main_title

            The plot title, usually show on top of the plot

        .. automethod:: set_main_title

        .. automethod:: set_show_main_title

        .. attribute:: axis_margin

            How much space (in pixels) should be left on each side for the axis, its label and its title.

        .. attribute:: title_margin

            How much space (in pixels) should be left at the top of the plot for the title, if the title is shown.

            .. seealso:: attribute :attr:`show_main_title`

        .. attribute:: plot_margin

            How much space (in pixels) should be left at each side of the plot as whitespace.


    **Coordinate transformation**

        There are several coordinate systems used by OWPlot:

        * `widget` coordinates.

          This is the coordinate system of the position returned by :meth:`.QEvent.pos()`.
          No calculations or positions is done with this coordinates, they must first be converted
          to scene coordinates with :meth:`mapToScene`.

        * `data` coordinates.

          The value used internally in Orange to specify the values of attributes.
          For example, this can be age in years, the number of legs, or any other numeric value.

        * `plot` coordinates.

          These coordinates specify where the plot items are placed on the graph, but doesn't account for zoom.
          They can be retrieved for a particular plot item with :meth:`.PlotItem.pos()`.

        * `scene` or `zoom` coordinates.

          Like plot coordinates, except that they take the :attr:`zoom_transform` into account. They represent the
          actual position of an item on the scene.

          These are the coordinates returned by :meth:`.PlotItem.scenePos()` and :meth:`mapToScene`.

          For example, they can be used to determine what is under the cursor.

        In most cases, you will use data coordinates for interacting with the actual data, and scene coordinates for
        interacting with the plot items. The other two sets are mostly used for converting.

        .. automethod:: map_to_graph

        .. automethod:: map_from_graph

        .. automethod:: transform

        .. automethod:: inv_transform

        .. method:: nearest_point(pos)

            Returns the point nearest to ``pos``, or ``None`` if no point is close enough.

            :param pos: The position in scene coordinates
            :type pos: QPointF

            :rtype: :obj:`.OWPoint`

        .. method:: point_at(pos)

            If there is a point with data coordinates equal to ``pos``, if is returned.
            Otherwise, this function returns None.

            :param pos: The position in data coordinates
            :type pos: tuple of float float

            :rtype: :obj:`.OWPoint`


    **Data curves**
        The preferred method for showing a series of data points is :meth:`set_main_curve_data`.
        It allows you to specify point positions, colors, labels, sizes and shapes.

        .. automethod:: set_main_curve_data

        .. automethod:: add_curve

        .. automethod:: add_custom_curve

        .. automethod:: add_marker

        .. method:: add_item(item)

            Adds any PlotItem ``item`` to this plot.
            Calling this function directly is useful for adding a :obj:`.Marker` or another object that does not have to appear in the legend.

This line is too long as per the coding-style (142/120).

            For data curves, consider using :meth:`add_custom_curve` instead.

        .. method:: plot_items()

            Returns the list of all plot items added to this graph with :meth:`add_item` or :meth:`.PlotItem.attach`.

    **Axes**

        .. automethod:: add_axis

        .. automethod:: add_custom_axis

        .. automethod:: set_axis_enabled

        .. automethod:: set_axis_labels

        .. automethod:: set_axis_scale

    **Settings**

	.. attribute:: gui

            An :obj:`.OWPlotGUI` object associated with this graph

    **Point Selection and Marking**

        There are four possible selection behaviors used for selecting or marking points in OWPlot.
        They are used in :meth:`select_points` and :meth:`mark_points` and are the same for both operations.

        .. data:: AddSelection

            The points are added to the selection, without affected the currently selected points

        .. data:: RemoveSelection

            The points are removed from the selection, without affected the currently selected points

        .. data:: ToggleSelection

            The points' selection state is toggled

        .. data:: ReplaceSelection

            The current selection is replaced with the new one

        .. note:: There are exactly the same functions for point selection and marking.
                For simplicity, they are only documented once.

        .. method:: select_points(area, behavior)
        .. method:: mark_points(area, behavior)

            Selects or marks all points inside the ``area``

            :param area: The newly selected/marked area
            :type area: QRectF or QPolygonF

            :param behavior: :data:`AddSelection`, :data:`RemoveSelection`, :data:`ToggleSelection` or :data:`ReplaceSelection`

This line is too long as per the coding-style (127/120).

            :type behavior: int

        .. method:: unselect_all_points()
        .. method:: unmark_all_points()

            Unselects or unmarks all the points in the plot

        .. method:: selected_points()
        .. method:: marked_points()

            Returns a list of all selected or marked points

            :rtype: list of OWPoint

        .. method:: selected_points(xData, yData)

            For each of the point specified by ``xData`` and ``yData``, the point's selection state is returned.

            :param xData: The list of x coordinates
            :type xData: list of float

            :param yData: The list of y coordinates
            :type yData: list of float

            :rtype: list of int

    **Color schemes**

        By default, OWPlot uses the application's system palette for drawing everything
        except data curves and points. This way, it maintains consistency with other application
        with regards to the user interface.

        If data is plotted with no color specified, it will use a system color as well,
        so that a good contrast with the background in guaranteed.

        OWPlot uses the :meth:`.OWidget.palette` to determine its color scheme, so it can be
        changed using :meth:`.QWidget.setPalette`. There are also two predefined color schemes:
        ``OWPalette.Dark`` and ``OWPalette.Light``, which provides a dark and a light scheme
        respectively.

        .. attribute:: theme_name

            A string attribute with three possible values:
            ==============  ===========================
            Value           Meaning
            --------------  ---------------------------
            "default"       The system palette is used
            "dark"          The dark theme is used
            "light"         The light theme is used
            ==============  ===========================

            To apply the settings, first set this attribute's value, and then call :meth:`update_theme`

        .. automethod:: update_theme

        On the other hand, curves with a specified color will use colors from Orange's palette,
        which can be configured within Orange. Each plot contains two separate palettes:
        one for continuous attributes, and one for discrete ones. Both are created by
        :obj:`.OWColorPalette.ColorPaletteGenerator`

        .. attribute:: continuous_palette

            The palette used when point color represents a continuous attribute

        .. attribute:: discrete_palette

            The palette used when point color represents a discrete attribute

    """

    point_settings = ["point_width", "alpha_value"]
    plot_settings = ["show_legend", "show_grid"]

    alpha_value = Setting(255)

    show_legend = Setting(False)
    show_grid = Setting(False)


    appearance_settings = ["antialias_plot", "animate_plot", "animate_points", "disable_animations_threshold", "auto_adjust_performance"]

This line is too long as per the coding-style (137/120).

    def settings_list(self, graph_name, settings):

This method could be written as a function/class method.

        return [graph_name + '.' + setting for setting in settings]

    def __init__(self, parent = None,  name = "None",  show_legend = 1, axes = [xBottom, yLeft], widget = None):

The default value [] might cause unintended side-effects.

The argument show_legend seems to be unused.

        """
            Creates a new graph

            If your visualization uses axes other than ``xBottom`` and ``yLeft``, specify them in the
            ``axes`` parameter. To use non-cartesian axes, set ``axes`` to an empty list
            and add custom axes with :meth:`add_axis` or :meth:`add_custom_axis`
        """
        orangeqt.Plot.__init__(self, parent)
        OWComponent.__init__(self, widget)
        self.widget = widget
        self.parent_name = name
        self.title_item = None

        self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)

        self._legend = OWLegend(self, self.scene())
        self._legend.setZValue(LegendZValue)
        self._legend_margin = QRectF(0, 0, 100, 0)
        self._legend_moved = False
        self.axes = dict()

        self.axis_margin = 50
        self.y_axis_extra_margin = 30
        self.title_margin = 40
        self.graph_margin = 10

        self.mainTitle = None
        self.showMainTitle = False
        self.XaxisTitle = None
        self.YLaxisTitle = None
        self.YRaxisTitle = None

        # Method aliases, because there are some methods with different names but same functions
        self.setCanvasBackground = self.setCanvasColor
        self.map_from_widget = self.mapToScene

        # OWScatterPlot needs these:
        self.point_width = 5
        self.show_filled_symbols = True
        self.show_grid = True

        self.curveSymbols = list(range(13))
        self.tips = TooltipManager(self)
        self.setMouseTracking(True)
        self.grabGesture(Qt.PinchGesture)
        self.grabGesture(Qt.PanGesture)

        self.state = NOTHING
        self._pressed_mouse_button = Qt.NoButton
        self._pressed_point = None
        self.selection_items = []
        self._current_rs_item = None
        self._current_ps_item = None
        self.polygon_close_treshold = 10
        self.sendSelectionOnUpdate = False
        self.auto_send_selection_callback = None

        self.data_range = {}
        self.map_transform = QTransform()
        self.graph_area = QRectF()

        ## Performance optimization
        self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
        self.scene().setItemIndexMethod(QGraphicsScene.NoIndex)

        self.animate_plot = True
        self.animate_points = True
        self.antialias_plot = True
        self.antialias_points = True
        self.antialias_lines = True

        self.auto_adjust_performance = True
        self.disable_animations_threshold = 5000
     #   self.setInteractive(False)

        self.warn_unused_attributes = False

        self._bounds_cache = {}
        self._transform_cache = {}
        self.block_update = False

        self.use_animations = True
        self._animations = []

        ## Mouse event handlers
        self.mousePressEventHandler = None
        self.mouseMoveEventHandler = None
        self.mouseReleaseEventHandler = None
        self.mouseStaticClickHandler = self.mouseStaticClick
        self.static_click = False

        self._marker_items = []
        self.grid_curve = PlotGrid(self)

        self._zoom_rect = None
        self._zoom_transform = QTransform()
        self.zoom_stack = []
        self.old_legend_margin = None
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        ## Add specified axes:

        for key in axes:
            if key in [yLeft, xTop]:
                self.add_axis(key, title_above=1)
            else:
                self.add_axis(key)

        self.continuous_palette = ColorPaletteGenerator(number_of_colors= -1)
        self.discrete_palette = ColorPaletteGenerator()

        self.gui = OWPlotGUI(self)
        """
            An :obj:`.OWPlotGUI` object associated with this plot
    	"""
        self.activate_zooming()
        self.selection_behavior = self.AddSelection

        self.main_curve = None

        self.replot()

#    selectionCurveList = deprecated_attribute("selectionCurveList", "selection_items")
#    autoSendSelectionCallback = deprecated_attribute("autoSendSelectionCallback", "auto_send_selection_callback")
#    showLegend = deprecated_attribute("showLegend", "show_legend")
#    pointWidth = deprecated_attribute("pointWidth", "point_width")
#    alphaValue = deprecated_attribute("alphaValue", "alpha_value")
#    useAntialiasing = deprecated_attribute("useAntialiasing", "use_antialiasing")
#    showFilledSymbols = deprecated_attribute("showFilledSymbols", "show_filled_symbols")
#    mainTitle = deprecated_attribute("mainTitle", "main_title")
#    showMainTitle = deprecated_attribute("showMainTitle", "show_main_title")
#    gridCurve = deprecated_attribute("gridCurve", "grid_curve")
#    contPalette = deprecated_attribute("contPalette", "continuous_palette")
#    discPalette = deprecated_attribute("discPalette", "discrete_palette")

    def scrollContentsBy(self, dx, dy):
        # This is overriden here to prevent scrolling with mouse and keyboard
        # Instead of moving the contents, we simply do nothing
        pass

    def graph_area_rect(self):
        return self.graph_area

    def map_to_graph(self, point, axes = None, zoom = False):
        '''
            Maps ``point``, which can be ether a tuple of (x,y), a QPoint or a QPointF, from data coordinates
            to plot coordinates.

            :param point: The point in data coordinates
            :type point: tuple or QPointF

            :param axes: The pair of axes along which to transform the point.
                         If none are specified, (xBottom, yLeft) will be used.
            :type axes: tuple of float float

            :param zoom: if ``True``, the current :attr:`zoom_transform` will be considered in the transformation, and the result will be in scene coordinates instead.

This line is too long as per the coding-style (167/120).

            :type zoom: int

            :return: The transformed point in scene coordinates
            :type: tuple of float float
        '''
        if type(point) == tuple:
            (x, y) = point
            point = QPointF(x, y)
        if axes:
            x_id, y_id = axes

It seems like you are trying to unpack a non-sequence, which was defined at line 485.

            point = point * self.transform_for_axes(x_id, y_id)
        else:
            point = point * self.map_transform
        if zoom:
            point = point * self._zoom_transform
        return (point.x(), point.y())

    def map_from_graph(self, point, axes = None, zoom = False):
        '''
            Maps ``point``, which can be ether a tuple of (x,y), a QPoint or a QPointF, from plot coordinates
            to data coordinates.

            :param point: The point in data coordinates
            :type point: tuple or QPointF

            :param axes: The pair of axes along which to transform the point. If none are specified, (xBottom, yLeft) will be used.

This line is too long as per the coding-style (131/120).

            :type axes: tuple of float float

            :param zoom: if ``True``, the current :attr:`zoom_transform` will be considered in the transformation, and the ``point`` should be in scene coordinates instead.

This line is too long as per the coding-style (172/120).

            :type zoom: int

            :returns: The transformed point in data coordinates
            :rtype: tuple of float float
        '''
        if type(point) == tuple:
            (x, y) = point
            point = QPointF(x,y)
        if zoom:
            t, ok = self._zoom_transform.inverted()

The variable ok seems to be unused.

            point = point * t
        if axes:
            x_id, y_id = axes

It seems like you are trying to unpack a non-sequence, which was defined at line 515.

            t, ok = self.transform_for_axes(x_id, y_id).inverted()
        else:
            t, ok = self.map_transform.inverted()
        ret = point * t
        return (ret.x(), ret.y())

    def save_to_file(self, extraButtons = []):

The default value [] might cause unintended side-effects.

        sizeDlg = OWChooseImageSizeDlg(self, extraButtons, parent=self)
        sizeDlg.exec_()

    def save_to_file_direct(self, fileName, size = None):
        sizeDlg = OWChooseImageSizeDlg(self)
        sizeDlg.saveImage(fileName, size)

    def activate_zooming(self):
        '''
            Activates the zooming mode, where the user can zoom in and out with a single mouse click
            or by dragging the mouse to form a rectangular area
        '''
        self.state = ZOOMING

    def activate_rectangle_selection(self):
        '''
            Activates the rectangle selection mode, where the user can select points in a rectangular area
            by dragging the mouse over them
        '''
        self.state = SELECT_RECTANGLE

    def activate_selection(self):
        '''
            Activates the point selection mode, where the user can select points by clicking on them
        '''
        self.state = SELECT

    def activate_polygon_selection(self):
        '''
            Activates the polygon selection mode, where the user can select points by drawing a polygon around them
        '''
        self.state = SELECT_POLYGON

    def activate_panning(self):
        '''
            Activates the panning mode, where the user can move the zoom projection by dragging the mouse
        '''
        self.state = PANNING

    def set_show_main_title(self, b):
        '''
            Shows the main title if ``b`` is ``True``, and hides it otherwise.
        '''
        self.showMainTitle = b
        self.replot()

    def set_main_title(self, t):
        '''
            Sets the main title to ``t``
        '''
        self.mainTitle = t
        self.replot()

    def setShowXaxisTitle(self, b = -1):
        if b == -1 and hasattr(self, 'showXaxisTitle'):
            b = self.showXaxisTitle
        self.set_show_axis_title(xBottom, b)

    def setXaxisTitle(self, title):
        self.set_axis_title(xBottom, title)

    def setShowYLaxisTitle(self, b = -1):
        if b == -1 and hasattr(self, 'showYLaxisTitle'):
            b = self.showYLaxisTitle
        self.set_show_axis_title(yLeft, b)

    def setYLaxisTitle(self, title):
        self.set_axis_title(yLeft, title)

    def setShowYRaxisTitle(self, b = -1):
        if b == -1 and hasattr(self, 'showYRaxisTitle'):
            b = self.showYRaxisTitle
        self.set_show_axis_title(yRight, b)

    def setYRaxisTitle(self, title):
        self.set_axis_title(yRight, title)

    def enableGridXB(self, b):
        self.grid_curve.set_x_enabled(b)
        self.replot()

    def enableGridYL(self, b):
        self.grid_curve.set_y_enabled(b)
        self.replot()

    def setGridColor(self, c):
        self.grid_curve.set_pen(QPen(c))
        self.replot()

    def setCanvasColor(self, c):
        p = self.palette()
        p.setColor(OWPalette.Canvas, c)
        self.set_palette(p)

    def setData(self, data):

The argument data seems to be unused.

        self.clear()
        self.replot()

    def setXlabels(self, labels):
        if xBottom in self.axes:
            self.set_axis_labels(xBottom, labels)
        elif xTop in self.axes:
            self.set_axis_labels(xTop, labels)

    def set_axis_autoscale(self, axis_id):
        if axis_id in self.axes:
            self.axes[axis_id].auto_scale = True
        elif axis_id in self.data_range:
            del self.data_range[axis_id]

    def set_axis_labels(self, axis_id, labels, values=None):
        '''
            Sets the labels of axis ``axis_id`` to ``labels``. This is used for axes displaying a discrete data type.

            :param labels: The ID of the axis to change
            :type labels: int

            :param labels: The list of labels to be displayed along the axis
            :type labels: A list of strings

            .. note:: This changes the axis scale and removes any previous scale set with :meth:`set_axis_scale`.
        '''
        if axis_id in self._bounds_cache:
            del self._bounds_cache[axis_id]
        self._transform_cache = {}
        self.axes[axis_id].set_labels(labels, values)

    def set_axis_scale(self, axis_id, min, max, step_size=0):

This seems to re-define the built-in max.

This seems to re-define the built-in min.

        '''
            Sets the scale of axis ``axis_id`` to show an interval between ``min`` and ``max``.
            If ``step`` is specified and non-zero, it determines the steps between label on the axis.
            Otherwise, they are calculated automatically.

            .. note:: This changes the axis scale and removes any previous labels set with :meth:`set_axis_labels`.
        '''
        if axis_id in self._bounds_cache:
            del self._bounds_cache[axis_id]
        self._transform_cache = {}
        if axis_id in self.axes:
            self.axes[axis_id].set_scale(min, max, step_size)
        else:
            self.data_range[axis_id] = (min, max)

    def set_axis_title(self, axis_id, title):
        if axis_id in self.axes:
            self.axes[axis_id].set_title(title)

    def set_show_axis_title(self, axis_id, b):
        if axis_id in self.axes:
            if b == -1:
                b = not self.axes[axis_id].show_title
            self.axes[axis_id].set_show_title(b)
            self.replot()

    def set_axis_tick_length(self, axis_id, minor, medium, major):
        if axis_id in self.axes:
            self.axes[axis_id].set_tick_legth(minor, medium, major)

    def setYLlabels(self, labels):
        self.set_axis_labels(yLeft, labels)

    def setYRlabels(self, labels):
        self.set_axis_labels(yRight, labels)

    def add_custom_curve(self, curve, enableLegend = False):
        '''
            Adds a custom PlotItem ``curve`` to the plot.
            If ``enableLegend`` is ``True``, a curve symbol defined by
            :meth:`.OWCurve.point_item` and the ``curve``'s name
            :obj:`.OWCurve.name` is added to the legend.

            This function recalculates axis bounds and replots the plot if needed.

            :param curve: The curve to add
            :type curve: :obj:`.OWCurve`
        '''
        self.add_item(curve)
        if enableLegend:
            self.legend().add_curve(curve)
        for key in [curve.axes()]:
            if key in self._bounds_cache:
                del self._bounds_cache[key]
        self._transform_cache = {}
        if hasattr(curve, 'tooltip'):
            curve.setToolTip(curve.tooltip)
        x,y = curve.axes()
        if curve.is_auto_scale() and (self.is_axis_auto_scale(x) or self.is_axis_auto_scale(y)):
            self.set_dirty()
            self.replot()
        else:
            curve.set_graph_transform(self.transform_for_axes(x,y))
            curve.update_properties()
        return curve

    def add_curve(self, name, brushColor = None, penColor = None, size = 5, style = Qt.NoPen,

The default value [] might cause unintended side-effects.

                 symbol = OWPoint.Ellipse, enableLegend = False, xData = [], yData = [], showFilledSymbols = None,

The argument showFilledSymbols seems to be unused.

                 lineWidth = 1, pen = None, autoScale = 0, antiAlias = None, penAlpha = 255, brushAlpha = 255,

The argument penAlpha seems to be unused.

The argument antiAlias seems to be unused.

The argument brushAlpha seems to be unused.

                 x_axis_key = xBottom, y_axis_key = yLeft):
        '''
            Creates a new :obj:`.OWCurve` with the specified parameters and adds it to the graph.
            If ``enableLegend`` is ``True``, a curve symbol is added to the legend.
        '''
        c = OWCurve(xData, yData, x_axis_key, y_axis_key, tooltip=name)
        c.set_zoom_transform(self._zoom_transform)
        c.name = name
        c.set_style(style)

        if not brushColor:
            brushColor = self.color(OWPalette.Data)
        if not penColor:
            penColor = self.color(OWPalette.Data)

        c.set_color(penColor)

        if pen:
            p = pen
        else:
            p = QPen()
            p.setColor(penColor)
            p.setWidth(lineWidth)
        c.set_pen(p)

        c.set_brush(brushColor)

        c.set_symbol(symbol)
        c.set_point_size(size)
        c.set_data(xData,  yData)

        c.set_auto_scale(autoScale)

        return self.add_custom_curve(c, enableLegend)

    def set_main_curve_data(self, x_data, y_data, color_data, label_data, size_data, shape_data, marked_data = [], valid_data = [], x_axis_key=xBottom, y_axis_key=yLeft):

This line is too long as per the coding-style (170/120).

The default value [] might cause unintended side-effects.

        """
            Creates a single curve that can have points of different colors, shapes and sizes.
            This is the preferred method for visualization that show a series of different points.

            :param x_data: The list of X coordinates of the points
            :type x_data: list of float

            :param y_data: The list of Y coordinates of the points
            :type y_data: list of float

            :param color_data: The list of point colors
            :type color_data: list of QColor

            :param label_data: The list of point labels
            :type label_data: list of str

            :param size_data: The list of point sizes
            :type size_data: list of int

            :param shape_data: The list of point symbols
            :type shape_data: list of int

            The number of points in the curve will be equal to min(len(x_data), len(y_data)).
            The other four list can be empty, in which case a default value will be used.
            If they contain only one element, its value will be used for all points.

            .. note:: This function does not add items to the legend automatically.
                      You will have to add them yourself with :meth:`.OWLegend.add_item`.

            .. seealso:: :obj:`.OWMultiCurve`, :obj:`.OWPoint`
        """
        if not self.main_curve:
            self.main_curve = OWMultiCurve([], [])
            self.add_item(self.main_curve)

        self.update_performance(len(x_data))

        if len(valid_data):
            import numpy

The import numpy could not be resolved.

            x_data = numpy.compress(valid_data, x_data)
            y_data = numpy.compress(valid_data, y_data)
            if len(color_data) > 1:
                color_data = numpy.compress(valid_data, color_data)
            if len(size_data) > 1:
                size_data = numpy.compress(valid_data, size_data)
            if len(shape_data) > 1:
                shape_data = numpy.compress(valid_data, shape_data)
            if len(label_data) > 1:
                label_data = numpy.compress(valid_data, label_data)
            if len(marked_data) > 1:
                marked_data = numpy.compress(valid_data, marked_data).tolist()

        c = self.main_curve
        c.set_data(x_data, y_data)
        c.set_axes(x_axis_key, y_axis_key)
        c.set_point_colors(color_data)
        c.set_point_labels(label_data)
        c.set_point_sizes(size_data)
        c.set_point_symbols(shape_data)
        if len(marked_data):
            c.set_points_marked(marked_data)
            self.marked_points_changed.emit()
        c.name = 'Main Curve'

        self.replot()

    def remove_curve(self, item):
        '''
            Removes ``item`` from the plot
        '''
        self.remove_item(item)
        self.legend().remove_curve(item)

    def plot_data(self, xData, yData, colors, labels, shapes, sizes):
        pass

    def add_axis(self, axis_id, title='', title_above=False, title_location=AxisMiddle,
                 line=None, arrows=0, zoomable=False, bounds=None):
        '''
            Creates an :obj:`OrangeWidgets.plot.OWAxis` with the specified ``axis_id`` and ``title``.
        '''
        a = OWAxis(axis_id, title, title_above, title_location, line, arrows, self, bounds=bounds)
        self.scene().addItem(a)
        a.zoomable = zoomable
        a.update_callback = self.replot
        if axis_id in self._bounds_cache:
            del self._bounds_cache[axis_id]
        self._transform_cache = {}
        self.axes[axis_id] = a
        if not axis_id in CartesianAxes:
            self.set_show_axis_title(axis_id, True)
        return a

    def remove_all_axes(self, user_only = True):
        '''
            Removes all axes from the plot
        '''
        ids = []
        for id,item in self.axes.items():

This seems to re-define the built-in id.

            if not user_only or id >= UserAxis:
                ids.append(id)
                self.scene().removeItem(item)
        for id in ids:
            del self.axes[id]

    def add_custom_axis(self, axis_id, axis):
        '''
            Adds a custom ``axis`` with id ``axis_id`` to the plot
        '''
        self.axes[axis_id] = axis
        self.replot()

    def add_marker(self, name, x, y, alignment = -1, bold = 0, color = None, brushColor = None, size=None, antiAlias = None,

This line is too long as per the coding-style (124/120).

The argument size seems to be unused.

The argument antiAlias seems to be unused.

                    x_axis_key = xBottom, y_axis_key = yLeft):
        m = Marker(name, x, y, alignment, bold, color, brushColor)
        self._marker_items.append((m, x, y, x_axis_key, y_axis_key))
        self.add_custom_curve(m)

        return m

    def removeAllSelections(self):
        ## TODO
        pass

    def clear(self):
        """
            Clears the plot, removing all curves, markers and tooltips.
            Axes and the grid are not removed
        """
        for i in self.plot_items():
            if i is not self.grid_curve:
                self.remove_item(i)
        self.main_curve = None
        self._bounds_cache = {}
        self._transform_cache = {}
        self.clear_markers()
        self.tips.removeAll()
        self.legend().clear()
        self.old_legend_margin = None
        self.update_grid()

    def clear_markers(self):
        """
            Removes all markers added with :meth:`add_marker` from the plot
        """
        for item,x,y,x_axis,y_axis in self._marker_items:

The variable x_axis seems to be unused.

The variable y_axis seems to be unused.

The variable y seems to be unused.

The variable x seems to be unused.

            item.detach()
        self._marker_items = []

    def update_layout(self):
        '''
            Updates the plot layout.

            This function recalculates the position of titles, axes, the legend and the main plot area.
            It does not update the curve or the other plot items.
        '''
        if not self.isVisible():
            # No point in updating the graph if it's still hidden
            return
        graph_rect = QRectF(self.contentsRect())
        self.centerOn(graph_rect.center())
        m = self.graph_margin
        graph_rect.adjust(m, m, -m, -m)

        if self.showMainTitle and self.mainTitle:
            if self.title_item:
                self.scene().remove_item(self.title_item)
                del self.title_item
            self.title_item = QGraphicsTextItem(self.mainTitle, scene=self.scene())
            title_size = self.title_item.boundingRect().size()
            ## TODO: Check if the title is too big

TODO and FIXME comments should generally be avoided.

            self.title_item.setPos( graph_rect.width()/2 - title_size.width()/2, self.title_margin/2 - title_size.height()/2 )

This line is too long as per the coding-style (126/120).

            graph_rect.setTop(graph_rect.top() + self.title_margin)

        if self.show_legend:
            self._legend_outside_area = QRectF(graph_rect)

The attribute _legend_outside_area was defined outside __init__.

            self._legend.max_size = self._legend_outside_area.size()
            r = self._legend_margin
            graph_rect.adjust(r.left(), r.top(), -r.right(), -r.bottom())

        self._legend.update_items()

        axis_rects = dict()
        base_margin = min(self.axis_margin,  graph_rect.height()/4, graph_rect.height()/4)
        if xBottom in self.axes and self.axes[xBottom].isVisible():

This code seems to be duplicated in your project.

            margin = base_margin
            if self.axes[xBottom].should_be_expanded():
                margin += min(20, graph_rect.height()/8, graph_rect.width() / 8)
            bottom_rect = QRectF(graph_rect)
            bottom_rect.setTop( bottom_rect.bottom() - margin)
            axis_rects[xBottom] = bottom_rect
            graph_rect.setBottom( graph_rect.bottom() - margin)
        if xTop in self.axes and self.axes[xTop].isVisible():

This code seems to be duplicated in your project.

            margin = base_margin
            if self.axes[xTop].should_be_expanded():
                margin += min(20, graph_rect.height()/8, graph_rect.width() / 8)
            top_rect = QRectF(graph_rect)
            top_rect.setBottom(top_rect.top() + margin)
            axis_rects[xTop] = top_rect
            graph_rect.setTop(graph_rect.top() + margin)
        if yLeft in self.axes and self.axes[yLeft].isVisible():

This code seems to be duplicated in your project.

            margin = base_margin
            if self.axes[yLeft].should_be_expanded():
                margin += min(20, graph_rect.height()/8, graph_rect.width() / 8)
            left_rect = QRectF(graph_rect)
            left = graph_rect.left() + margin + self.y_axis_extra_margin
            left_rect.setRight(left)
            graph_rect.setLeft(left)
            axis_rects[yLeft] = left_rect
            if xBottom in axis_rects:
                axis_rects[xBottom].setLeft(left)
            if xTop in axis_rects:
                axis_rects[xTop].setLeft(left)
        if yRight in self.axes and self.axes[yRight].isVisible():

This code seems to be duplicated in your project.

            margin = base_margin
            if self.axes[yRight].should_be_expanded():
                margin += min(20, graph_rect.height()/8, graph_rect.width() / 8)
            right_rect = QRectF(graph_rect)
            right = graph_rect.right() - margin - self.y_axis_extra_margin
            right_rect.setLeft(right)
            graph_rect.setRight(right)
            axis_rects[yRight] = right_rect
            if xBottom in axis_rects:
                axis_rects[xBottom].setRight(right)
            if xTop in axis_rects:
                axis_rects[xTop].setRight(right)

        if self.graph_area != graph_rect:
            self.graph_area = QRectF(graph_rect)
            self.set_graph_rect(self.graph_area)
            self._transform_cache = {}

            if self._zoom_rect:
                data_zoom_rect = self.map_transform.inverted()[0].mapRect(self._zoom_rect)
                self.map_transform = self.transform_for_axes()
                self.set_zoom_rect(self.map_transform.mapRect(data_zoom_rect))

        self.map_transform = self.transform_for_axes()

        for c in self.plot_items():
            x,y = c.axes()
            c.set_graph_transform(self.transform_for_axes(x,y))
            c.update_properties()

    def update_zoom(self):
        '''
            Updates the zoom transformation of the plot items.
        '''
        zt = self.zoom_transform()
        self._zoom_transform = zt
        self.set_zoom_transform(zt)

        self.update_axes(zoom_only=True)
        self.viewport().update()

    def update_axes(self, zoom_only=False):
        """
            Updates the axes.

            If ``zoom_only`` is ``True``, only the positions of the axes and their labels are recalculated.
            Otherwise, all their labels are updated.
        """
        if self.warn_unused_attributes and not zoom_only:
            self._legend.remove_category(UNUSED_ATTRIBUTES_STR)

        for id, item in self.axes.items():

This seems to re-define the built-in id.

            if item.scale is None and item.labels is None:
                item.auto_range = self.bounds_for_axis(id)

            if id in XAxes:
                (x,y) = (id, yLeft)
            elif id in YAxes:
                (x,y) = (xBottom, id)
            else:
                (x,y) = (xBottom, yLeft)

            if id in CartesianAxes:
                ## This class only sets the lines for these four axes, widgets are responsible for the rest
                if x in self.axes and y in self.axes:
                    item.data_line = self.axis_line(self.data_rect_for_axes(x,y), id)
            if id in CartesianAxes:
                item.graph_line = self.axis_line(self.graph_area, id, invert_y = True)
            elif item.data_line:
                t = self.transform_for_axes(x, y)
                item.graph_line = t.map(item.data_line)

            if item.graph_line and item.zoomable:
                item.graph_line = self._zoom_transform.map(item.graph_line)

            if not zoom_only:
                if item.graph_line:
                    item.show()
                else:
                    item.hide()
                    if self.warn_unused_attributes:
                        self._legend.add_item(UNUSED_ATTRIBUTES_STR, item.title, None)
            item.zoom_transform = self._zoom_transform
            item.update(zoom_only)

    def replot(self):
        '''
            Replot the entire graph.

            This functions redraws everything on the graph, so it can be very slow
        '''
        #self.setBackgroundBrush(self.color(OWPalette.Canvas))
        self._bounds_cache = {}
        self._transform_cache = {}
        self.set_clean()
        self.update_antialiasing()
        self.update_legend()
        self.update_layout()
        self.update_zoom()
        self.update_axes()
        self.update_grid()
        self.update_filled_symbols()
        self.setSceneRect(QRectF(self.contentsRect()))
        self.viewport().update()

    def update_legend(self):
        if self.show_legend and not self._legend_moved:
            ## If the legend hasn't been moved it, we set it outside, in the top right corner
            m = self.graph_margin
            r = QRectF(self.contentsRect())
            r.adjust(m, m, -m, -m)
            self._legend.max_size = r.size()
            self._legend.update_items()
            w = self._legend.boundingRect().width()
            self._legend_margin = QRectF(0, 0, w, 0)
            self._legend.set_floating(False)
            self._legend.set_orientation(Qt.Vertical)
            self._legend.setPos(QRectF(self.contentsRect()).topRight() + QPointF(-w, 0))


        if (self._legend.isVisible() == self.show_legend):

There is an unnecessary parenthesis after if.

            return

        self._legend.setVisible(self.show_legend)
        if self.show_legend:
            if self.old_legend_margin is not None:
                self.animate(self, 'legend_margin', self.old_legend_margin, duration = 100)
            else:
                r = self.legend_rect()
                self.ensure_inside(r, self.contentsRect())
                self._legend.setPos(r.topLeft())
                self.notify_legend_moved(r.topLeft())
        else:
            self.old_legend_margin = self.legend_margin
            self.animate(self, 'legend_margin', QRectF(), duration=100)

    def update_filled_symbols(self):
        ## TODO: Implement this in Curve.cpp

TODO and FIXME comments should generally be avoided.

        pass

    def update_grid(self):
        self.grid_curve.set_x_enabled(self.show_grid)
        self.grid_curve.set_y_enabled(self.show_grid)
        self.grid_curve.update_properties()

    def legend(self):
        '''
            Returns the plot's legend, which is a :obj:`OrangeWidgets.plot.OWLegend`
        '''
        return self._legend

    def legend_rect(self):
        if self.show_legend:
            return self._legend.mapRectToScene(self._legend.boundingRect())
        else:
            return QRectF()

    def isLegendEvent(self, event, function):
        if self.show_legend and self.legend_rect().contains(self.mapToScene(event.pos())):
            function(self, event)
            return True
        else:
            return False

    def mouse_action(self, event):
        b = event.buttons() | event.button()
        m = event.modifiers()
        if b == Qt.LeftButton | Qt.RightButton:
            b = Qt.MidButton
        if m & Qt.AltModifier and b == Qt.LeftButton:
            m = m & ~Qt.AltModifier
            b = Qt.MidButton

        if b == Qt.LeftButton and not m:
            return self.state

        if b == Qt.RightButton and not m and self.state == SELECT:
            return SELECT_RIGHTCLICK

        if b == Qt.MidButton:
            return PANNING

        if b in [Qt.LeftButton, Qt.RightButton] and (self.state == ZOOMING or m == Qt.ControlModifier):
            return ZOOMING

        if b == Qt.LeftButton and m == Qt.ShiftModifier:
            return SELECT

    ## Event handling

    def event(self, event):
        if event.type() == QEvent.Gesture:
            return self.gestureEvent(event)
        else:
            return orangeqt.Plot.event(self, event)

    def gestureEvent(self, event):
        for gesture in event.gestures():
            if gesture.state() == Qt.GestureStarted:
                self.current_gesture_scale = 1.

The attribute current_gesture_scale was defined outside __init__.

                event.accept(gesture)
                continue
            elif gesture.gestureType() == Qt.PinchGesture:
                old_animate_plot = self.animate_plot
                self.animate_plot = False
                self.zoom(gesture.centerPoint(), gesture.scaleFactor()/self.current_gesture_scale )
                self.current_gesture_scale = gesture.scaleFactor()

The attribute current_gesture_scale was defined outside __init__.

                self.animate_plot = old_animate_plot
            elif gesture.gestureType() == Qt.PanGesture:
                self.pan(gesture.delta())
        return True

    def resizeEvent(self, event):
        self.replot()
        s = event.size() - event.oldSize()
        if self.legend_margin.right() > 0:
            self._legend.setPos(self._legend.pos() + QPointF(s.width(), 0))
        if self.legend_margin.bottom() > 0:
            self._legend.setPos(self._legend.pos() + QPointF(0, s.height()))

    def showEvent(self, event):

The argument event seems to be unused.

        self.replot()

    def mousePressEvent(self, event):
        self.static_click = True
        self._pressed_mouse_button = event.button()
        self._pressed_mouse_pos = event.pos()

The attribute _pressed_mouse_pos was defined outside __init__.

        if self.mousePressEventHandler and self.mousePressEventHandler(event):
            event.accept()
            return

        if self.isLegendEvent(event, QGraphicsView.mousePressEvent):
            return

        point = self.mapToScene(event.pos())
        a = self.mouse_action(event)

        if a == SELECT and hasattr(self, 'move_selected_points'):
            self._pressed_point = self.nearest_point(point)
            self._pressed_point_coor = None

The attribute _pressed_point_coor was defined outside __init__.

            if self._pressed_point is not None:
                self._pressed_point_coor = self._pressed_point.coordinates()

The attribute _pressed_point_coor was defined outside __init__.

        if a == PANNING:
            self._last_pan_pos = point

The attribute _last_pan_pos was defined outside __init__.

            event.accept()
        else:
            orangeqt.Plot.mousePressEvent(self, event)

    def mouseMoveEvent(self, event):
        if event.buttons() and (self._pressed_mouse_pos - event.pos()).manhattanLength() > QtGui.QApplication.instance().startDragDistance():

This line is too long as per the coding-style (141/120).

            self.static_click = False

        if self.mouseMoveEventHandler and self.mouseMoveEventHandler(event):
            event.accept()
            return

        if self.isLegendEvent(event, QGraphicsView.mouseMoveEvent):
            return

        point = self.mapToScene(event.pos())
        if not self._pressed_mouse_button:
            if self.receivers(SIGNAL('point_hovered(Point*)')) > 0:
                self.point_hovered.emit(self.nearest_point(point))

        ## We implement a workaround here, because sometimes mouseMoveEvents are not fast enough
        ## so the moving legend gets left behind while dragging, and it's left in a pressed state
        if self._legend.mouse_down:
            QGraphicsView.mouseMoveEvent(self, event)
            return

        a = self.mouse_action(event)

        if a == SELECT and self._pressed_point is not None and self._pressed_point.is_selected() and hasattr(self, 'move_selected_points'):

This line is too long as per the coding-style (139/120).

            animate_points = self.animate_points
            self.animate_points = False
            x1, y1 = self._pressed_point_coor

It seems like you are trying to unpack a non-sequence, which was defined at line 1234.

            x2, y2 = self.map_from_graph(point, zoom=True)
            self.move_selected_points((x2 - x1, y2 - y1))
            self.replot()
            if self._pressed_point is not None:
                self._pressed_point_coor = self._pressed_point.coordinates()

The attribute _pressed_point_coor was defined outside __init__.

            self.animate_points = animate_points

        elif a in [SELECT, ZOOMING] and self.graph_area.contains(point):
            if not self._current_rs_item:
                self._selection_start_point = self.mapToScene(self._pressed_mouse_pos)

The attribute _selection_start_point was defined outside __init__.

                self._current_rs_item = QGraphicsRectItem(scene=self.scene())
                self._current_rs_item.setPen(SelectionPen)
                self._current_rs_item.setBrush(SelectionBrush)
                self._current_rs_item.setZValue(SelectionZValue)
            self._current_rs_item.setRect(QRectF(self._selection_start_point, point).normalized())
        elif a == PANNING:
            if not self._last_pan_pos:
                self._last_pan_pos = self.mapToScene(self._pressed_mouse_pos)

The attribute _last_pan_pos was defined outside __init__.

            self.pan(point - self._last_pan_pos)
            self._last_pan_pos = point

The attribute _last_pan_pos was defined outside __init__.

        else:
            x, y = self.map_from_graph(point, zoom=True)
            text, x, y = self.tips.maybeTip(x, y)
            if type(text) == int:
                text = self.buildTooltip(text)
            if text and x is not None and y is not None:
                tp = self.mapFromScene(QPointF(x,y) * self.map_transform * self._zoom_transform)
                self.showTip(tp.x(), tp.y(), text)
            else:
                orangeqt.Plot.mouseMoveEvent(self, event)


    def mouseReleaseEvent(self, event):
        self._pressed_mouse_button = Qt.NoButton

        if self.mouseReleaseEventHandler and self.mouseReleaseEventHandler(event):
            event.accept()
            return
        if self.static_click and self.mouseStaticClickHandler and self.mouseStaticClickHandler(event):
            event.accept()
            return

        if self.isLegendEvent(event, QGraphicsView.mouseReleaseEvent):
            return

        a = self.mouse_action(event)
        if a == SELECT and self._pressed_point is not None:
            self._pressed_point = None
        if a in [ZOOMING, SELECT] and self._current_rs_item:
            rect = self._current_rs_item.rect()
            if a == ZOOMING:
                self.zoom_to_rect(self._zoom_transform.inverted()[0].mapRect(rect))
            else:
                self.add_selection(rect)
            self.scene().removeItem(self._current_rs_item)
            self._current_rs_item = None
            return
        orangeqt.Plot.mouseReleaseEvent(self, event)

    def mouseStaticClick(self, event):
        point = self.mapToScene(event.pos())
        if point not in self.graph_area:
            return False

        a = self.mouse_action(event)
        b = event.buttons() | event.button()

        if a == ZOOMING:
            if event.button() == Qt.LeftButton:
                self.zoom_in(point)
            elif event.button() == Qt.RightButton:
                self.zoom_back()
            else:
                return False
            return True
        elif a == SELECT and b == Qt.LeftButton:
            point_item = self.nearest_point(point)
            b = self.selection_behavior

            if b == self.ReplaceSelection:
                self.unselect_all_points()
                b = self.AddSelection

            if point_item:
                point_item.set_selected(b == self.AddSelection or (b == self.ToggleSelection and not point_item.is_selected()))

This line is too long as per the coding-style (127/120).

            self.selection_changed.emit()
        elif a == SELECT and b == Qt.RightButton:
            point_item = self.nearest_point(point)
            if point_item:
                self.point_rightclicked.emit(self.nearest_point(point))
            else:
                self.unselect_all_points()
        else:
            return False

    def wheelEvent(self, event):
        point = self.mapToScene(event.pos())
        d = event.delta() / 120.0
        self.zoom(point, pow(2,d))

    @staticmethod
    def transform_from_rects(r1, r2):
        """
            Returns a QTransform that maps from rectangle ``r1`` to ``r2``.
        """
        if r1 is None or r2 is None:
            return QTransform()
        if r1.width() == 0 or r1.height() == 0 or r2.width() == 0 or r2.height() == 0:
            return QTransform()
        tr1 = QTransform().translate(-r1.left(), -r1.top())
        ts = QTransform().scale(r2.width()/r1.width(), r2.height()/r1.height())
        tr2 = QTransform().translate(r2.left(), r2.top())
        return tr1 * ts * tr2

    def transform_for_zoom(self, factor, point, rect):

The argument rect seems to be unused.

This method could be written as a function/class method.

        if factor == 1:
            return QTransform()

        dp = point

        t = QTransform()
        t.translate(dp.x(), dp.y())
        t.scale(factor, factor)
        t.translate(-dp.x(), -dp.y())
        return t

    def rect_for_zoom(self, point, old_rect, scale = 2):
        r = QRectF()
        r.setWidth(old_rect.width() / scale)
        r.setHeight(old_rect.height() / scale)
        r.moveCenter(point)

        self.ensure_inside(r, self.graph_area)

        return r

    def set_state(self, state):
        self.state = state
        if state != SELECT_RECTANGLE:
            self._current_rs_item = None
        if state != SELECT_POLYGON:
            self._current_ps_item = None

    def get_selected_points(self, xData, yData, validData):
        if self.main_curve:
            selected = []
            points = self.main_curve.points()
            i = 0
            for d in validData:
                if d:
                    selected.append(points[i].is_selected())
                    i += 1
                else:
                    selected.append(False)
        else:
            selected = self.selected_points(xData, yData)
        unselected = [not i for i in selected]
        return selected, unselected

    def add_selection(self, reg):
        """
            Selects all points in the region ``reg`` using the current :attr: `selection_behavior`.
        """
        self.select_points(reg, self.selection_behavior)
        self.viewport().update()
        if self.auto_send_selection_callback:
            self.auto_send_selection_callback()

    def points_equal(self, p1, p2):
        if type(p1) == tuple:
            (x, y) = p1
            p1 = QPointF(x, y)
        if type(p2) == tuple:
            (x, y) = p2
            p2 = QPointF(x, y)
        return (QPointF(p1)-QPointF(p2)).manhattanLength() < self.polygon_close_treshold

    def data_rect_for_axes(self, x_axis = xBottom, y_axis = yLeft):
        """
            Calculates the bounding rectangle in data coordinates for the axes ``x_axis`` and ``y_axis``.
        """
        if x_axis in self.axes and y_axis in self.axes:
            x_min, x_max = self.bounds_for_axis(x_axis, try_auto_scale=True)
            y_min, y_max = self.bounds_for_axis(y_axis, try_auto_scale=True)
            if (x_min or x_max) and (y_min or y_max):
                r = QRectF(x_min, y_min, x_max-x_min, y_max-y_min)
                return r
        r = orangeqt.Plot.data_rect_for_axes(self, x_axis, y_axis)
        for id, axis in self.axes.items():

This seems to re-define the built-in id.

            if id not in CartesianAxes and axis.data_line:
                r |= QRectF(axis.data_line.p1(), axis.data_line.p2())
        ## We leave a 5% margin on each side so the graph doesn't look overcrowded
        ## TODO: Perhaps change this from a fixed percentage to always round to a round number

TODO and FIXME comments should generally be avoided.

        dx = r.width() / 20.0
        dy = r.height() / 20.0
        r.adjust(-dx, -dy, dx, dy)
        return r

    def transform_for_axes(self, x_axis = xBottom, y_axis = yLeft):
        """
            Returns the graph transform that maps from data to scene coordinates using axes ``x_axis`` and ``y_axis``.
        """
        if not (x_axis, y_axis) in self._transform_cache:
            # We must flip the graph area, becase Qt coordinates start from top left, while graph coordinates start from bottom left

This line is too long as per the coding-style (132/120).

            a = QRectF(self.graph_area)
            t = a.top()
            a.setTop(a.bottom())
            a.setBottom(t)
            self._transform_cache[(x_axis, y_axis)] = self.transform_from_rects(self.data_rect_for_axes(x_axis, y_axis), a)

This line is too long as per the coding-style (123/120).

        return self._transform_cache[(x_axis, y_axis)]

    def transform(self, axis_id, value):
        """
            Transforms the ``value`` from data to plot coordinates along the axis ``axis_id``.

            This function always ignores zoom. If you need to account for zooming, use :meth:`map_to_graph`.
        """
        if axis_id in XAxes:
            size = self.graph_area.width()
            margin = self.graph_area.left()
        else:
            size = self.graph_area.height()
            margin = self.graph_area.top()
        m, M = self.bounds_for_axis(axis_id)
        if m is None or M is None or M == m:
            return 0
        else:
            return margin + (value-m)/(M-m) * size

    def inv_transform(self, axis_id, value):
        """
            Transforms the ``value`` from plot to data coordinates along the axis ``axis_id``.

            This function always ignores zoom. If you need to account for zooming, use :meth:`map_from_graph`.
        """
        if axis_id in XAxes:
            size = self.graph_area.width()
            margin = self.graph_area.left()
        else:
            size = self.graph_area.height()
            margin = self.graph_area.top()
        m, M = self.bounds_for_axis(axis_id)
        if m is not None and M is not None:
            return m + (value-margin)/size * (M-m)
        else:
            return 0

    def bounds_for_axis(self, axis_id, try_auto_scale=True):
        if axis_id in self.axes and not self.axes[axis_id].auto_scale:
            return self.axes[axis_id].bounds()
        if try_auto_scale:
            lower, upper = orangeqt.Plot.bounds_for_axis(self, axis_id)
            if lower != upper:
                lower = lower - (upper-lower)/20.0
                upper = upper + (upper-lower)/20.0
            return lower, upper
        else:
            return None, None

    def enableYRaxis(self, enable=1):
        self.set_axis_enabled(yRight, enable)

    def enableLRaxis(self, enable=1):
        self.set_axis_enabled(yLeft, enable)

    def enableXaxis(self, enable=1):
        self.set_axis_enabled(xBottom, enable)

    def set_axis_enabled(self, axis, enable):
        if axis not in self.axes:
            self.add_axis(axis)
        self.axes[axis].setVisible(enable)
        self.replot()

    @staticmethod
    def axis_coordinate(point, axis_id):
        if axis_id in XAxes:
            return point.x()
        elif axis_id in YAxes:
            return point.y()
        else:
            return None

    # ####################################################################
    # return string with attribute names and their values for example example
    def getExampleTooltipText(self, example, indices=None, maxIndices=20):
        if indices and type(indices[0]) == str:
            indices = [self.attributeNameIndex[i] for i in indices]
        if not indices:
            indices = list(range(len(self.dataDomain.attributes)))

        # don't show the class value twice
        if example.domain.classVar:
            classIndex = self.attributeNameIndex[example.domain.classVar.name]
            while classIndex in indices:
                indices.remove(classIndex)

        text = "<b>Attributes:</b><br>"
        for index in indices[:maxIndices]:
            attr = self.attributeNames[index]
            if attr not in example.domain:  text += "&nbsp;"*4 + "%s = ?<br>" % (Qt.escape(attr))
            elif example[attr].isSpecial(): text += "&nbsp;"*4 + "%s = ?<br>" % (Qt.escape(attr))
            else:                           text += "&nbsp;"*4 + "%s = %s<br>" % (Qt.escape(attr), Qt.escape(str(example[attr])))

This line is too long as per the coding-style (129/120).

        if len(indices) > maxIndices:
            text += "&nbsp;"*4 + " ... <br>"

        if example.domain.classVar:
            text = text[:-4]
            text += "<hr><b>Class:</b><br>"
            if example.getclass().isSpecial(): text += "&nbsp;"*4 + "%s = ?<br>" % (Qt.escape(example.domain.classVar.name))

This line is too long as per the coding-style (124/120).

            else:                              text += "&nbsp;"*4 + "%s = %s<br>" % (Qt.escape(example.domain.classVar.name), Qt.escape(str(example.getclass())))

This line is too long as per the coding-style (161/120).

        if len(example.domain.getmetas()) != 0:
            text = text[:-4]
            text += "<hr><b>Meta attributes:</b><br>"
            # show values of meta attributes
            for key in example.domain.getmetas():
                try: text += "&nbsp;"*4 + "%s = %s<br>" % (Qt.escape(example.domain[key].name), Qt.escape(str(example[key])))

This line is too long as per the coding-style (125/120).

                except: pass

This except handler seems to be unused and could be removed.

General except handlers without types should be used sparingly.

        return text[:-4]        # remove the last <br>

    # show a tooltip at x,y with text. if the mouse will move for more than 2 pixels it will be removed
    def showTip(self, x, y, text):
        QToolTip.showText(self.mapToGlobal(QPoint(x, y)), text, self, QRect(x-3,y-3,6,6))

    def notify_legend_moved(self, pos):
        self._legend_moved = True
        l = self.legend_rect()

The variable l seems to be unused.

        g = getattr(self, '_legend_outside_area', QRectF())
        p = QPointF()
        rect = QRectF()
        offset = 20
        if pos.x() > g.right() - offset:
            self._legend.set_orientation(Qt.Vertical)
            rect.setRight(self._legend.boundingRect().width())
            p = g.topRight() - self._legend.boundingRect().topRight()
        elif pos.x() < g.left() + offset:
            self._legend.set_orientation(Qt.Vertical)
            rect.setLeft(self._legend.boundingRect().width())
            p = g.topLeft()
        elif pos.y() < g.top() + offset:
            self._legend.set_orientation(Qt.Horizontal)
            rect.setTop(self._legend.boundingRect().height())
            p = g.topLeft()
        elif pos.y() > g.bottom() - offset:
            self._legend.set_orientation(Qt.Horizontal)
            rect.setBottom(self._legend.boundingRect().height())
            p = g.bottomLeft() - self._legend.boundingRect().bottomLeft()

        if p.isNull():
            self._legend.set_floating(True, pos)
        else:
            self._legend.set_floating(False, p)

        if rect != self._legend_margin:
            orientation = Qt.Horizontal if rect.top() or rect.bottom() else Qt.Vertical
            self._legend.set_orientation(orientation)
            self.animate(self, 'legend_margin', rect, duration=100)

    def get_legend_margin(self):
        return self._legend_margin

    def set_legend_margin(self, value):
        self._legend_margin = value
        self.update_layout()
        self.update_axes()

    legend_margin = pyqtProperty(QRectF, get_legend_margin, set_legend_margin)

    def update_curves(self):
        if self.main_curve:
            self.main_curve.set_alpha_value(self.alpha_value)
        else:
            for c in self.plot_items():
                if isinstance(c, orangeqt.Curve) and not getattr(c, 'ignore_alpha', False):
                    au = c.auto_update()
                    c.set_auto_update(False)
                    c.set_point_size(self.point_width)
                    color = c.color()
                    color.setAlpha(self.alpha_value)
                    c.set_color(color)
                    c.set_auto_update(au)
                    c.update_properties()
        self.viewport().update()

    update_point_size = update_curves
    update_alpha_value = update_curves

    def update_antialiasing(self, use_antialiasing=None):
        if use_antialiasing is not None:
            self.antialias_plot = use_antialiasing

        self.setRenderHint(QPainter.Antialiasing, self.antialias_plot)

    def update_animations(self, use_animations=None):
        if use_animations is not None:
            self.animate_plot = use_animations
            self.animate_points = use_animations

    def update_performance(self, num_points = None):
        if self.auto_adjust_performance:
            if not num_points:
                if self.main_curve:
                    num_points = len(self.main_curve.points())
                else:
                    num_points = sum( len(c.points()) for c in self.curves )
            if num_points > self.disable_animations_threshold:
                self.disabled_animate_points = self.animate_points

The attribute disabled_animate_points was defined outside __init__.

                self.animate_points = False

                self.disabled_animate_plot = self.animate_plot

The attribute disabled_animate_plot was defined outside __init__.

                self.animate_plot = False

                self.disabled_antialias_lines = self.animate_points

The attribute disabled_antialias_lines was defined outside __init__.

                self.antialias_lines = True

            elif hasattr(self, 'disabled_animate_points'):
                self.animate_points = self.disabled_animate_points
                del self.disabled_animate_points

                self.animate_plot = self.disabled_animate_plot
                del self.disabled_animate_plot

                self.antialias_lines = True # self.disabled_antialias_lines
                del self.disabled_antialias_lines

    def animate(self, target, prop_name, end_val, duration = None, start_val = None):
        for a in self._animations:
            if a.state() == QPropertyAnimation.Stopped:
                self._animations.remove(a)
        if self.animate_plot:
            a = QPropertyAnimation(target, prop_name)
            a.setEndValue(end_val)
            if start_val is not None:
                a.setStartValue(start_val)
            if duration:
                a.setDuration(duration)
            self._animations.append(a)
            a.start(QPropertyAnimation.KeepWhenStopped)
        else:
            target.setProperty(prop_name, end_val)

    def clear_selection(self):
        self.unselect_all_points()

    def send_selection(self):
        if self.auto_send_selection_callback:
            self.auto_send_selection_callback()

    def pan(self, delta):
        if type(delta) == tuple:
            x, y = delta
        else:
            x, y = delta.x(), delta.y()
        t = self.zoom_transform()
        x = x / t.m11()
        y = y / t.m22()
        r = QRectF(self.zoom_rect)
        r.translate(-QPointF(x,y))
        self.ensure_inside(r, self.graph_area)
        self.zoom_rect = r

    def zoom_to_rect(self, rect):
        self.ensure_inside(rect, self.graph_area)

        # add to zoom_stack if zoom_rect is larger
        if self.zoom_rect.width() > rect.width() or self.zoom_rect.height() > rect.height():
            self.zoom_stack.append(self.zoom_rect)

        self.animate(self, 'zoom_rect', rect, start_val = self.get_zoom_rect())

    def zoom_back(self):
        if self.zoom_stack:
            rect = self.zoom_stack.pop()
            self.animate(self, 'zoom_rect', rect, start_val = self.get_zoom_rect())

    def reset_zoom(self):
        self._zoom_rect = None
        self.update_zoom()

    def zoom_transform(self):
        return self.transform_from_rects(self.zoom_rect, self.graph_area)

    def zoom_in(self, point):
        self.zoom(point, scale = 2)

    def zoom_out(self, point):
        self.zoom(point, scale = 0.5)

    def zoom(self, point, scale):
        print(len(self.zoom_stack))
        t, ok = self._zoom_transform.inverted()

The variable ok seems to be unused.

        point = point * t
        r = QRectF(self.zoom_rect)
        i = 1.0/scale
        r.setTopLeft(point*(1-i) + r.topLeft()*i)
        r.setBottomRight(point*(1-i) + r.bottomRight()*i)

        self.ensure_inside(r, self.graph_area)

        # remove smaller zoom rects from stack
        while len(self.zoom_stack) > 0 and r.width() >= self.zoom_stack[-1].width() and r.height() >= self.zoom_stack[-1].height():

This line is too long as per the coding-style (131/120).

            self.zoom_stack.pop()

        self.zoom_to_rect(r)

    def get_zoom_rect(self):
        if self._zoom_rect:
            return self._zoom_rect
        else:
            return self.graph_area

    def set_zoom_rect(self, rect):
        self._zoom_rect = rect
        self._zoom_transform = self.transform_from_rects(rect, self.graph_area)
        self.update_zoom()

    zoom_rect = pyqtProperty(QRectF, get_zoom_rect, set_zoom_rect)

    @staticmethod
    def ensure_inside(small_rect, big_rect):
        if small_rect.width() > big_rect.width():
            small_rect.setWidth(big_rect.width())
        if small_rect.height() > big_rect.height():
            small_rect.setHeight(big_rect.height())

        if small_rect.right() > big_rect.right():
            small_rect.moveRight(big_rect.right())
        elif small_rect.left() < big_rect.left():
            small_rect.moveLeft(big_rect.left())

        if small_rect.bottom() > big_rect.bottom():
            small_rect.moveBottom(big_rect.bottom())
        elif small_rect.top() < big_rect.top():
            small_rect.moveTop(big_rect.top())

    def shuffle_points(self):
        if self.main_curve:
            self.main_curve.shuffle_points()

    def set_progress(self, done, total):
        if not self.widget:
            return

        if done == total:
            self.widget.progressBarFinished()
        else:
            self.widget.progressBarSet(100.0 * done / total)

    def start_progress(self):
        if self.widget:
            self.widget.progressBarInit()

    def end_progress(self):
        if self.widget:
            self.widget.progressBarFinished()

    def is_axis_auto_scale(self, axis_id):
        if axis_id not in self.axes:
            return axis_id not in self.data_range
        return self.axes[axis_id].auto_scale

    def axis_line(self, rect, id, invert_y = False):

This seems to re-define the built-in id.

This method could be written as a function/class method.

        if invert_y:
            r = QRectF(rect)
            r.setTop(rect.bottom())
            r.setBottom(rect.top())
            rect = r
        if id == xBottom:
            line = QLineF(rect.topLeft(), rect.topRight())
        elif id == xTop:
            line = QLineF(rect.bottomLeft(), rect.bottomRight())
        elif id == yLeft:
            line = QLineF(rect.topLeft(), rect.bottomLeft())
        elif id == yRight:
            line = QLineF(rect.topRight(), rect.bottomRight())
        else:
            line = None
        return line

    def color(self, role, group = None):
        if group:
            return self.palette().color(group, role)
        else:
            return self.palette().color(role)

    def set_palette(self, p):
        '''
            Sets the plot palette to ``p``.

            :param p: The new color palette
            :type p: :obj:`.QPalette`
        '''
        self.setPalette(p)
        self.replot()

    def update_theme(self):
        '''
            Updates the current color theme, depending on the value of :attr:`theme_name`.
        '''
        if self.theme_name.lower() == 'default':
            self.set_palette(OWPalette.System)
        elif self.theme_name.lower() == 'light':
            self.set_palette(OWPalette.Light)
        elif self.theme_name.lower() == 'dark':
            self.set_palette(OWPalette.Dark)