Merge branch 'master' into master

Author: nschloe

matplotlib2tikz/__about__.py

@@ -5,6 +5,6 @@
 __copyright__ = 'Copyright (c) 2010-2017, %s <%s>' % (__author__, __email__)
 __credits__ = []
 __license__ = 'License :: OSI Approved :: MIT License'
-__version__ = '0.6.5'
+__version__ = '0.6.6'
 __maintainer__ = u'Nico Schlömer'
 __status__ = 'Development Status :: 5 - Production/Stable'

matplotlib2tikz/axes.py

@@ -198,6 +198,29 @@ def __init__(self, data, obj):
                     assert direction == 'inout'
                     self.axis_options.append('tick align=center')
 
+        # Set each rotation for every label
+        x_tick_rotation_and_horizontal_alignment = \
+            self.__get_label_rotation_and_horizontal_alignment(obj, data, 'x')
+        if x_tick_rotation_and_horizontal_alignment:
+            self.axis_options.append(x_tick_rotation_and_horizontal_alignment)
+
+        y_tick_rotation_and_horizontal_alignment = \
+            self.__get_label_rotation_and_horizontal_alignment(obj, data, 'y')
+        if y_tick_rotation_and_horizontal_alignment:
+            self.axis_options.append(y_tick_rotation_and_horizontal_alignment)
+
+        # Set tick position
+        x_tick_position_string, x_tick_position = \
+            self.__get_tick_position(obj, data, 'x')
+        y_tick_position_string, y_tick_position = \
+            self.__get_tick_position(obj, data, 'y')
+
+        if x_tick_position == y_tick_position and x_tick_position is not None:
+            self.axis_options.append("tick pos=%s" % x_tick_position)
+        else:
+            self.axis_options.append(x_tick_position_string)
+            self.axis_options.append(y_tick_position_string)
+
         # Don't use get_{x,y}gridlines for gridlines; see discussion on
         # <http://sourceforge.net/p/matplotlib/mailman/message/25169234/>
         # Coordinate of the lines are entirely meaningless, but styles
@@ -360,6 +383,113 @@ def __init__(self, data, obj):
 
         return
 
+    def __get_label_rotation_and_horizontal_alignment(self, obj, data, axes):
+        tick_label_text_width = None
+        tick_label_text_width_identifier = "%s tick label text width" % axes
+        if tick_label_text_width_identifier in data['extra axis options']:
+            tick_label_text_width = data['extra axis options [base]']
+            [tick_label_text_width_identifier]
+            del data['extra axis options'][tick_label_text_width_identifier]
+
+        label_style = ""
+
+        major_tick_labels = obj.xaxis.get_majorticklabels() if axes == 'x' \
+            else obj.yaxis.get_majorticklabels()
+
+        if len(major_tick_labels) == 0:
+            return None
+
+        tick_labels_rotation = \
+            [label.get_rotation() for label in major_tick_labels]
+        tick_labels_rotation_same_value = len(set(tick_labels_rotation)) == 1
+
+        tick_labels_horizontal_alignment = \
+            [label.get_horizontalalignment() for label in major_tick_labels]
+        tick_labels_horizontal_alignment_same_value = \
+            len(set(tick_labels_horizontal_alignment)) == 1
+
+        if tick_labels_rotation_same_value and \
+                tick_labels_horizontal_alignment_same_value:
+            values = []
+
+            if any(tick_labels_rotation) != 0:
+                values.append('rotate=%d' % tick_labels_rotation[0])
+
+            if tick_label_text_width:
+                values.append('align=%s' % tick_labels_horizontal_alignment[0])
+                values.append('text width=%s' % tick_label_text_width)
+            else:
+                print('Horizontal alignment will be ignored as no \'%s tick '
+                      'label text width\' has been passed in the \'extra\' '
+                      'parameter' % axes)
+
+            if len(values) > 0:
+                label_style = \
+                    '%sticklabel style = {%s}' % (axes, ','.join(values))
+        else:
+            values = []
+
+            if tick_labels_rotation_same_value:
+                values.append('rotate=%d' % tick_labels_rotation[0])
+            else:
+                values.append('rotate={%s,0}[\\ticknum]'
+                              % ','.join(str(x) for x in tick_labels_rotation))
+
+            if tick_label_text_width:
+                if tick_labels_horizontal_alignment_same_value:
+                    values.append('align=%s' %
+                                  tick_labels_horizontal_alignment[0])
+                    values.append('text width=%s' % tick_label_text_width)
+                else:
+                    for idx, x in enumerate(tick_labels_horizontal_alignment):
+                        label_style += '%s_tick_label_ha_%d/.initial = %s' \
+                            % (axes, idx, x)
+
+                    values.append(
+                        'align=\pgfkeysvalueof{/pgfplots/'
+                        '%s_tick_label_ha_\\ticknum}' % axes)
+                    values.append('text width=%s' % tick_label_text_width)
+            else:
+                print('Horizontal alignment will be ignored as no \'%s tick '
+                      'label text width\' has been passed in the \'extra\' '
+                      'parameter' % axes)
+
+            label_style = 'every %s tick label/.style = {\n' \
+                '%s\n' \
+                '}' % (axes, ',\n'.join(values))
+
+        return label_style
+
+    def __get_tick_position(self, obj, data, axes):
+        major_ticks = obj.xaxis.majorTicks if axes == 'x' else \
+            obj.yaxis.majorTicks
+
+        major_ticks_bottom = [tick.tick1On for tick in major_ticks]
+        major_ticks_top = [tick.tick2On for tick in major_ticks]
+
+        major_ticks_bottom_show_all = False
+        if len(set(major_ticks_bottom)) == 1 and major_ticks_bottom[0] is True:
+            major_ticks_bottom_show_all = True
+
+        major_ticks_top_show_all = False
+        if len(set(major_ticks_top)) == 1 and major_ticks_top[0] is True:
+            major_ticks_top_show_all = True
+
+        major_ticks_position = None
+        if not major_ticks_bottom_show_all and not major_ticks_top_show_all:
+            position_string = "%smajorticks=false" % axes
+        elif major_ticks_bottom_show_all and major_ticks_top_show_all:
+            major_ticks_position = 'both'
+        elif major_ticks_bottom_show_all:
+            major_ticks_position = 'left'
+        elif major_ticks_top_show_all:
+            major_ticks_position = 'right'
+
+        if major_ticks_position:
+            position_string = "%stick pos=%s" % (axes, major_ticks_position)
+
+        return position_string, major_ticks_position
+
     def get_begin_code(self):
         content = self.content
         if self.axis_options:

matplotlib2tikz/legend.py

@@ -1,6 +1,9 @@
 # -*- coding: utf-8 -*-
 #
 import warnings
+
+import numpy
+
 from . import color as mycol
 
 
@@ -19,52 +22,126 @@ def draw_legend(data, obj):
     # Get the location.
     # http://matplotlib.org/api/legend_api.html
     pad = 0.03
-    if obj._loc == 0:
+    loc = obj._loc
+    if loc == 0:
         # best
-        print(
-            'Legend location "best" not yet implemented, '
-            'choosing "upper right" instead.'
-            )
-        position = None
-        anchor = None
-    elif obj._loc == 1:
+        # Create a renderer
+        from matplotlib.backends import backend_agg
+        renderer = backend_agg.RendererAgg(width=obj.figure.get_figwidth(),
+                                           height=obj.figure.get_figheight(),
+                                           dpi=obj.figure.dpi)
+
+        # Rectangles of the legend and of the axes
+        # Lower left and upper right points
+        x0_legend, x1_legend = obj._legend_box \
+            .get_window_extent(renderer).get_points()
+        x0_axes, x1_axes = obj.axes.get_window_extent(renderer).get_points()
+        dimension_legend = x1_legend - x0_legend
+        dimension_axes = x1_axes - x0_axes
+
+        # To determine the actual position of the legend, check which corner
+        # (or center) of the legend is closest to the corresponding corner
+        # (or center) of the axes box.
+        # 1. Key points of the legend
+        lower_left_legend = x0_legend
+        lower_right_legend = numpy.array([x1_legend[0], x0_legend[1]],
+                                         dtype=numpy.float_)
+        upper_left_legend = numpy.array([x0_legend[0], x1_legend[1]],
+                                        dtype=numpy.float_)
+        upper_right_legend = x1_legend
+        center_legend = x0_legend + dimension_legend / 2.
+        center_left_legend = numpy.array(
+            [x0_legend[0], x0_legend[1] + dimension_legend[1] / 2.],
+            dtype=numpy.float_)
+        center_right_legend = numpy.array(
+            [x1_legend[0], x0_legend[1] + dimension_legend[1] / 2.],
+            dtype=numpy.float_)
+        lower_center_legend = numpy.array(
+            [x0_legend[0] + dimension_legend[0] / 2., x0_legend[1]],
+            dtype=numpy.float_)
+        upper_center_legend = numpy.array(
+            [x0_legend[0] + dimension_legend[0] / 2., x1_legend[1]],
+            dtype=numpy.float_)
+
+        # 2. Key points of the axes
+        lower_left_axes = x0_axes
+        lower_right_axes = numpy.array([x1_axes[0], x0_axes[1]],
+                                       dtype=numpy.float_)
+        upper_left_axes = numpy.array([x0_axes[0], x1_axes[1]],
+                                      dtype=numpy.float_)
+        upper_right_axes = x1_axes
+        center_axes = x0_axes + dimension_axes / 2.
+        center_left_axes = numpy.array(
+            [x0_axes[0], x0_axes[1] + dimension_axes[1] / 2.],
+            dtype=numpy.float_)
+        center_right_axes = numpy.array(
+            [x1_axes[0], x0_axes[1] + dimension_axes[1] / 2.],
+            dtype=numpy.float_)
+        lower_center_axes = numpy.array(
+            [x0_axes[0] + dimension_axes[0] / 2., x0_axes[1]],
+            dtype=numpy.float_)
+        upper_center_axes = numpy.array(
+            [x0_axes[0] + dimension_axes[0] / 2., x1_axes[1]],
+            dtype=numpy.float_)
+
+        # 3. Compute the distances between comparable points.
+        distances = {
+            1: upper_right_axes - upper_right_legend,  # upper right
+            2: upper_left_axes - upper_left_legend,  # upper left
+            3: lower_left_axes - lower_left_legend,  # lower left
+            4: lower_right_axes - lower_right_legend,  # lower right
+            # 5:, Not Implemented  # right
+            6: center_left_axes - center_left_legend,  # center left
+            7: center_right_axes - center_right_legend,  # center right
+            8: lower_center_axes - lower_center_legend,  # lower center
+            9: upper_center_axes - upper_center_legend,  # upper center
+            10: center_axes - center_legend  # center
+        }
+        for k, v in distances.items():
+            distances[k] = numpy.linalg.norm(v, ord=2)
+
+        # 4. Take the shortest distance between key points as the final
+        # location
+        loc = min(distances, key=distances.get)
+
+    if loc == 1:
         # upper right
         position = None
         anchor = None
-    elif obj._loc == 2:
+    elif loc == 2:
         # upper left
         position = [pad, 1.0 - pad]
         anchor = 'north west'
-    elif obj._loc == 3:
+    elif loc == 3:
         # lower left
         position = [pad, pad]
         anchor = 'south west'
-    elif obj._loc == 4:
+    elif loc == 4:
         # lower right
         position = [1.0 - pad, pad]
         anchor = 'south east'
-    elif obj._loc == 5:
+    elif loc == 5:
         # right
         position = [1.0 - pad, 0.5]
-        anchor = 'west'
-    elif obj._loc == 6:
+        anchor = 'east'
+    elif loc == 6:
         # center left
         position = [3 * pad, 0.5]
-        anchor = 'east'
-    elif obj._loc == 7:
+        anchor = 'west'
+    elif loc == 7:
         # center right
         position = [1.0 - 3 * pad, 0.5]
-        anchor = 'west'
-    elif obj._loc == 8:
+        anchor = 'east'
+    elif loc == 8:
         # lower center
         position = [0.5, 3 * pad]
         anchor = 'south'
-    elif obj._loc == 9:
+    elif loc == 9:
         # upper center
         position = [0.5, 1.0 - 3 * pad]
         anchor = 'north'
     else:
-        assert obj._loc == 10
+        assert loc == 10
         # center
         position = [0.5, 0.5]
         anchor = 'center'
@@ -100,7 +177,7 @@ def draw_legend(data, obj):
         if alignment != childAlignment:
             warnings.warn(
                 'Varying horizontal alignments in the legend. Using default.'
-                )
+            )
             alignment = None
             break
 

test/test_hashes.py renamed to test/helpers.py

@@ -1,25 +1,18 @@
 # -*- coding: utf-8 -*-
 #
 import matplotlib2tikz
-import testfunctions
 
 import os
 import tempfile
-from importlib import import_module
-import pytest
 import subprocess
 from PIL import Image
 import imagehash
 from matplotlib import pyplot as plt
 
 
-@pytest.mark.parametrize('name', testfunctions.__all__)
-def test_hash(name):
-    test = import_module('testfunctions.' + name)
-    # import the test
-    fig = test.plot()
+def compute_phash(fig):
     # convert to tikz file
-    _, tmp_base = tempfile.mkstemp(prefix=name)
+    _, tmp_base = tempfile.mkstemp()
     tikz_file = tmp_base + '_tikz.tex'
     matplotlib2tikz.save(
         tikz_file,
@@ -68,7 +61,7 @@ def test_hash(name):
     except subprocess.CalledProcessError as e:
         print('Command output:')
         print('=' * 70)
-        print(repr(e.output))
+        print(e.output)
         print('=' * 70)
         if 'DISPLAY' not in os.environ:
             cmd = ['curl', '-sT', tikz_file, 'chunk.io']
@@ -89,14 +82,23 @@ def test_hash(name):
     png_file = tmp_base + '-1.png'
 
     # compute the phash of the PNG
-    phash = imagehash.phash(Image.open(png_file)).__str__()
+    return (
+        imagehash.phash(Image.open(png_file)).__str__(), png_file, pdf_file,
+        tex_out, ptp_out, mpl_reference, tikz_file
+        )
+
+
+def assert_phash(fig, reference_phash):
+    phash, png_file, pdf_file, tex_out, ptp_out, mpl_reference, tikz_file =\
+        compute_phash(fig)
 
-    if test.phash != phash:
+    if reference_phash != phash:
         # Compute the Hamming distance between the two 64-bit numbers
-        hamming_dist = bin(int(phash, 16) ^ int(test.phash, 16)).count('1')
+        hamming_dist = \
+            bin(int(phash, 16) ^ int(reference_phash, 16)).count('1')
         print('Output file: %s' % png_file)
         print('computed pHash:  %s' % phash)
-        print('reference pHash: %s' % test.phash)
+        print('reference pHash: %s' % reference_phash)
         print(
             'Hamming distance: %s (out of %s)' %
             (hamming_dist, 4 * len(phash))
@@ -136,6 +138,6 @@ def test_hash(name):
                 )
             print('Uploaded output PNG file to %s' % out.decode('utf-8'))
 
-    assert test.phash == phash
+    assert reference_phash == phash
 
     return