Custom axis scales and ticks

Added convenience functions for 1) custom axis scaling e.g. the simplex
can have scaöe = 10 but the axes can be labelled for example from 10 to
20, 25 to 35 and 40 to 50, and 2) the ability to pass format strings
into lines.ticks() so that any or all of the axes can have int, float or
scientific format.

Author: tgwoodcock

ternary/helpers.py

@@ -114,3 +114,86 @@ def project_sequence(s, permutation=None):
 
     xs, ys = unzip([project_point(p, permutation=permutation) for p in s])
     return xs, ys
+
+
+## Convert coordinates for custom plots with limits ##
+
+def convert_coordinates(q,conversion,axisorder):
+    """
+    Convert a 3-tuple in data coordinates into to simplex data
+    coordinates for plotting.
+
+    Parameters
+    ----------
+    q, 3-tuple
+       the point to be plotted in data coordinates
+
+    conversion, dict
+                keys = ['b','l','r']
+                vals = lambda function giving the conversion
+
+    axisorder, str giving the order of the axes for
+               the coordinate tuple e.g. 'blr' for bottom, left,
+               right coordinates.
+
+    Returns
+    -------
+    p, 3-tuple
+       the point converted to simplex coordinates
+    """
+    p = []
+    for k in range(3):
+        p.append(conversion[axisorder[k]](q[k]))
+
+    return tuple(p)
+
+
+def get_conversion(scale,limits):
+    """
+    Get the converion equations for each axis.
+
+    limits: dict  of min and max values for the axes in the order blr.
+    """
+    fb = float(scale)/float(limits['b'][1]-limits['b'][0])
+    fl = float(scale)/float(limits['l'][1]-limits['l'][0])
+    fr = float(scale)/float(limits['r'][1]-limits['r'][0])
+
+    conversion = {"b" : lambda x: (x-limits['b'][0])*fb,
+                  "l" : lambda x: (x-limits['l'][0])*fl,
+                  "r" : lambda x: (x-limits['r'][0])*fr
+                  }
+
+    return conversion
+    
+
+def convert_coordinates_sequence(qs,scale,limits,axisorder):
+    """
+    Take a sequence of 3-tuples in data coordinates and convert them
+    to simplex coordinates for plotting. This is needed for custom
+    plots where the scale of the simplex axes is set within limits rather
+    than being defined by the scale parameter.
+
+    Parameters
+    ----------
+    qs, sequence of 3-tuples
+       the points to be plotted in data coordinates
+
+    scale, int
+                the scale parameter for the plot
+    
+    limits, dict
+                keys = ['b','l','r']
+                vals = min,max data values for this axis
+
+    axisorder, str giving the order of the axes for
+               the coordinate tuple e.g. 'blr' for bottom, left,
+               right coordinates.
+
+    Returns
+    -------
+    s, list of 3-tuples
+       the points converted to simplex coordinates
+    """
+    conversion = get_conversion(scale,limits)
+    
+    return [convert_coordinates(q,conversion,axisorder) for q in qs]

ternary/lines.py

@@ -186,7 +186,8 @@ def gridlines(ax, scale, multiple=None, horizontal_kwargs=None, left_kwargs=None
     return ax
 
 def ticks(ax, scale, ticks=None, locations=None, multiple=1, axis='b',
-          offset=0.01, clockwise=False, axes_colors=None, fsize = 10, **kwargs):
+          offset=0.01, clockwise=False, axes_colors=None, fsize = 10,
+          tick_formats=None, **kwargs):
     """
     Sets tick marks and labels.
 
@@ -213,6 +214,12 @@ def ticks(ax, scale, ticks=None, locations=None, multiple=1, axis='b',
     axes_colors: Dict, None
         Option to color ticks differently for each axis, 'l', 'r', 'b'
         e.g. {'l': 'g', 'r':'b', 'b': 'y'}
+    tick_formats: None, Dict, Str
+        If None, all axes will be labelled with ints. If Dict, the keys are
+        'b', 'l' and 'r' and the values are format strings e.g. "%.3f" for
+        a float with 3 decimal places or "%.3e" for scientific format with
+        3 decimal places or "%d" for ints. If tick_formats is a string, it
+        is assumed that this is a format string to be applied to all axes.
     kwargs:
         Any kwargs to pass through to matplotlib.
 
@@ -258,7 +265,16 @@ def ticks(ax, scale, ticks=None, locations=None, multiple=1, axis='b',
                 tick = ticks[index]
             line(ax, loc1, loc2, color=axes_colors['r'], **kwargs)
             x, y = project_point(text_location)
-            ax.text(x, y, str(tick), horizontalalignment="center", 
+            if tick_formats == None:
+                if type(tick) == int:
+                    s = str(tick)
+                else:
+                    s = str(int(tick))
+            elif type(tick_formats) == str:
+                s = tick_formats %(tick)
+            elif type(tick_formats == dict):
+                s = tick_formats['r'] %(tick)
+            ax.text(x, y, s, horizontalalignment="center", 
                 color=axes_colors['r'], fontsize=fsize)
 
     if 'l' in axis:
@@ -276,7 +292,16 @@ def ticks(ax, scale, ticks=None, locations=None, multiple=1, axis='b',
                 tick = ticks[-(index+1)]
             line(ax, loc1, loc2, color=axes_colors['l'], **kwargs)
             x, y = project_point(text_location)
-            ax.text(x, y, str(tick), horizontalalignment="center",
+            if tick_formats == None:
+                if type(tick) == int:
+                    s = str(tick)
+                else:
+                    s = str(int(tick))
+            elif type(tick_formats) == str:
+                s = tick_formats %(tick)
+            elif type(tick_formats == dict):
+                s = tick_formats['l'] %(tick)
+            ax.text(x, y, s, horizontalalignment="center",
                 color=axes_colors['l'], fontsize=fsize)
 
     if 'b' in axis:
@@ -294,5 +319,14 @@ def ticks(ax, scale, ticks=None, locations=None, multiple=1, axis='b',
                 tick = ticks[index]
             line(ax, loc1, loc2, color=axes_colors['b'], **kwargs)
             x, y = project_point(text_location)
-            ax.text(x, y, str(tick), horizontalalignment="center",
+            if tick_formats == None:
+                if type(tick) == int:
+                    s = str(tick)
+                else:
+                    s = str(int(tick))
+            elif type(tick_formats) == str:
+                s = tick_formats %(tick)
+            elif type(tick_formats == dict):
+                s = tick_formats['b'] %(tick)
+            ax.text(x, y, s, horizontalalignment="center",
                 color=axes_colors['b'], fontsize=fsize)

ternary/ternary_axes_subplot.py

@@ -10,7 +10,7 @@
 from . import heatmapping
 from . import lines
 from . import plotting
-from .helpers import project_point
+from .helpers import project_point, convert_coordinates_sequence
 
 
 def figure(ax=None, scale=None, permutation=None):
@@ -102,6 +102,20 @@ def set_scale(self, scale=None):
     def get_scale(self):
         return self._scale
 
+    def set_axis_limits(self, axis_limits=None):
+        """
+        Set min and max data limits for each of the three axes.
+
+        axis_limits = dict
+                keys are 'b','l' and 'r' for the three axes
+                vals are lists of the min and max values for the axis in
+                data units.
+        """
+        self._axis_limits = axis_limits
+
+    def get_axis_limits(self):
+        return self._axis_limits
+
     # Title and Axis Labels
 
     def set_title(self, title, **kwargs):
@@ -255,13 +269,42 @@ def clear_matplotlib_ticks(self, axis="both"):
         ax = self.get_axes()
         plotting.clear_matplotlib_ticks(ax=ax, axis=axis)
 
+
+    def get_ticks_from_axis_limits(self,multiple=1):
+        """
+        Taking self._axis_limits and self._boundary_scale get the scaled
+        ticks for all three axes and store them in self._ticks under the
+        keys 'b' for bottom, 'l' for left and 'r' for right axes.
+        """
+        for k in ['b','l','r']:
+            self._ticks[k] = numpy.linspace(self._axis_limits[k][0],
+                                            self._axis_limits[k][1],
+                                            (self._boundary_scale/float(multiple)+1)).tolist()
+
+
+
+    def set_custom_ticks(self, locations=None,clockwise=False,multiple=1,
+                         axes_colors=None, tick_formats=None, **kwargs):
+        """
+        Having called get_ticks_from_axis_limits, set the custom ticks on the
+        plot.
+        """
+        for k in ['b','l','r']:
+            self.ticks(ticks=self._ticks[k],locations=locations,
+                       axis=k,clockwise=clockwise, multiple=multiple,
+                       axes_colors=axes_colors, tick_formats=tick_formats,
+                       **kwargs)
+
+
     def ticks(self, ticks=None, locations=None, multiple=1, axis='blr',
-              clockwise=False, axes_colors=None, **kwargs):
+              clockwise=False, axes_colors=None, tick_formats=None,
+              **kwargs):
         ax = self.get_axes()
         scale = self.get_scale()
         lines.ticks(ax, scale, ticks=ticks, locations=locations,
                     multiple=multiple, clockwise=clockwise, axis=axis, 
-                    axes_colors=axes_colors, **kwargs)
+                    axes_colors=axes_colors, tick_formats=tick_formats,
+                    **kwargs)
 
     # Redrawing and resizing
 
@@ -293,6 +336,17 @@ def _redraw_labels(self):
             text.set_rotation_mode("anchor")
             self._to_remove.append(text)
 
+
+            
+    def convert_coordinates(self,points,axisorder='blr'):
+        """
+        Convert data coords to simplex coords for plotting
+        in the case that axis limits have been applied
+        """
+        return convert_coordinates_sequence(points,self._boundary_scale,
+                                            self._axis_limits,axisorder)
+
+
     ## Various Plots
 
     def scatter(self, points, **kwargs):