tikzplot42 0.6.2__tar.gz → 0.6.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.6.2
+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
@@ -764,6 +764,7 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `imshow()`,
 - `matshow()`,
 - `text()`,
+- `annotate()`,
 - `bxp()` (without notches),
 - `boxplot()` (without notches),
 - `violin()`,

{tikzplot42-0.6.2 → tikzplot42-0.6.4}/README.md

@@ -64,6 +64,7 @@ Some basic plot commands are already implemented with commonly used arguments:
 - `imshow()`,
 - `matshow()`,
 - `text()`,
+- `annotate()`,
 - `bxp()` (without notches),
 - `boxplot()` (without notches),
 - `violin()`,

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tikzplot42"
-version = "0.6.2"
+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.4/src/tikzplot/arrows.py

@@ -0,0 +1,87 @@
+from .colors import _tex_color
+
+class Arrow:
+    _LINE_MAP = {"--": "dashed", ":": "dotted", "-.": "dashdotted", "-":"solid"}
+    def __init__(self, ax, x1, y1, x2, y2, coordinate1, coordinate2, **kwargs):
+        self._axes = ax
+        self._x1 = x1
+        self._y1 = y1
+        self._x2 = x2
+        self._y2 = y2
+        self._coordinate1 = coordinate1
+        self._coordinate2 = coordinate2
+        self._kwargs = kwargs
+        self._opacity = 1
+        self._visible = True
+
+    def match_color(self, input):
+        self._has_color = True
+        ccode, op = _tex_color(input)
+        if not isinstance(op, bool):
+            self._opacity = op
+        if isinstance(ccode, str):
+            return ccode
+        r,g,b=ccode
+        self._axes._add_col(r,g,b)
+        return f"c{r:.3f}{g:.3f}{b:.3f}".replace(".", "")
+
+    def _style_string(self):
+        output = []
+        if "arrowstyle" in self._kwargs:
+            allowed = {"<", ">", "|", "stealth", "latex"}
+            arstyle = self._kwargs["arrowstyle"]
+            arstyle = arstyle.split("-")
+            if not all(s in allowed for s in arstyle):
+                raise ValueError(f"Arrow style {self._kwargs['arrowstyle']} not recognized. Valid options should consist of: {allowed}, separated by -.")
+            output.append(self._kwargs["arrowstyle"])
+        if "color" in self._kwargs or "c" in self._kwargs:
+            self._color = self.match_color(self._kwargs.get("color") or self._kwargs.get("c"))
+        if "alpha" in self._kwargs:
+            self._opacity = self._kwargs["alpha"]
+        if "line width" in self._kwargs or "lw" in self._kwargs:
+            output.append("line width=" + str(self._kwargs.get("line width") or self._kwargs.get("lw")))
+        if "linestyle" in self._kwargs or "ls" in self._kwargs:
+            ls = self._kwargs.get("linestyle") or self._kwargs.get("ls")
+            if ls in self._LINE_MAP:
+                ls = self._LINE_MAP[ls]
+            elif ls not in self._LINE_MAP.values():
+                raise ValueError(f"Line style {ls} not recognized. Valid options are: {list(self._LINE_MAP.keys())}.")
+            output.append("line style=" + str(ls))
+        if self._opacity < 1:
+            output.insert(0,f"opacity={self._opacity}")
+        if self._color:
+            output.insert(0,f"color={self._color}")
+        return ", ".join(output)
+
+    def _to_tex(self, *args, **kwargs):
+        if self._visible:
+            if self._coordinate1 is not None:
+                return f"\\coordinate {self._coordinate1} at (axis cs:{self._x1},{self._y1});"
+        else:
+            return ""
+        
+    def _to_tex_fin(self):
+        if self._visible:
+            if self._coordinate1 is not None and self._coordinate2 is not None:
+                return f"\\draw[{self._style_string()}] {self._coordinate2} -- {self._coordinate1};"
+        else:
+            return ""
+
+    def _filter(self, which, label):
+        pass
+
+    def _get_erange(self, which):
+        if which == "xmin":
+            return min(self._x1, self._x2)
+        elif which == "xmax":
+            return max(self._x1, self._x2)
+        elif which == "ymin":
+            return min(self._y1, self._y2)
+        elif which == "ymax":
+            return max(self._y1, self._y2)
+
+    def _num_points(self):
+        return 2
+    
+    def _reduce_points(self, max_points):
+        pass

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

@@ -9,6 +9,7 @@ from skimage import measure
 
 from .elements import Graph, Single
 from .texts import Text
+from .arrows import Arrow
 from .config import TikzConfig
 from .colorbar import Colorbar
 from .state import _next_imshow_num, main_name
@@ -538,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))
@@ -546,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
@@ -591,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)))
@@ -1331,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:
@@ -1351,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):
@@ -1810,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)
@@ -1869,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:
@@ -2549,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
@@ -2560,6 +2561,32 @@ class BaseAxes:
             txt = Text(self, x, y, None, s, **kwargs)
         self._elements[self._get_overlay()].append(txt)
 
+    def annotate(self, text, xy, xytext=None, arrowprops=None, **kwargs):
+        kws = {"alpha", "color", "c", "fontsize", "size", "backgroundcolor", "horizontalalignment", "ha", "verticalalignment", "va", "rotation", "label"}
+        kwargs = self._check_kwargs("annotate", kws, **kwargs)
+        akws = {"arrowstyle", "alpha", "color", "c", "linewidth", "lw", "linestyle", "ls"}
+        passing_kwargs = {"alpha", "color", "c"}
+        ap0 = {k: kwargs[k] for k in passing_kwargs if k in kwargs}
+        if arrowprops is not None:
+            arrowprops = self._check_kwargs("annotate: arrowprops", akws, **arrowprops)
+        else:
+            arrowprops = {}
+        arrowprops = ap0 | arrowprops
+        assert self._fig is not None
+        xa, ya = xy
+        if xytext is not None:
+            xt, yt = xytext
+        else:
+            return self.text(xa, ya, text, **kwargs)
+        ca = self._fig._next_coordinate_name()
+        ct = self._fig._next_coordinate_name()
+        txt = Text(self, xt, yt, ct, text, **kwargs)
+        self._fig._add_text(txt)
+        arr = Arrow(self, xa, ya, xt, yt, ca, ct, **arrowprops)
+        self._fig._add_arrow(arr)
+        self._elements[self._get_overlay()].append(txt)
+        self._elements[self._get_overlay()].append(arr)
+
     def magnify(self, x_p, y_p, x_m, y_m, zoom, size, **kwargs):
         kws = {"shape", "connect"}
         kwargs = self._check_kwargs("magnify", kws, **kwargs)
@@ -2568,6 +2595,9 @@ class BaseAxes:
         self._coordinates.update({f"spypoint{n}": (x_p,y_p)})
         self._coordinates.update({f"spyviewr{n}": (x_m,y_m)})
 
+    def set_axis_off(self):
+        self._axis_options["hide axis"] = None
+
     def _add_legend_entries(self):
         if self._add_legend == []: return ""
         axs, labs = self._add_legend
@@ -2681,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)
@@ -3073,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):
@@ -3085,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")
@@ -3126,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] = ""
@@ -3145,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:
@@ -3170,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:
@@ -3253,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":
@@ -3268,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
@@ -3284,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
@@ -3307,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":
@@ -3341,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,")
@@ -3390,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
@@ -3433,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):
@@ -3459,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")
@@ -3474,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()) + "}"
@@ -3484,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)
@@ -3496,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)