import numpy as np

Author: nschloe

test/test_deterministic_output.py

@@ -8,7 +8,7 @@
 # the same process, the order of axis parameters is deterministic.
 plot_code = """
 import sys
-import numpy as np
+import numpy as np as np
 from matplotlib import pyplot as plt
 import tikzplotlib
 

test/test_text_overlay.py

@@ -1,12 +1,12 @@
 import matplotlib.pyplot as plt
-import numpy
+import numpy as np
 from helpers import assert_equality
 
 
 def plot():
     fig = plt.figure()
 
-    xxx = numpy.linspace(0, 5)
+    xxx = np.linspace(0, 5)
     yyy = xxx ** 2
     plt.text(
         1,

tikzplotlib/_axes.py

@@ -1,5 +1,5 @@
 import matplotlib as mpl
-import numpy
+import numpy as np
 from matplotlib.backends.backend_pgf import (
     common_texification as mpl_common_texification,
 )
@@ -731,7 +731,7 @@ def _handle_linear_segmented_color_map(cmap, data):
     # dimension errors or memory errors in latex)
     # 0-1000 is the internal granularity of PGFplots.
     # 16300 was the maximum value for pgfplots<=1.13
-    X = _scale_to_int(numpy.array(X), 1000)
+    X = _scale_to_int(np.array(X), 1000)
 
     color_changes = []
     ff = data["float format"]

tikzplotlib/_color.py

@@ -1,11 +1,11 @@
 import matplotlib as mpl
-import numpy
+import numpy as np
 
 
 def mpl_color2xcolor(data, matplotlib_color):
     """Translates a matplotlib color specification into a proper LaTeX xcolor."""
     # Convert it to RGBA.
-    my_col = numpy.array(mpl.colors.ColorConverter().to_rgba(matplotlib_color))
+    my_col = np.array(mpl.colors.ColorConverter().to_rgba(matplotlib_color))
 
     # If the alpha channel is exactly 0, then the color is really 'none'
     # regardless of the RGB channels.
@@ -18,22 +18,22 @@ def mpl_color2xcolor(data, matplotlib_color):
         # List white first such that for gray values, the combination
         # white!<x>!black is preferred over, e.g., gray!<y>!black. Note that
         # the order of the dictionary is respected from Python 3.6 on.
-        "white": numpy.array([1, 1, 1]),
-        "lightgray": numpy.array([0.75, 0.75, 0.75]),
-        "gray": numpy.array([0.5, 0.5, 0.5]),
-        "darkgray": numpy.array([0.25, 0.25, 0.25]),
-        "black": numpy.array([0, 0, 0]),
+        "white": np.array([1, 1, 1]),
+        "lightgray": np.array([0.75, 0.75, 0.75]),
+        "gray": np.array([0.5, 0.5, 0.5]),
+        "darkgray": np.array([0.25, 0.25, 0.25]),
+        "black": np.array([0, 0, 0]),
         #
-        "red": numpy.array([1, 0, 0]),
-        "green": numpy.array([0, 1, 0]),
-        "blue": numpy.array([0, 0, 1]),
-        "brown": numpy.array([0.75, 0.5, 0.25]),
-        "lime": numpy.array([0.75, 1, 0]),
-        "orange": numpy.array([1, 0.5, 0]),
-        "pink": numpy.array([1, 0.75, 0.75]),
-        "purple": numpy.array([0.75, 0, 0.25]),
-        "teal": numpy.array([0, 0.5, 0.5]),
-        "violet": numpy.array([0.5, 0, 0.5]),
+        "red": np.array([1, 0, 0]),
+        "green": np.array([0, 1, 0]),
+        "blue": np.array([0, 0, 1]),
+        "brown": np.array([0.75, 0.5, 0.25]),
+        "lime": np.array([0.75, 1, 0]),
+        "orange": np.array([1, 0.5, 0]),
+        "pink": np.array([1, 0.75, 0.75]),
+        "purple": np.array([0.75, 0, 0.25]),
+        "teal": np.array([0, 0.5, 0.5]),
+        "violet": np.array([0.5, 0, 0.5]),
         # The colors cyan, magenta, yellow, and olive are also
         # predefined by xcolor, but their RGB approximation of the
         # native CMYK values is not very good. Don't use them here.

tikzplotlib/_image.py

@@ -1,5 +1,5 @@
 import matplotlib as mpl
-import numpy
+import numpy as np
 import PIL
 
 from . import _files
@@ -30,11 +30,11 @@ def draw_image(data, obj):
         assert len(dims) == 3 and dims[2] in [3, 4]
         # convert to PIL image
         if obj.origin == "lower":
-            img_array = numpy.flipud(img_array)
+            img_array = np.flipud(img_array)
 
         # Convert mpl image to PIL
-        if img_array.dtype != numpy.uint8:
-            img_array = numpy.uint8(img_array * 255)
+        if img_array.dtype != np.uint8:
+            img_array = np.uint8(img_array * 255)
         image = PIL.Image.fromarray(img_array)
 
         # If the input image is PIL:

tikzplotlib/_legend.py

@@ -1,6 +1,6 @@
 import warnings
 
-import numpy
+import numpy as np
 
 from . import _color as mycol
 
@@ -111,40 +111,40 @@ def _get_location_from_best(obj):
     # (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_)
+    lower_right_legend = np.array([x1_legend[0], x0_legend[1]], dtype=np.float_)
+    upper_left_legend = np.array([x0_legend[0], x1_legend[1]], dtype=np.float_)
     upper_right_legend = x1_legend
     center_legend = x0_legend + dimension_legend / 2.0
-    center_left_legend = numpy.array(
-        [x0_legend[0], x0_legend[1] + dimension_legend[1] / 2.0], dtype=numpy.float_
+    center_left_legend = np.array(
+        [x0_legend[0], x0_legend[1] + dimension_legend[1] / 2.0], dtype=np.float_
     )
-    center_right_legend = numpy.array(
-        [x1_legend[0], x0_legend[1] + dimension_legend[1] / 2.0], dtype=numpy.float_
+    center_right_legend = np.array(
+        [x1_legend[0], x0_legend[1] + dimension_legend[1] / 2.0], dtype=np.float_
     )
-    lower_center_legend = numpy.array(
-        [x0_legend[0] + dimension_legend[0] / 2.0, x0_legend[1]], dtype=numpy.float_
+    lower_center_legend = np.array(
+        [x0_legend[0] + dimension_legend[0] / 2.0, x0_legend[1]], dtype=np.float_
     )
-    upper_center_legend = numpy.array(
-        [x0_legend[0] + dimension_legend[0] / 2.0, x1_legend[1]], dtype=numpy.float_
+    upper_center_legend = np.array(
+        [x0_legend[0] + dimension_legend[0] / 2.0, x1_legend[1]], dtype=np.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_)
+    lower_right_axes = np.array([x1_axes[0], x0_axes[1]], dtype=np.float_)
+    upper_left_axes = np.array([x0_axes[0], x1_axes[1]], dtype=np.float_)
     upper_right_axes = x1_axes
     center_axes = x0_axes + dimension_axes / 2.0
-    center_left_axes = numpy.array(
-        [x0_axes[0], x0_axes[1] + dimension_axes[1] / 2.0], dtype=numpy.float_
+    center_left_axes = np.array(
+        [x0_axes[0], x0_axes[1] + dimension_axes[1] / 2.0], dtype=np.float_
     )
-    center_right_axes = numpy.array(
-        [x1_axes[0], x0_axes[1] + dimension_axes[1] / 2.0], dtype=numpy.float_
+    center_right_axes = np.array(
+        [x1_axes[0], x0_axes[1] + dimension_axes[1] / 2.0], dtype=np.float_
     )
-    lower_center_axes = numpy.array(
-        [x0_axes[0] + dimension_axes[0] / 2.0, x0_axes[1]], dtype=numpy.float_
+    lower_center_axes = np.array(
+        [x0_axes[0] + dimension_axes[0] / 2.0, x0_axes[1]], dtype=np.float_
     )
-    upper_center_axes = numpy.array(
-        [x0_axes[0] + dimension_axes[0] / 2.0, x1_axes[1]], dtype=numpy.float_
+    upper_center_axes = np.array(
+        [x0_axes[0] + dimension_axes[0] / 2.0, x1_axes[1]], dtype=np.float_
     )
 
     # 3. Compute the distances between comparable points.
@@ -161,7 +161,7 @@ def _get_location_from_best(obj):
         10: center_axes - center_legend,  # center
     }
     for k, v in distances.items():
-        distances[k] = numpy.linalg.norm(v, ord=2)
+        distances[k] = np.linalg.norm(v, ord=2)
 
     # 4. Take the shortest distance between key points as the final
     # location

tikzplotlib/_line2d.py

@@ -1,6 +1,6 @@
 import datetime
 
-import numpy
+import numpy as np
 from matplotlib.dates import num2date
 
 from . import _color as mycol
@@ -222,7 +222,7 @@ def _table(obj, data):  # noqa: C901
     except AttributeError:
         ydata_mask = []
     else:
-        if isinstance(ydata_mask, numpy.bool_) and not ydata_mask:
+        if isinstance(ydata_mask, np.bool_) and not ydata_mask:
             ydata_mask = []
         elif callable(ydata_mask):
             # pandas.Series have the method mask
@@ -268,7 +268,7 @@ def _table(obj, data):  # noqa: C901
 
     plot_table = []
     table_row_sep = data["table_row_sep"]
-    ydata[ydata_mask] = numpy.nan
+    ydata[ydata_mask] = np.nan
     if any(ydata_mask):
         # matplotlib jumps at masked images, while PGFPlots by default interpolates.
         # Hence, if we have a masked plot, make sure that PGFPlots jumps as well.

tikzplotlib/_path.py

@@ -1,5 +1,5 @@
 import matplotlib as mpl
-import numpy
+import numpy as np
 from matplotlib.dates import DateConverter, num2date
 from matplotlib.markers import MarkerStyle
 
@@ -32,7 +32,7 @@ def draw_path(data, path, draw_options=None, simplify=None):
         #   The transform call yields warnings and it is unclear why. Perhaps
         #   the input data is not suitable? Anyhow, this should not happen.
         #   Comment out for now.
-        # vert = numpy.asarray(
+        # vert = np.asarray(
         #         _transform_to_data_coordinates(obj, [vert[0]], [vert[1]])
         #         )
         # For path codes see: http://matplotlib.org/api/path_api.html
@@ -123,7 +123,7 @@ def draw_pathcollection(data, obj):
 
     if obj.get_array() is not None:
         draw_options.append("scatter")
-        dd = numpy.column_stack([dd, obj.get_array()])
+        dd = np.column_stack([dd, obj.get_array()])
         labels.append("colordata" + 13 * " ")
         draw_options.append("scatter src=explicit")
         table_options.extend(["x=x", "y=y", "meta=colordata"])
@@ -159,9 +159,9 @@ def draw_pathcollection(data, obj):
         marker0 = None
         for marker, path in paths.items():
             if (
-                numpy.array_equal(path.codes, p.codes)
+                np.array_equal(path.codes, p.codes)
                 and (path.vertices.shape == p.vertices.shape)
-                and numpy.max(numpy.abs(path.vertices - p.vertices)) < 1.0e-10
+                and np.max(np.abs(path.vertices - p.vertices)) < 1.0e-10
             ):
                 marker0 = marker
                 break
@@ -197,8 +197,8 @@ def draw_pathcollection(data, obj):
         if len(obj.get_sizes()) == len(dd):
             # See Pgfplots manual, chapter 4.25.
             # In Pgfplots, \mark size specifies raddi, in matplotlib circle areas.
-            radii = numpy.sqrt(obj.get_sizes() / numpy.pi)
-            dd = numpy.column_stack([dd, radii])
+            radii = np.sqrt(obj.get_sizes() / np.pi)
+            dd = np.column_stack([dd, radii])
             labels.append("sizedata" + 14 * " ")
             draw_options.extend(
                 [
@@ -298,7 +298,7 @@ def get_draw_options(data, obj, ec, fc, ls, lw, hatch=None):
             if ec is None or ec_rgba[3] == 0.0:
                 # Assuming that a hatch marker indicates that hatches are wanted, also
                 # when the edge color is (0, 0, 0, 0), i.e., the edge is invisible
-                h_col, h_rgba = "black", numpy.array([0, 0, 0, 1])
+                h_col, h_rgba = "black", np.array([0, 0, 0, 1])
             else:
                 h_col, h_rgba = ec_col, ec_rgba
         else:

tikzplotlib/_util.py

@@ -1,5 +1,5 @@
 import matplotlib.transforms
-import numpy
+import numpy as np
 
 
 def has_legend(axes):
@@ -33,7 +33,7 @@ def transform_to_data_coordinates(obj, xdata, ydata):
       2. from display to data.
     """
     if obj.axes is not None and obj.get_transform() != obj.axes.transData:
-        points = numpy.array([xdata, ydata]).T
+        points = np.array([xdata, ydata]).T
         transform = matplotlib.transforms.composite_transform_factory(
             obj.get_transform(), obj.axes.transData.inverted()
         )