tikzplot42 0.6.3__tar.gz → 0.6.4__tar.gz

{tikzplot42-0.6.3 → tikzplot42-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.6.3
+Version: 0.6.4
 Summary: TikzPlot to make TikZ/PGFPlots plots with matplotlib.pyplot-like syntax.
 Author-email: Zan Ambrozic <zan.ambrozic7@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{tikzplot42-0.6.3 → tikzplot42-0.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tikzplot42"
-version = "0.6.3"
+version = "0.6.4"
 description = "TikzPlot to make TikZ/PGFPlots plots with matplotlib.pyplot-like syntax."
 authors = [
     { name = "Zan Ambrozic", email = "zan.ambrozic7@gmail.com" }

{tikzplot42-0.6.3 → tikzplot42-0.6.4}/src/tikzplot/axes.py

@@ -539,6 +539,7 @@ class BaseAxes:
             else:
                 lines[0].append(list(zip(x_seg, y_seg)))
         ol = None
+        settings["empty line"] = "jump"
         if cmap is not None:
             vmin = 0
             vmax = _np.max(_np.hypot(u, v))
@@ -547,7 +548,6 @@ class BaseAxes:
                 self._get_free_overlay(cb=cb)
             ol = self._get_overlay()
             self._cmap_bar[ol] = cb
-            settings["empty line"] = "jump"
             settings["mesh"] = None
             settings["point meta"] = "explicit"
             st["color"] = True
@@ -592,7 +592,7 @@ class BaseAxes:
                         arrow_u.append(pu / p_norm)
                         arrow_v.append(pv / p_norm)
                         arrow_c.append(p_norm)
-            sc = 1e-5 * max(domain_dx, domain_dy) / _np.max(_np.hypot(u, v))
+            sc = 1e-2 * max(domain_dx, domain_dy)
             if len(arrow_x) > 0:
                 if cmap is not None:
                     self.quiver(_np.array(arrow_x), _np.array(arrow_y), _np.array(arrow_u), _np.array(arrow_v), _np.array(arrow_c), scale=sc, pivot="middle", lw=arrowsize/2, cmap=cmap, vmin=0, vmax=_np.max(_np.hypot(u, v)))
@@ -1332,7 +1332,7 @@ class BaseAxes:
         overlay = self._get_free_overlay()
         self._overlay_special[overlay] = {"stack plots": "y", "area style": None}
         if base_set != "zero":
-            self._plot(x, baseline, overlay=overlay, alpha=0)
+            self._plot(x, baseline, overlay=overlay, alpha=0, settings={"stackplot": {}})
         datas = {}
         for kw in ["labels", "colors", "alpha", "facecolor", "fc", "edgecolor", "ec", "linewidth", "lw", "linestyle", "ls", "hatch", "hatch_color", "hatch_linewidth", "hatch_distance"]:
             if kw in kwargs:
@@ -1352,7 +1352,7 @@ class BaseAxes:
         for i in range(len(y)):
             kws = {kw: datas[kw][i] for kw in datas}
             kws["_endnotes"] = r"\closedcycle"
-            output.append(self._plot(x, y[i], overlay=overlay, settings={"fill": None}, **kws))
+            output.append(self._plot(x, y[i], overlay=overlay, settings={"fill": None, "stackplot": {}}, **kws))
         return output
 
     def step(self, x, y, *args, **kwargs):
@@ -1811,7 +1811,7 @@ class BaseAxes:
         if "fontsize" in kwargs:
             st["font"] = self._tex_fontsize(kwargs["fontsize"])
         if st:
-            self._update_axis_options("y tick style", st)
+            self._update_axis_options("y tick label style", st)
         passing = {k: kwargs[k] for k in pass_to_labels if k in kwargs}
         if passing:
             self.set_yticklabels(**passing)
@@ -1870,7 +1870,7 @@ class BaseAxes:
             elif ha != "center":
                 raise Warning(f"Invalid horizontalalignment: {ha}. Must be one of 'left', 'right', or 'center'.")
         if st:
-            self._update_axis_options("y tick style", st)
+            self._update_axis_options("y tick label style", st)
         if list(labels) != []:
             if len(labels) == 1 and isinstance(labels[0], (list, tuple)):
                 if len(labels[0]) > 0:
@@ -2550,7 +2550,7 @@ class BaseAxes:
         kws = {"alpha", "color", "c", "fontsize", "on_top", "size", "backgroundcolor", "horizontalalignment", "ha", "verticalalignment", "va", "rotation", "label"}
         kwargs = self._check_kwargs("text", kws, **kwargs)
         if "fontsize" in kwargs or "size" in kwargs:
-            kwargs["fontsize"] = kwargs.pop("size", kwargs.pop("fontsize"))
+            kwargs["fontsize"] = self._tex_fontsize(kwargs.pop("size", kwargs.pop("fontsize")))
         on_top = kwargs.pop("on_top", True)
         if on_top:
             assert self._fig is not None
@@ -2711,14 +2711,6 @@ class BaseAxes:
         for e in self._get_all_elements():
             e._filter(which, value)
 
-    def _num_points(self):
-        return [e._num_points() for e in self._get_all_elements()]
-    
-    def _reduce_points(self, limit):
-        for e in self._get_all_elements():
-            if e._num_points() > 0:
-                e._reduce_points(limit)
-
     def _add_col(self, r,g,b):
         assert self._fig is not None
         self._fig._add_col(r,g,b)
@@ -3103,10 +3095,15 @@ class Axes(BaseAxes):
             self._elements[0].insert(0, Graph(self, f"graphics [xmin={xm}, xmax={xM}, ymin={ym}, ymax={yM}] {{{im_name}}}", settings={}, xerr=None, yerr=None, onlayer="axis background"))
         if self._hidable and self._get_all_elements() == [] and self._secondary_y is None:
             self._axis_options["hide axis"] = None
-        axis_opt_str = ""
-        auxiliary_opt_str = ""
+        axis_opt_str: dict[int, str] = {0: "", 1: "", 2: "", 3: ""} # 0 - lower, 1 - any, 2 - top, 3 - single
+        def _add_to_ax_opt(which: int|Iterable[int], entry:str):
+            if isinstance(which, int):
+                axis_opt_str[which] += entry
+            else:
+                for i in which:
+                    axis_opt_str[i] += entry
         if TikzConfig.SCHOOL_AXIS:
-            axis_opt_str += f",\n axis lines=middle,\n xlabel style={{at={{(ticklabel* cs:{1+TikzConfig.SCHOOL_AXIS_LABEL_MARGIN})}},anchor=north}},\n ylabel style={{at={{(ticklabel* cs:{1+TikzConfig.SCHOOL_AXIS_LABEL_MARGIN})}},anchor=east}}"
+            axis_opt_str[1] += f",\n axis lines=middle,\n xlabel style={{at={{(ticklabel* cs:{1+TikzConfig.SCHOOL_AXIS_LABEL_MARGIN})}},anchor=north}},\n ylabel style={{at={{(ticklabel* cs:{1+TikzConfig.SCHOOL_AXIS_LABEL_MARGIN})}},anchor=east}}"
             if ("xmin" in self._axis_options and self._axis_options["xmin"] == 0) or ("xmax" in self._axis_options and self._axis_options["xmax"] == 0):
                 self._axis_options["extra x ticks"] = r"{0}"
             if ("ymin" in self._axis_options and self._axis_options["ymin"] == 0) or ("ymax" in self._axis_options and self._axis_options["ymax"] == 0):
@@ -3115,16 +3112,16 @@ class Axes(BaseAxes):
             if "set layers" in self._axis_args:
                 self._axis_args.remove("set layers")
             if TikzConfig.SCHOOL_AXIS:
-                axis_opt_str += f",\n set layers,\n axis line style={{on layer=axis foreground}}"
-                auxiliary_opt_str += ",\n set layers"
+                axis_opt_str[2] += f",\n set layers,\n axis line style={{on layer=axis foreground}}"
+                _add_to_ax_opt((0,1), ",\n set layers")
             else:
                 if self._get_all_elements() != []:
-                    axis_opt_str += f",\nset layers=standard, cell picture=true, grid style={{on layer=axis grid}}"
-                    auxiliary_opt_str += "set layers=standard"
+                    axis_opt_str[2] += f",\nset layers=standard, cell picture=true, grid style={{on layer=axis grid}}"
+                    _add_to_ax_opt((0,1), "set layers=standard")
         if self._axis_args and not (self._hidable and self._get_all_elements() == [] and self._secondary_y is None):
-            axis_opt_str = ",\n".join(self._axis_args) + axis_opt_str
+            axis_opt_str[2] = ",\n".join(self._axis_args) + axis_opt_str[2]
             if "set layers" in self._axis_args:
-                auxiliary_opt_str += ",\n set layers"
+                _add_to_ax_opt((0,1), ",\n set layers")
         if self._ext_xmin or self._ext_xmax:
             lower = self._get_range("xmin")
             upper = self._get_range("xmax")
@@ -3156,16 +3153,24 @@ class Axes(BaseAxes):
             if self._int_ymax is not None and (upper[0] is None or upper[0] <= self._int_ymax):
                 self._axis_options["ymax"] = self._int_ymax
         if self._axis_options:
-            if axis_opt_str: axis_opt_str += ",\n"
-            if auxiliary_opt_str: auxiliary_opt_str += ",\n"
+            axis_opt_str[3] = axis_opt_str[2]
+            for k in axis_opt_str:
+                if axis_opt_str[k] and not axis_opt_str[k].endswith(",\n"):
+                    axis_opt_str[k] += ",\n"
             for k, v in self._axis_options.items():
                 if v != {}:
                     entry = self._parse_entry(k,v)
-                    axis_opt_str += entry + ",\n"
+                    axis_opt_str[3] += entry + ",\n"
+                    to_back = ["grid"]
+                    if any(q in k for q in to_back):
+                        axis_opt_str[0] += entry + ",\n"
+                    else:
+                        axis_opt_str[2] += entry + ",\n"
                     if k in ["xmin", "xmax", "ymin", "ymax", "xmode", "ymode", "log basis x", "log basis y", "width", "height", "at"]:
-                        auxiliary_opt_str += entry + ",\n"
-        axis_opt_str = axis_opt_str.removesuffix(",,\n")
-        auxiliary_opt_str = auxiliary_opt_str.removesuffix(",,\n")
+                        _add_to_ax_opt((0,1), entry + ",\n")
+        axis_opt_str[0] += "axis line style={draw=none},\n tick style={draw=none},\n minor tick style={draw=none},\n xticklabels={},\n yticklabels={},\n"
+        for k in axis_opt_str:
+            axis_opt_str[k] = axis_opt_str[k].removesuffix(",,\n").strip("\n")
         adds = {}
         for c in self._elements.keys():
             adds[c] = ""
@@ -3175,7 +3180,8 @@ class Axes(BaseAxes):
                 cm = self._cmap_bar[c]
                 assert isinstance(cm, Colorbar)
                 adds[c] += f"colormap={cm._generate_tex_colormap(cm._cmap)},\n"
-        return axis_opt_str, "hide axis,\n" + auxiliary_opt_str, alias, adds
+        axis_opt_str[1] = "hide axis,\n" + axis_opt_str[1]
+        return axis_opt_str, alias, adds
 
     def _parse_entry(self, k, v):
         if v is None:
@@ -3200,12 +3206,16 @@ class Axes(BaseAxes):
         self._virtual = True
         from .border_finder import _get_sizes
         self._ext_xmin = self._ext_xmax = self._ext_ymin = self._ext_ymax = True
-        main, aux, alias, adds = self._axis_option_string()
-        if 0 in adds:
+        main, alias, adds = self._axis_option_string()
+        aux = main[1]
+        main = main[2]
+        if not self._fig._tight_params.get("ignore_colorbars", False) and 0 in adds:
             main += adds[0]
         main = r"""\begin{axis}[""" + main + r"]" + r"\end{axis}" + "\n"
         if self._secondary_y is not None:
-            main2, aux2 = self._secondary_y._axis_option_string()
+            main2 = self._secondary_y._axis_option_string()
+            aux2 = main2[1]
+            main2 = main2[2]
             main2 = r"""\begin{axis}[""" + main2 + r"]" + r"\end{axis}" + "\n"
             main += main2
         for k in adds:
@@ -3283,12 +3293,18 @@ class Axes(BaseAxes):
             self._fig._add_required_package("\\usepgfplotslibrary{polar}")
         elif self._projection == "smith":
             self._fig._add_required_package("\\usepgfplotslibrary{smithchart}")
-        main_ax, aux_ax, alias, adds = self._axis_option_string()
+        ax_opt, alias, adds = self._axis_option_string()
+        aux_ax = ax_opt[1]
+        if len (self._elements) <= 1:
+            main_ax = ax_opt[3]
+        else:
+            main_ax = ax_opt[2]
         contents = self._content_tex(filename)
         if self._extend is not None:
             lines.append(f"\\nextgroupplot[alias={alias}, width={self._extend[0]}cm, height={self._extend[1]}cm, hide axis]")
             for i in self._elements.keys():
-                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(i, {}).items()]) + ",\n" if i in self._overlay_special else ""
+                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(i, {}).items()]) + "," if i in self._overlay_special else ""
+                spec = spec.strip("\n")
                 if self._projection == "polar":
                     lines2.append("\\begin{polaraxis}["+ f"\n at={{({alias}.south west)}},")
                 elif self._projection == "smith":
@@ -3298,9 +3314,18 @@ class Axes(BaseAxes):
                 if TikzConfig.SCALE_ONLY_AXIS:
                     lines2.append("scale only axis,")
                 if i == self._get_overlay():
-                    lines2.append(f"{main_ax}{spec}\n]")
+                    if i in adds and adds[i] != "":
+                        addit = adds[i]
+                        addit = addit.replace(f"at={{({alias}", f"at={{({alias}a")
+                        addit = f"alias={alias}a,\n" + addit
+                        lines2.append(f"{main_ax}{spec+addit}\n]")
+                    else:
+                        lines2.append(f"{main_ax}{spec}\n]")
                 else:
-                    lines2.append(f"{aux_ax}{spec}\n]")
+                    if i == 0:
+                        lines2.append(f"{ax_opt[0]}{spec}\n]")
+                    else:
+                        lines2.append(f"{aux_ax}{spec}\n]")
                 lines2.append(contents[i])
                 if i == self._get_overlay() and self._overlay_legend:
                     lines2 += self._overlay_legend_entries
@@ -3314,19 +3339,28 @@ class Axes(BaseAxes):
                 else:
                     lines2.append("\\end{axis}")
                     if self._secondary_y is not None:
-                        main_ax2, aux_ax2 = self._secondary_y._axis_option_string()
+                        ax_opt2 = self._secondary_y._axis_option_string()
+                        aux_ax2 = ax_opt2[1]
+                        if len (self._secondary_y._elements) <= 1:
+                            main_ax2 = ax_opt2[3]
+                        else:
+                            main_ax2 = ax_opt2[2]
                         contents2 = self._secondary_y._content_tex(filename)
                         for i in self._secondary_y._elements.keys():
                             lines2.append("\\begin{axis}[")
                             if TikzConfig.SCALE_ONLY_AXIS:
                                 lines2.append("scale only axis,")
-                            spec = ",\n".join([self._parse_entry(k, v) for k, v in self._secondary_y._overlay_special.get(i, {}).items()]) + ",\n" if i in self._secondary_y._overlay_special else ""
+                            spec = ",\n".join([self._parse_entry(k, v) for k, v in self._secondary_y._overlay_special.get(i, {}).items()]) + "," if i in self._secondary_y._overlay_special else ""
                             if i in adds:
                                 spec += adds[i]
+                            spec = spec.strip("\n")
                             if i == sorted(self._secondary_y._elements.keys())[-1]:
                                 lines2.append(f"{main_ax2}{spec}\n]")
                             else:
-                                lines2.append(f"{aux_ax2}{spec}\n]")
+                                if i == 0:
+                                    lines2.append(f"{ax_opt2[0]}{spec}\n]")
+                                else:
+                                    lines2.append(f"{aux_ax2}{spec}\n]")
                             lines2.append(contents2[i])
                             if i == sorted(self._secondary_y._elements.keys())[-1]:
                                 lines2 += self._secondary_y._overlay_legend_entries
@@ -3337,9 +3371,10 @@ class Axes(BaseAxes):
         elif self._projection in ["polar", "smith"] and TikzConfig.USE_GROUPPLOTS and not single:
             lines.append(f"\\nextgroupplot[alias={alias}, width={self._width}, height={self._height}, hide axis]")
             for i in self._elements.keys():
-                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(i, {}).items()]) + ",\n" if i in self._overlay_special else ""
+                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(i, {}).items()]) + "," if i in self._overlay_special else ""
                 if i in adds:
                     spec += adds[i]
+                spec = spec.strip("\n")
                 if self._projection == "polar":
                     lines2.append("\\begin{polaraxis}["+ f"\n at={{({alias}.south west)}},")
                 elif self._projection == "smith":
@@ -3371,28 +3406,31 @@ class Axes(BaseAxes):
                 if TikzConfig.SCALE_ONLY_AXIS:
                     lines.append("scale only axis,")
             if self._get_overlay() == 0:
-                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(0, {}).items()]) + ",\n" if 0 in self._overlay_special else ""
+                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(0, {}).items()]) + "," if 0 in self._overlay_special else ""
                 if 0 in adds:
                     spec += adds[0]
+                spec = spec.strip("\n")
                 if self._secondary_y is not None or any([c is not None for c in self._colorbar.values()]) or self._externs:
                     lines.append(f"{main_ax}{spec}alias={alias}\n]")
                 else:
                     lines.append(f"{main_ax}{spec}\n]")
                 lines.append(contents[0])
             else:
-                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(0, {}).items()]) + ",\n" if 0 in self._overlay_special else ""
+                spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(0, {}).items()]) + "," if 0 in self._overlay_special else ""
                 if 0 in adds:
                     spec += adds[0]
+                spec = spec.strip("\n")
                 if len(contents[0]) == 0:
-                    lines.append(f"{aux_ax}{spec}alias={alias}\n]".replace("set layers=standard,\n", ""))
+                    lines.append(f"{ax_opt[0]}{spec}alias={alias}\n]".replace("set layers=standard,\n", ""))
                 else:
-                    lines.append(f"{aux_ax}{spec}alias={alias}\n]")
+                    lines.append(f"{ax_opt[0]}{spec}alias={alias}\n]")
                 lines.append(contents[0])
                 for i in self._elements.keys():
                     if i == 0: continue
-                    spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(i, {}).items()]) + ",\n" if i in self._overlay_special else ""
+                    spec = ",\n".join([self._parse_entry(k, v) for k, v in self._overlay_special.get(i, {}).items()]) + "," if i in self._overlay_special else ""
                     if i in adds:
                         spec += adds[i]
+                    spec = spec.strip("\n")
                     lines2.append("\\begin{axis}[")
                     if TikzConfig.SCALE_ONLY_AXIS:
                         lines2.append("scale only axis,")
@@ -3420,17 +3458,26 @@ class Axes(BaseAxes):
             elif not TikzConfig.USE_GROUPPLOTS or (TikzConfig.USE_GROUPPLOTS and single):            
                 lines.append("\\end{axis}")
             if self._secondary_y is not None:
-                main_ax2, aux_ax2 = self._secondary_y._axis_option_string()
+                ax_opt2 = self._secondary_y._axis_option_string()
+                aux_ax2 = ax_opt2[1]
+                if len (self._secondary_y._elements) <= 1:
+                    main_ax2 = ax_opt2[3]
+                else:
+                    main_ax2 = ax_opt2[2]
                 contents2 = self._secondary_y._content_tex(filename)
                 for i in self._secondary_y._elements.keys():
                     lines2.append("\\begin{axis}[")
                     if TikzConfig.SCALE_ONLY_AXIS:
                         lines2.append("scale only axis,")
-                    spec = ",\n".join([self._parse_entry(k, v) for k, v in self._secondary_y._overlay_special.get(i, {}).items()]) + ",\n" if i in self._secondary_y._overlay_special else ""
+                    spec = ",\n".join([self._parse_entry(k, v) for k, v in self._secondary_y._overlay_special.get(i, {}).items()]) + "," if i in self._secondary_y._overlay_special else ""
+                    spec = spec.strip("\n")
                     if i == sorted(self._secondary_y._elements.keys())[-1]:
                         lines2.append(f"{main_ax2}{spec}\n]")
                     else:
-                        lines2.append(f"{aux_ax2}{spec}\n]")
+                        if i == 0:
+                            lines2.append(f"{ax_opt2[0]}{spec}\n]")
+                        else:
+                            lines2.append(f"{aux_ax2}{spec}\n]")
                     lines2.append(contents2[i])
                     if i == sorted(self._secondary_y._elements.keys())[-1]:
                         lines2 += self._secondary_y._overlay_legend_entries
@@ -3463,6 +3510,18 @@ class Axes(BaseAxes):
         if position not in ["above", "below", "left", "right"]:
             raise ValueError(f"Invalid position: {position}. Must be one of 'above', 'below', 'left', or 'right'.")
         return self._fig._inset(self, position, relsize=relsize, sharex=sharex, sharey=sharey)
+
+    def _num_points(self):
+        if self._secondary_y is not None:
+            return [e._num_points() for e in self._get_all_elements()] + self._secondary_y._num_points()
+        return [e._num_points() for e in self._get_all_elements()]
+    
+    def _reduce_points(self, limit):
+        for e in self._get_all_elements():
+            if e._num_points() > 0:
+                e._reduce_points(limit)
+        if self._secondary_y is not None:
+            self._secondary_y._reduce_points(limit)
         
 class Secondary(BaseAxes):
     def __init__(self, primary):
@@ -3489,11 +3548,10 @@ class Secondary(BaseAxes):
             self._axis_options["width"] = self._primary._width
         if self._primary._height:
             self._axis_options["height"] = self._primary._height
-        axis_opt_str = ""
-        auxiliary_opt_str = ""
+        axis_opt_str: dict[int, str] = {0: "", 1: "", 2: "", 3: ""} # 0 - lower, 1 - any, 2 - top, 3 - single
         if self._axis_args:
-            axis_opt_str += ",\n".join(self._axis_args)
-            auxiliary_opt_str += ",\n".join(self._axis_args)
+            for i in [1,2,3]:
+                axis_opt_str[i] += ",\n".join(self._axis_args)
         if self._ext_ymin or self._ext_ymax:
             lower = self._get_range("ymin")
             upper = self._get_range("ymax")
@@ -3504,9 +3562,15 @@ class Secondary(BaseAxes):
                 self._axis_options["ymax"] = self._fig._next_limname("ymax", self._axis_options.get("ymax", yM))
         self._axis_options["xmin"] = self._primary._axis_options["xmin"]
         self._axis_options["xmax"] = self._primary._axis_options["xmax"]
+        if "xmode" in self._primary._axis_options:
+            self._axis_options["xmode"] = self._primary._axis_options["xmode"]
+            if "log basis x" in self._primary._axis_options:
+                self._axis_options["log basis x"] = self._primary._axis_options["log basis x"]
         if self._axis_options:
-            if axis_opt_str: axis_opt_str += ",\n"
-            if auxiliary_opt_str: auxiliary_opt_str += ",\n"
+            axis_opt_str[3] = axis_opt_str[2]
+            for k in axis_opt_str:
+                if axis_opt_str[k] and not axis_opt_str[k].endswith(",\n"):
+                    axis_opt_str[k] += ",\n"
             def parse_entry(k,v):
                 if isinstance(v, dict):
                     return f"{k}={{" + ",\n".join(f"{kk}={vv}" for kk, vv in v.items()) + "}"
@@ -3514,10 +3578,20 @@ class Secondary(BaseAxes):
                     return f"{k}={v}"
             for k, v in self._axis_options.items():
                 entry = parse_entry(k,v)
-                axis_opt_str += entry + ",\n"
+                axis_opt_str[3] += entry + ",\n"
+                to_back = ["grid"]
+                if any(q in k for q in to_back):
+                    axis_opt_str[0] += entry + ",\n"
+                else:
+                    axis_opt_str[2] += entry + ",\n"
                 if k in ["xmin", "xmax", "ymin", "ymax", "xmode", "ymode", "log basis x", "log basis y", "width", "height", "at", "axis y line*", "axis x line", "anchor"]:
-                    auxiliary_opt_str += entry + ",\n"
-        return axis_opt_str, "hide axis,\n" + auxiliary_opt_str
+                    axis_opt_str[0] += entry + ",\n"
+                    axis_opt_str[1] += entry + ",\n"
+        axis_opt_str[0] += "axis line style={draw=none},\n tick style={draw=none},\n minor tick style={draw=none},\n xticklabels={},\n yticklabels={},\n"
+        for k in axis_opt_str:
+            axis_opt_str[k] = axis_opt_str[k].removesuffix(",,\n").strip("\n")
+        axis_opt_str[1] = "hide axis,\n" + axis_opt_str[1]
+        return axis_opt_str
     
     def _padding(self):
         return TikzConfig.SEC_Y_PADDING + TikzConfig.YTICK_PADDING * self._yticks + TikzConfig.SEC_Y_LABEL_PADDING * ("ylabel" in self._axis_options)
@@ -3526,4 +3600,12 @@ class Secondary(BaseAxes):
         return self._primary._get_defcol(index)
     
     def _get_index(self):
-        return self._primary._get_index()
+        return self._primary._get_index()
+
+    def _num_points(self):
+        return [e._num_points() for e in self._get_all_elements()]
+    
+    def _reduce_points(self, limit):
+        for e in self._get_all_elements():
+            if e._num_points() > 0:
+                e._reduce_points(limit)