New upstream version 0.7.0+dfsg

1 files changed, 88 insertions, 89 deletions

diff --git a/silx/gui/plot/backends/BackendOpenGL.py b/silx/gui/plot/backends/BackendOpenGL.py
index c70b03a..3c18f4f 100644
--- a/silx/gui/plot/backends/BackendOpenGL.py
+++ b/silx/gui/plot/backends/BackendOpenGL.py
@@ -1,7 +1,7 @@
 # coding: utf-8
 # /*##########################################################################
 #
-# Copyright (c) 2014-2017 European Synchrotron Radiation Facility
+# Copyright (c) 2014-2018 European Synchrotron Radiation Facility
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -892,11 +892,13 @@ class BackendOpenGL(BackendBase.BackendBase, glu.OpenGLWidget):
         for item in self._items.values():
             shape2D = item.get('_shape2D')
             if shape2D is None:
+                closed = item['shape'] != 'polylines'
                 shape2D = Shape2D(tuple(zip(item['x'], item['y'])),
                                   fill=item['fill'],
                                   fillColor=item['color'],
                                   stroke=True,
-                                  strokeColor=item['color'])
+                                  strokeColor=item['color'],
+                                  strokeClosed=closed)
                 item['_shape2D'] = shape2D
 
             if ((isXLog and shape2D.xMin < FLOAT32_MINPOS) or
@@ -1032,17 +1034,8 @@ class BackendOpenGL(BackendBase.BackendBase, glu.OpenGLWidget):
                 data = numpy.array(data, dtype=numpy.float32, order='C')
 
             colormapIsLog = colormap.getNormalization() == 'log'
-
             cmapRange = colormap.getColormapRange(data=data)
-
-            # Retrieve colormap LUT from name and color array
-            colormapDisp = Colormap(name=colormap.getName(),
-                                    normalization=Colormap.LINEAR,
-                                    vmin=0,
-                                    vmax=255,
-                                    colors=colormap.getColormapLUT())
-            colormapLut = colormapDisp.applyToData(
-                numpy.arange(256, dtype=numpy.uint8))
+            colormapLut = colormap.getNColors(nbColors=256)
 
             image = GLPlotColormap(data,
                                    origin,
@@ -1087,7 +1080,8 @@ class BackendOpenGL(BackendBase.BackendBase, glu.OpenGLWidget):
 
     def addItem(self, x, y, legend, shape, color, fill, overlay, z):
         # TODO handle overlay
-        if shape not in ('polygon', 'rectangle', 'line', 'vline', 'hline'):
+        if shape not in ('polygon', 'rectangle', 'line',
+                         'vline', 'hline', 'polylines'):
             raise NotImplementedError("Unsupported shape {0}".format(shape))
 
         x = numpy.array(x, copy=False)
@@ -1107,6 +1101,9 @@ class BackendOpenGL(BackendBase.BackendBase, glu.OpenGLWidget):
             raise RuntimeError(
                 'Cannot add item with Y <= 0 with Y axis log scale')
 
+        # Ignore fill for polylines to mimic matplotlib
+        fill = fill if shape != 'polylines' else False
+
         self._items[legend] = {
             'shape': shape,
             'color': Colors.rgba(color),
@@ -1119,8 +1116,7 @@ class BackendOpenGL(BackendBase.BackendBase, glu.OpenGLWidget):
 
     def addMarker(self, x, y, legend, text, color,
                   selectable, draggable,
-                  symbol, constraint, overlay):
-        # TODO handle overlay
+                  symbol, constraint):
 
         if symbol is None:
             symbol = '+'
@@ -1227,90 +1223,93 @@ class BackendOpenGL(BackendBase.BackendBase, glu.OpenGLWidget):
             self._plotFrame.size[1] - self._plotFrame.margins.bottom - 1)
         return xPlot, yPlot
 
-    def pickItems(self, x, y):
+    def pickItems(self, x, y, kinds):
         picked = []
 
         dataPos = self.pixelToData(x, y, axis='left', check=True)
         if dataPos is not None:
             # Pick markers
-            for marker in reversed(list(self._markers.values())):
-                pixelPos = self.dataToPixel(
-                    marker['x'], marker['y'], axis='left', check=False)
-                if pixelPos is None:  # negative coord on a log axis
-                    continue
-
-                if marker['x'] is None:  # Horizontal line
-                    pt1 = self.pixelToData(
-                        x, y - self._PICK_OFFSET, axis='left', check=False)
-                    pt2 = self.pixelToData(
-                        x, y + self._PICK_OFFSET, axis='left', check=False)
-                    isPicked = (min(pt1[1], pt2[1]) <= marker['y'] <=
-                                max(pt1[1], pt2[1]))
-
-                elif marker['y'] is None:  # Vertical line
-                    pt1 = self.pixelToData(
-                        x - self._PICK_OFFSET, y, axis='left', check=False)
-                    pt2 = self.pixelToData(
-                        x + self._PICK_OFFSET, y, axis='left', check=False)
-                    isPicked = (min(pt1[0], pt2[0]) <= marker['x'] <=
-                                max(pt1[0], pt2[0]))
-
-                else:
-                    isPicked = (
-                        numpy.fabs(x - pixelPos[0]) <= self._PICK_OFFSET and
-                        numpy.fabs(y - pixelPos[1]) <= self._PICK_OFFSET)
-
-                if isPicked:
-                    picked.append(dict(kind='marker',
-                                       legend=marker['legend']))
-
-            # Pick image and curves
-            for item in self._plotContent.zOrderedPrimitives(reverse=True):
-                if isinstance(item, (GLPlotColormap, GLPlotRGBAImage)):
-                    pickedPos = item.pick(*dataPos)
-                    if pickedPos is not None:
-                        picked.append(dict(kind='image',
-                                           legend=item.info['legend']))
-
-                elif isinstance(item, GLPlotCurve2D):
-                    offset = self._PICK_OFFSET
-                    if item.marker is not None:
-                        offset = max(item.markerSize / 2., offset)
-                    if item.lineStyle is not None:
-                        offset = max(item.lineWidth / 2., offset)
-
-                    yAxis = item.info['yAxis']
-
-                    inAreaPos = self._mouseInPlotArea(x - offset, y - offset)
-                    dataPos = self.pixelToData(inAreaPos[0], inAreaPos[1],
-                                               axis=yAxis, check=True)
-                    if dataPos is None:
+            if 'marker' in kinds:
+                for marker in reversed(list(self._markers.values())):
+                    pixelPos = self.dataToPixel(
+                        marker['x'], marker['y'], axis='left', check=False)
+                    if pixelPos is None:  # negative coord on a log axis
                         continue
-                    xPick0, yPick0 = dataPos
 
-                    inAreaPos = self._mouseInPlotArea(x + offset, y + offset)
-                    dataPos = self.pixelToData(inAreaPos[0], inAreaPos[1],
-                                               axis=yAxis, check=True)
-                    if dataPos is None:
-                        continue
-                    xPick1, yPick1 = dataPos
+                    if marker['x'] is None:  # Horizontal line
+                        pt1 = self.pixelToData(
+                            x, y - self._PICK_OFFSET, axis='left', check=False)
+                        pt2 = self.pixelToData(
+                            x, y + self._PICK_OFFSET, axis='left', check=False)
+                        isPicked = (min(pt1[1], pt2[1]) <= marker['y'] <=
+                                    max(pt1[1], pt2[1]))
+
+                    elif marker['y'] is None:  # Vertical line
+                        pt1 = self.pixelToData(
+                            x - self._PICK_OFFSET, y, axis='left', check=False)
+                        pt2 = self.pixelToData(
+                            x + self._PICK_OFFSET, y, axis='left', check=False)
+                        isPicked = (min(pt1[0], pt2[0]) <= marker['x'] <=
+                                    max(pt1[0], pt2[0]))
 
-                    if xPick0 < xPick1:
-                        xPickMin, xPickMax = xPick0, xPick1
                     else:
-                        xPickMin, xPickMax = xPick1, xPick0
+                        isPicked = (
+                            numpy.fabs(x - pixelPos[0]) <= self._PICK_OFFSET and
+                            numpy.fabs(y - pixelPos[1]) <= self._PICK_OFFSET)
 
-                    if yPick0 < yPick1:
-                        yPickMin, yPickMax = yPick0, yPick1
-                    else:
-                        yPickMin, yPickMax = yPick1, yPick0
-
-                    pickedIndices = item.pick(xPickMin, yPickMin,
-                                              xPickMax, yPickMax)
-                    if pickedIndices:
-                        picked.append(dict(kind='curve',
-                                           legend=item.info['legend'],
-                                           indices=pickedIndices))
+                    if isPicked:
+                        picked.append(dict(kind='marker',
+                                           legend=marker['legend']))
+
+            # Pick image and curves
+            if 'image' in kinds or 'curve' in kinds:
+                for item in self._plotContent.zOrderedPrimitives(reverse=True):
+                    if ('image' in kinds and
+                            isinstance(item, (GLPlotColormap, GLPlotRGBAImage))):
+                        pickedPos = item.pick(*dataPos)
+                        if pickedPos is not None:
+                            picked.append(dict(kind='image',
+                                               legend=item.info['legend']))
+
+                    elif 'curve' in kinds and isinstance(item, GLPlotCurve2D):
+                        offset = self._PICK_OFFSET
+                        if item.marker is not None:
+                            offset = max(item.markerSize / 2., offset)
+                        if item.lineStyle is not None:
+                            offset = max(item.lineWidth / 2., offset)
+
+                        yAxis = item.info['yAxis']
+
+                        inAreaPos = self._mouseInPlotArea(x - offset, y - offset)
+                        dataPos = self.pixelToData(inAreaPos[0], inAreaPos[1],
+                                                   axis=yAxis, check=True)
+                        if dataPos is None:
+                            continue
+                        xPick0, yPick0 = dataPos
+
+                        inAreaPos = self._mouseInPlotArea(x + offset, y + offset)
+                        dataPos = self.pixelToData(inAreaPos[0], inAreaPos[1],
+                                                   axis=yAxis, check=True)
+                        if dataPos is None:
+                            continue
+                        xPick1, yPick1 = dataPos
+
+                        if xPick0 < xPick1:
+                            xPickMin, xPickMax = xPick0, xPick1
+                        else:
+                            xPickMin, xPickMax = xPick1, xPick0
+
+                        if yPick0 < yPick1:
+                            yPickMin, yPickMax = yPick0, yPick1
+                        else:
+                            yPickMin, yPickMax = yPick1, yPick0
+
+                        pickedIndices = item.pick(xPickMin, yPickMin,
+                                                  xPickMax, yPickMax)
+                        if pickedIndices:
+                            picked.append(dict(kind='curve',
+                                               legend=item.info['legend'],
+                                               indices=pickedIndices))
 
         return picked