clabel can be called with approximate postions of labels

leejjoon · leejjoon · commit 5883c662b7ff · 2011-12-28T11:32:57.000+09:00
diff --git a/examples/pylab_examples/contour_demo.py b/examples/pylab_examples/contour_demo.py
@@ -35,6 +35,16 @@
 plt.title('Simplest default with labels')
 
 
+# contour labels can be placed manually by providing list of positions
+# (in data coordinate). See ginput_manual_clabel.py for interactive
+# placement.
+plt.figure()
+CS = plt.contour(X, Y, Z)
+manual_locations = [(-1, -1.4), (-0.62, -0.7), (-2, 0.5), (1.7, 1.2), (2.0, 1.4), (2.4, 1.7)]
+plt.clabel(CS, inline=1, fontsize=10, manual=manual_locations)
+plt.title('labels at selected locations')
+
+
 # You can force all the contours to be the same color.
 plt.figure()
 CS = plt.contour(X, Y, Z, 6,
diff --git a/examples/pylab_examples/contour_label_demo.py b/examples/pylab_examples/contour_label_demo.py
@@ -50,7 +50,11 @@ def __repr__(self):
 CS.levels = [nf(val) for val in CS.levels ]
 
 # Label levels with specially formatted floats
-plt.clabel(CS, CS.levels, inline=True, fmt='%r %%', fontsize=10)
+if plt.rcParams["text.usetex"]:
+     fmt = r'%r \%%'
+else:
+     fmt = '%r %%'
+plt.clabel(CS, CS.levels, inline=True, fmt=fmt, fontsize=10)
 
 ##################################################
 # Label contours with arbitrary strings using a
diff --git a/lib/matplotlib/blocking_input.py b/lib/matplotlib/blocking_input.py
@@ -18,7 +18,7 @@
 """
 
 from __future__ import print_function
-from matplotlib import path, verbose
+from matplotlib import verbose
 from matplotlib.cbook import is_sequence_of_strings
 import matplotlib.lines as mlines
 
@@ -306,52 +306,10 @@ def button1(self,event):
         """
 
         # Shorthand
-        cs = self.cs
-
-        if event.inaxes == cs.ax:
-            conmin,segmin,imin,xmin,ymin = cs.find_nearest_contour(
-                event.x, event.y, cs.labelIndiceList)[:5]
-
-            # Get index of nearest level in subset of levels used for labeling
-            lmin = cs.labelIndiceList.index(conmin)
-
-            # Coordinates of contour
-            paths = cs.collections[conmin].get_paths()
-            lc = paths[segmin].vertices
-
-            # In pixel/screen space
-            slc = cs.ax.transData.transform(lc)
-
-            # Get label width for rotating labels and breaking contours
-            lw = cs.get_label_width(cs.labelLevelList[lmin],
-                                    cs.labelFmt, cs.labelFontSizeList[lmin])
-
-            """
-            # requires python 2.5
-            # Figure out label rotation.
-            rotation,nlc = cs.calc_label_rot_and_inline(
-                slc, imin, lw, lc if self.inline else [],
-                self.inline_spacing )
-            """
-            # Figure out label rotation.
-            if self.inline: lcarg = lc
-            else: lcarg = None
-            rotation,nlc = cs.calc_label_rot_and_inline(
-                slc, imin, lw, lcarg,
-                self.inline_spacing )
-
-            cs.add_label(xmin,ymin,rotation,cs.labelLevelList[lmin],
-                         cs.labelCValueList[lmin])
-
-            if self.inline:
-                # Remove old, not looping over paths so we can do this up front
-                paths.pop(segmin)
-
-                # Add paths if not empty or single point
-                for n in nlc:
-                    if len(n)>1:
-                        paths.append( path.Path(n) )
-
+        if event.inaxes == self.cs.ax:
+            self.cs.add_label_near(event.x, event.y, self.inline,
+                                   inline_spacing=self.inline_spacing,
+                                   transform=False)
             self.fig.canvas.draw()
         else: # Remove event if not valid
             BlockingInput.pop(self)
diff --git a/lib/matplotlib/contour.py b/lib/matplotlib/contour.py
@@ -110,6 +110,9 @@ def clabel(self, *args, **kwargs):
             placement, delete or backspace act like the third mouse button,
             and any other key will select a label location).
 
+            *manual* can be an iterable object of x,y tuples. Contour labels
+            will be created as if mouse is clicked at each x,y positions.
+
           *rightside_up*:
             if *True* (default), label rotations will always be plus
             or minus 90 degrees from level.
@@ -197,7 +200,12 @@ def clabel(self, *args, **kwargs):
         #self.labelCValues = [] # same
         self.labelXYs = []
 
-        if self.labelManual:
+        if cbook.iterable(self.labelManual):
+            for x,y in self.labelManual:
+                self.add_label_near(x, y, inline,
+                                    inline_spacing)
+
+        elif self.labelManual:
             print('Select label locations manually using first mouse button.')
             print('End manual selection with second mouse button.')
             if not inline:
@@ -532,6 +540,72 @@ def add_label_clabeltext(self,x,y,rotation,lev,cvalue):
         self._add_label(t, x, y, lev, cvalue)
 
 
+    def add_label_near(self, x, y, inline=True, inline_spacing=5,
+                       transform=None):
+        """
+        Add a label near the point (x, y) of the given transform.
+        If transform is None, data transform is used. If transform is
+        False, IdentityTransform is used.
+
+        *inline*:
+          controls whether the underlying contour is removed or
+          not. Default is *True*.
+
+        *inline_spacing*:
+          space in pixels to leave on each side of label when
+          placing inline.  Defaults to 5.  This spacing will be
+          exact for labels at locations where the contour is
+          straight, less so for labels on curved contours.
+        """
+
+        if transform is None:
+            transform = self.ax.transData
+
+        if transform:
+            x,y = transform.transform_point((x, y))
+
+        conmin,segmin,imin,xmin,ymin = self.find_nearest_contour(
+            x, y, self.labelIndiceList)[:5]
+
+        # Get index of nearest level in subset of levels used for labeling
+        lmin = self.labelIndiceList.index(conmin)
+
+        # Coordinates of contour
+        paths = self.collections[conmin].get_paths()
+        lc = paths[segmin].vertices
+
+        # In pixel/screen space
+        slc = self.ax.transData.transform(lc)
+
+        # Get label width for rotating labels and breaking contours
+        lw = self.get_label_width(self.labelLevelList[lmin],
+                                  self.labelFmt, self.labelFontSizeList[lmin])
+
+        """
+        # requires python 2.5
+        # Figure out label rotation.
+        rotation,nlc = cs.calc_label_rot_and_inline(
+            slc, imin, lw, lc if self.inline else [],
+            self.inline_spacing )
+        """
+        # Figure out label rotation.
+        if inline: lcarg = lc
+        else: lcarg = None
+        rotation,nlc = self.calc_label_rot_and_inline(
+            slc, imin, lw, lcarg,
+            inline_spacing )
+
+        self.add_label(xmin,ymin,rotation,self.labelLevelList[lmin],
+                       self.labelCValueList[lmin])
+
+        if inline:
+            # Remove old, not looping over paths so we can do this up front
+            paths.pop(segmin)
+
+            # Add paths if not empty or single point
+            for n in nlc:
+                if len(n)>1:
+                    paths.append( mpath.Path(n) )
 
     def pop_label(self,index=-1):
         '''Defaults to removing last label, but any index can be supplied'''
