tikzplot42 0.3.9__tar.gz → 0.4.5__tar.gz

{tikzplot42-0.3.9/src/tikzplot42.egg-info → tikzplot42-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tikzplot42
-Version: 0.3.9
+Version: 0.4.5
 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
@@ -765,6 +765,8 @@ If axes and plot have different name for command with same effect, both are impl
 - `ax.twinx()`,
 - `ax.set()`.
 
+There is a limited support for built-in styles (e.g. `plt.style.use("default")`), you may also define your own style using `plt.style.set_profile()`. Currently supported features are: color cycle (hex colors sequence), line width (in pt), grid (with matplotlib kwargs), background (latex style key=value), additional settings (raw latex code for optional arguments to axis: key=value).
+
 #### Supported common **kwargs
 - `color/c` (all matplotlib formats, except color schemes which are not yet implemented),
 - `linestyle/ls`,
@@ -788,6 +790,6 @@ For plot configurations (default sizes, paddings, etc.), use `from tikzplot impo
 Currently supported parameters are listed with their default values in `src/tikzplot/config.py`.
 
 ## More features coming soon...
-- basic color schemes,
+- more developed styles,
 - improved 3D plots (currently only basic support: plot, errorbar, fill_between, scatter, plot_wireframe, plot_surface),
 - ... 

{tikzplot42-0.3.9 → tikzplot42-0.4.5}/README.md

@@ -63,6 +63,8 @@ If axes and plot have different name for command with same effect, both are impl
 - `ax.twinx()`,
 - `ax.set()`.
 
+There is a limited support for built-in styles (e.g. `plt.style.use("default")`), you may also define your own style using `plt.style.set_profile()`. Currently supported features are: color cycle (hex colors sequence), line width (in pt), grid (with matplotlib kwargs), background (latex style key=value), additional settings (raw latex code for optional arguments to axis: key=value).
+
 #### Supported common **kwargs
 - `color/c` (all matplotlib formats, except color schemes which are not yet implemented),
 - `linestyle/ls`,
@@ -86,6 +88,6 @@ For plot configurations (default sizes, paddings, etc.), use `from tikzplot impo
 Currently supported parameters are listed with their default values in `src/tikzplot/config.py`.
 
 ## More features coming soon...
-- basic color schemes,
+- more developed styles,
 - improved 3D plots (currently only basic support: plot, errorbar, fill_between, scatter, plot_wireframe, plot_surface),
 - ... 

{tikzplot42-0.3.9 → tikzplot42-0.4.5}/pyproject.toml

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

{tikzplot42-0.3.9 → tikzplot42-0.4.5}/src/tikzplot/axes.py

@@ -1,3 +1,6 @@
+from typing import Any
+from xml.dom import XMLNS_NAMESPACE
+
 import numpy as _np
 import matplotlib.pyplot as _plt
 
@@ -7,6 +10,7 @@ from .config import TikzConfig
 from .colorbar import Colorbar
 from .state import _next_imshow_num, main_name
 from .latex_special import tex_text
+from .colors import _tex_color
 
 class BaseAxes:
     def __init__(self):
@@ -21,18 +25,21 @@ class BaseAxes:
         else:
             self._axis_args.add(f"/pgf/number format/.cd, 1000 sep={{{TikzConfig.THOUSANDS_SEP}}}")
 
-        self._add_legend = ""
+        self._add_legend = []
+        self._legend_lab_col: Any = None
         self._coordinates = {}
         self._cmap_bar = None
 
         self._ext_ymin = False
         self._ext_ymax = False
 
-    def _plot(self, x, y, settings=None, xerr=None, yerr=None, **style):
-        if not isinstance(self, Secondary) and self._polar:
+        self._reverse_elements = []
+
+    def _plot(self, x, y, settings={}, xerr=None, yerr=None, **style):
+        if isinstance(self, Axes) and self._polar:
             x = _np.rad2deg(x)
         e = Graph(self, (x, y), settings, xerr=xerr, yerr=yerr, **style)
-        if TikzConfig.USE_GROUPPLOTS and ("axvspan" == settings or "axhspan" == settings):
+        if TikzConfig.USE_GROUPPLOTS and ("axvspan" in settings or "axhspan" in settings):
             self._elements.insert(0, e)
         else:
             self._elements.append(e)
@@ -71,6 +78,7 @@ class BaseAxes:
 
         try:
             c = kwargs.get("c", kwargs.get("color", None))
+            if c is None: raise ValueError("No color specified")
             if len(c) == len(x):
                 if isinstance(c[0], (int, float)):
                     if "cmap" not in kwargs:
@@ -87,7 +95,7 @@ class BaseAxes:
                         self._cmap_bar = kwargs["cmap"]
         except: pass
         
-        return self._plot(x, y, **kwargs, ls="", settings=["scatter"])
+        return self._plot(x, y, **kwargs, ls="", settings={"scatter": None})
                         
     def semilogy(self, x, y, *args, **kwargs):
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label"}
@@ -118,17 +126,16 @@ class BaseAxes:
             x = range(len(y))
         elif len(args) == 2:
             x,y=args
-        elif len(args) == 3:
-            x,y,fmt=args
-            kwargs["fmt"]=fmt
+        else:
+            raise Warning("Invalid number of args for stem.")
         if "orientation" in kwargs:
             o = kwargs.pop("orientation")
             if o == "horizontal":
                 vert = False
         if vert:
-            return self._plot(x,y,settings=["ycomb"], **kwargs)
+            return self._plot(x,y,settings={"ycomb": None}, **kwargs)
         else:
-            return self._plot(y,x,settings=["xcomb"], **kwargs)
+            return self._plot(y,x,settings={"xcomb": None}, **kwargs)
 
     def fill_between(self, x, y1, y2=None, **kwargs):
         kws = {"fmt", "alpha", "color", "c", "label"}
@@ -139,6 +146,7 @@ class BaseAxes:
                     return el._try_set_pname(pname)
                 else:
                     return None
+        assert self._fig is not None
         name1 = self._fig._get_free_path_name()
         name2 = self._fig._get_free_path_name()
         if isinstance(y1, (int, float)):
@@ -165,7 +173,7 @@ class BaseAxes:
                 self._plot(xs,ys,path_name=name2, alpha=0)
             else:
                 name2 = inst
-        e = Graph(self, f"fill between [of={name1} and {name2}]",settings=None, xerr=None, yerr=None, **kwargs)
+        e = Graph(self, f"fill between [of={name1} and {name2}]",settings={}, xerr=None, yerr=None, **kwargs)
         self._elements.append(e)
         return e
         
@@ -214,46 +222,150 @@ class BaseAxes:
                 self._plot([xs[i]]*2, [ymins[i], ymaxs[i]], None, None, None, c=colorss[i], ls=lss[i])
 
     def hist(self, x, bins=10, density=False,**kwargs):
-        #kws = {"alpha", "color", "c", "label"}
-        #kwargs = self._check_kwargs("hist", kws, **kwargs)
-        try:
-            iter(x)
-            iter(x[0])
-            datasets = x
-        except:
-            datasets = [x]
+        kws = {"alpha", "color", "c", "label", "facecolor", "fc", "edgecolor", "ec", "orientation", "rwidth", "cumulative", "range", "histtype", "weights", "cumulative", "align", "stacked", "fill"}
+        kwargs = self._check_kwargs("hist", kws, **kwargs)
+        if isinstance(x, (list, tuple)) and len(x) > 0 and isinstance(x[0], (list, tuple, _np.ndarray)):
+            try:
+                datasets = [_np.asarray(ds, dtype=_np.float64) for ds in x]
+                if any(ds.ndim != 1 for ds in datasets):
+                    raise ValueError("Nested datasets must all be 1-dimensional.")
+            except (ValueError, TypeError):
+                x_arr = _np.asarray(x)
+                if x_arr.ndim == 2:
+                    datasets = [x_arr[:, i] for i in range(x_arr.shape[1])]
+                else:
+                    raise ValueError("Invalid dataset structure.")
+        else:
+            x_arr = _np.asarray(x)
+            if x_arr.ndim == 1:
+                datasets = [x_arr]
+            elif x_arr.ndim == 2:
+                datasets = [x_arr[:, i] for i in range(x_arr.shape[1])]
+            else:
+                raise ValueError(f"Input must be 1D or 2D, got {x_arr.ndim}D.")
+
+        stack = kwargs.pop("stacked", False)
+        datas = {}
+        for kw in ["color", "c", "facecolor", "fc", "edgecolor", "ec", "label"]:
+            if kw in kwargs:
+                if isinstance(kwargs[kw], (list)):
+                    if len(kwargs[kw]) != len(datasets):
+                        raise Warning(f"Length of {kw} does not match number of datasets.")
+                    prop = kwargs.pop(kw)
+                else:
+                    prop = [kwargs.pop(kw)] * len(datasets)
+                for i in range(len(datasets)):
+                    if i not in datas:
+                        datas[i] = {}
+                    datas[i][kw] = prop[i]
         all_data = _np.concatenate(datasets)
-        edges = _np.histogram_bin_edges(all_data, bins=bins)
-        for data in datasets:
-            counts, _ = _np.histogram(data, edges, density=density)
-            centers = (edges[:-1] + edges[1:]) / 2
+        edges = _np.histogram_bin_edges(all_data, bins=bins, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
         widths = edges[1:] - edges[:-1]
-        settings = []
+        offset = 0
+        settings = {}
+        hist_type = kwargs.pop("histtype", "bar")
+        if hist_type not in ["bar", "barstacked", "step", "stepfilled"]:
+            raise Warning(f"Invalid histtype: {hist_type}.")
         if "orientation" in kwargs and kwargs["orientation"] == "horizontal":
-            settings.append("xbar")
+            settings["xbar"] = None
         else:
-            settings.append("ybar")
-        settings.append("fill")
-        if "rwidth" in kwargs:
-            settings.append(f"bar width={widths.mean()*kwargs['rwidth']}")
+            settings["ybar"] = None
+        if ("rwidth" in kwargs or (len(datasets) > 1 and not stack)) and isinstance(bins, int):
+            if stack or len(datasets) == 1:
+                settings["bar width"] = f"{widths.mean()*kwargs['rwidth']}"
+            else:
+                if "rwidth" in kwargs:
+                    settings["bar width"] = f"{widths.mean()*kwargs['rwidth']/(len(datasets)+1)}"
+                    offset = widths.mean() * kwargs['rwidth'] / (len(datasets) + 1)
+                else:
+                    settings["bar width"] = f"{widths.mean()/(len(datasets)+1)}"
+                    offset = widths.mean() / (len(datasets) + 1)
         else:
-            settings[0] += " interval"
+            if "xbar" in settings:
+                settings.pop("xbar")
+                settings["xbar interval"] = None
+            elif "ybar" in settings:
+                settings.pop("ybar")
+                settings["ybar interval"] = None
         if "range" in kwargs:
-            if settings[0] == "xbar":
+            if "xbar" in settings:
                 self.set_ylim(kwargs["range"])
-            else:
+            elif isinstance(self, Axes):
                 self.set_xlim(kwargs["range"])
-        if "cumulative" in kwargs and kwargs["cumulative"]:
-            counts = _np.cumsum(counts)
-
-        return self._plot(centers, counts, settings=settings, **kwargs)
+            elif  isinstance(self, Secondary):
+                self._primary.set_xlim(kwargs["range"])
+        base_settings = settings.copy()
+        outputs = []
+        old_counts = _np.zeros(len(edges), dtype=_np.float64)
+        totals, _ = _np.histogram(all_data, edges, density=False, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
+        tot_sum = totals.sum()
+        for i in range(len(datasets)):
+            data = datasets[i]
+            settings = base_settings.copy()
+            kws = datas.get(i, {})
+            if "label" in kws:
+                if "xbar" in settings or "xbar interval" in settings:
+                    settings["xbar legend"] = None
+                else:
+                    settings["ybar legend"] = None
+            else:
+                settings["forget plot"] = None
+            fill = kws.pop("facecolor", kws.pop("fc", kws.pop("color", kws.pop("c", None))))
+            draw = kws.pop("edgecolor", kws.pop("ec", None))
+            if fill:
+                fill = self._match_color(fill)
+            settings["fill"] = fill
+            if draw and hist_type != "stepfilled":
+                draw = self._match_color(draw)
+                settings["draw"] = draw
+            else:
+                settings["draw"] = "none"
+            counts, _ = _np.histogram(data, edges, density=density, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
+            if "xbar interval" in settings or "ybar interval" in settings: # edges for interval
+                if "rwidth" in kwargs:
+                    xs = [edges[0] + widths[0]*(1-kwargs["rwidth"])/2]
+                    new_counts = []
+                    for j in range(len(widths)):  # Changed 'i' to 'j' to avoid overwriting dataset index 'i'
+                        xs.append(xs[-1] + widths[j]*kwargs["rwidth"])
+                        new_counts.append(counts[j])
+                        if j < len(counts)-1:
+                            xs.append(xs[-1] + (widths[j] + widths[j+1])*(1-kwargs["rwidth"])/2)
+                            new_counts.append(0)
+                    counts = new_counts + [0]
+                else:
+                    xs = edges
+                    counts = _np.concatenate([counts, [0]])
+            else: # centers
+                xs = (edges[:-1] + edges[1:]) / 2
+                if offset > 0:
+                    settings["bar shift"] = f"{offset*(i - len(datasets)/2 + 0.5)}"
+            if "cumulative" in kwargs and kwargs["cumulative"]:
+                counts = _np.cumsum(counts)
+            if stack:
+                if density:
+                    set_counts, _ = _np.histogram(data, edges, density=False, weights=kwargs.get("weights", None), range=kwargs.get("range", None))
+                    counts = counts * _np.sum(set_counts) / tot_sum
+                counts = _np.asarray(counts, dtype=_np.float64)
+                counts += old_counts
+                old_counts = counts.copy()
+            if hist_type == "step":
+                    kwargs.pop("facecolor", None)
+                    kwargs.pop("fc", None)
+                    kwargs.pop("fill", None)
+                    self.step([edges[0]] + list(edges), [0] + list(counts), where="pre", **kws)
+            else:
+                e = self._plot(xs, counts, settings=settings, **kws)
+                outputs.append(e)
+        if outputs and stack:
+            self._reverse_elements.append([id(e) for e in outputs])
+        return outputs
     
     def step(self, x, y, *args, **kwargs):
         kws = {"fmt", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "marker", "markersize", "ms", "label", "where"}
         kwargs = self._check_kwargs("step", kws, **kwargs)
         WHERE_DICT = {"pre": "left", "post": "right", "mid": "mid"}
         where = WHERE_DICT.get(kwargs.pop("where", "pre"), None)
-        settings = [f"const plot mark {where}"]
+        settings = {f"const plot mark {where}": None}
         if len(args) == 1:
             kwargs["fmt"] = args[0]
         return self._plot(x,y,settings=settings, **kwargs)
@@ -262,7 +374,7 @@ class BaseAxes:
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "label"}
         kwargs = self._check_kwargs("axvline", kws, **kwargs)
         self._ext_ymin = self._ext_ymax = True
-        self._plot(x, (ymin, ymax), settings="axvline", **kwargs)
+        self._plot(x, (ymin, ymax), settings={"axvline": None}, **kwargs)
 
     def axhline(self, y, xmin=0, xmax=1, **kwargs):
         kws = {"fmt", "base", "alpha", "color", "c", "linestyle", "ls", "linewidth", "lw", "label"}
@@ -271,7 +383,7 @@ class BaseAxes:
             self._primary._ext_xmin = self._primary._ext_xmax = True
         else:
             self._ext_xmin = self._ext_xmax = True
-        self._plot((xmin, xmax), y, settings="axhline", **kwargs)
+        self._plot((xmin, xmax), y, settings={"axhline": None}, **kwargs)
 
     def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):
         kws = {"c", "color", "alpha", "label"}
@@ -279,7 +391,7 @@ class BaseAxes:
         self._ext_ymin = self._ext_ymax = True
         if TikzConfig.USE_GROUPPLOTS:
             self._axis_args.add("set layers")
-        self._plot([xmin, xmax], [ymin, ymax], settings="axvspan", **kwargs)
+        self._plot([xmin, xmax], [ymin, ymax], settings={"axvspan": None}, **kwargs)
 
     def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):
         kws = {"c", "color", "alpha", "label"}
@@ -290,7 +402,7 @@ class BaseAxes:
             self._ext_xmin = self._ext_xmax = True
         if TikzConfig.USE_GROUPPLOTS:
             self._axis_args.add("set layers")
-        self._plot([xmin, xmax], [ymin, ymax], settings="axhspan", **kwargs)
+        self._plot([xmin, xmax], [ymin, ymax], settings={"axhspan": None}, **kwargs)
 
     def set_ylabel(self, label):
         self._axis_options["ylabel"] = f"{{{tex_text(label)}}}"
@@ -350,7 +462,19 @@ class BaseAxes:
     _LEGEND_LOC_MAP = ["best", "upper right", "upper left", "lower_left", "lower right", "right", "center left", "center right", "lower center", "upper center", "center"]
     _ANCHOR_MAP = {"top": "north", "bottom": "south", "upper": "north", "lower": "south", "left": "west", "right": "east", "center": "center"}
 
+    def _match_color(self, input):
+        if isinstance(self, Axes) or isinstance(self, Secondary):
+            if input == "none":
+                return "none"
+            ccode, op = _tex_color(input, self._style)
+            if isinstance(ccode, str):
+                return ccode
+            r,g,b = ccode
+            self._add_col(r,g,b)
+            return f"c{r:.3f}{g:.3f}{b:.3f}".replace(".", "")
+
     def legend(self, *args, **kwargs):
+        legend_string = {}
         if "loc" in kwargs:
             loc = kwargs["loc"]
             lx = ly = posit = None
@@ -358,7 +482,8 @@ class BaseAxes:
                 try:
                     lx,ly=float(loc[0]), float(loc[1])
                     posit = "south west"
-                except: print(f"Error parsing legend location: {loc}")
+                except: 
+                    print(f"Error parsing legend location: {loc}")
             else:
                 if isinstance(loc, int):
                     loc = self._LEGEND_LOC_MAP[loc]
@@ -376,17 +501,34 @@ class BaseAxes:
                 elif "east" in posit:
                     lx = 1 - TikzConfig.LEGEND_REL_X
 
-            legend_string = []
             if lx is not None and ly is not None:
-                legend_string.append(r"at={(" + f"{lx},{ly}" + r")}")
-            if len(posit):
-                legend_string.append(r"anchor=" + posit)
-            self._axis_options["legend style"] = f"{{{','.join(legend_string)}}}"
+                legend_string["at"] = "{(" + f"{lx},{ly}" + r")}"
+            if posit is not None and len(posit):
+                legend_string["anchor"] = posit
+
+        if "facecolor" in kwargs and (isinstance(self, Axes) or isinstance(self, Secondary)):
+            ccode = self._match_color(kwargs["facecolor"])
+            if ccode is not None:
+                legend_string["fill"] = ccode
+        if "edgecolor" in kwargs and (isinstance(self, Axes) or isinstance(self, Secondary)):
+            ccode = self._match_color(kwargs["edgecolor"])
+            if ccode is not None:
+                legend_string["draw"] = ccode
+        if "labelcolor" in kwargs and (isinstance(self, Axes) or isinstance(self, Secondary)):
+            ccode = self._match_color(kwargs["labelcolor"])
+            if ccode is not None:
+                self._legend_lab_col = ccode
+        if "frameon" in kwargs and not kwargs["frameon"]:
+            legend_string["draw"] = "none"                      
+        if "legend style" in self._axis_options:
+            self._axis_options["legend style"].update(legend_string)
+        else:
+            self._axis_options["legend style"] = legend_string
         self._legend_on = True
         if "ncols" in kwargs:
             self._axis_options["legend columns"] = kwargs["ncols"]
         if len(args) == 2:
-            self._add_legend = args
+            self._add_legend = list(args)
         elif len(args) == 1:
             labs = args[0]
             if len(labs) > len(self._elements):
@@ -395,10 +537,12 @@ class BaseAxes:
                 for i in range(len(labs)):
                     self._elements[i]._set_label(tex_text(labs[i]))
 
-    def text(self, x, y, s, on_top=True, **kwargs):
-        kws = {"alpha", "color", "c", "fontsize", "size", "backgroundcolor", "horizontalalignment", "ha", "verticalalignment", "va", "rotation", "label"}
+    def text(self, x, y, s, **kwargs):
+        kws = {"alpha", "color", "c", "fontsize", "on_top", "size", "backgroundcolor", "horizontalalignment", "ha", "verticalalignment", "va", "rotation", "label"}
         kwargs = self._check_kwargs("text", kws, **kwargs)
+        on_top = kwargs.pop("on_top", True)
         if on_top:
+            assert self._fig is not None
             coord = self._fig._next_coordinate_name()
             txt = Text(self, x, y, coord, s, **kwargs)
             self._fig._add_text(txt)
@@ -409,12 +553,13 @@ class BaseAxes:
     def magnify(self, x_p, y_p, x_m, y_m, zoom, size, **kwargs):
         kws = {"shape", "connect"}
         kwargs = self._check_kwargs("magnify", kws, **kwargs)
+        assert self._fig is not None
         n = self._fig._add_spy(zoom, size, **kwargs)
         self._coordinates.update({f"spypoint{n}": (x_p,y_p)})
         self._coordinates.update({f"spyviewr{n}": (x_m,y_m)})
 
     def _add_legend_entries(self):
-        if self._add_legend == "": return ""
+        if self._add_legend == []: return ""
         axs, labs = self._add_legend
         output = ""
         if len(axs) != len(labs):
@@ -422,16 +567,36 @@ class BaseAxes:
             return ""
         for i in range(len(axs)):
             output += f"\n\\addlegendimage{{{axs[i]._style_string()}}}"
-            output += f"\n\\addlegendentry{{{tex_text(labs[i])}}}"
+            if self._legend_lab_col:
+                output += f"\n\\addlegendentry[{self._legend_lab_col}]{{{tex_text(labs[i])}}}"
+            else:
+                output += f"\n\\addlegendentry{{{tex_text(labs[i])}}}"
         return output
         
     def _content_tex(self, filename):
-        ouptut = "\n".join(e._to_tex(filename) for e in self._elements)
-        ouptut += self._add_legend_entries()
+        element_strings = {id(e): e._to_tex(filename, self._legend_lab_col) for e in self._elements}
+        seq_map = {seq[0]: seq for seq in self._reverse_elements}
+        output_list = []
+        visited = set()
+        for e in self._elements:
+            e_id = id(e)
+            if e_id in visited:
+                continue
+            if e_id in seq_map:
+                seq = seq_map[e_id]
+                for el in reversed(seq):
+                    output_list.append(element_strings[el])
+                    visited.add(el)
+            else:
+                output_list.append(element_strings[e_id])
+                visited.add(e_id)
+
+        output = "\n".join(output_list)
+        output += self._add_legend_entries()
         for coord in self._coordinates:
             x,y = self._coordinates[coord]
-            ouptut += f"\n\\coordinate ({coord}) at ({x},{y});"
-        return ouptut
+            output += f"\n\\coordinate ({coord}) at ({x},{y});"
+        return output
     
     def _get_hard_range(self,which):
         arg = f"{which[0]}mode"
@@ -499,6 +664,7 @@ class BaseAxes:
             e._reduce_points(limit)
 
     def _add_col(self, r,g,b):
+        assert self._fig is not None
         self._fig._add_col(r,g,b)
 
     def set(self, **kwargs):
@@ -507,6 +673,10 @@ class BaseAxes:
             if attr in kwargs:
                 defined[attr](kwargs.pop(attr))
 
+    def _reoreder_last_elements(self, n):
+        if n <= 0: return
+        self._elements = self._elements[:-n] + self._elements[:-n-1:-1]
+
 class Axes(BaseAxes):
 
     def __init__(self, nrows, ncols, index, fig, polar):
@@ -521,6 +691,7 @@ class Axes(BaseAxes):
         self._col = self._index - self._row * self._ncols
 
         self._fig = fig
+        self._style = self._fig._style
         self._imshow = None
 
         self._defcol_counter = 0
@@ -559,6 +730,18 @@ class Axes(BaseAxes):
 
         self._xticks = True
 
+        self._style_defaults()
+
+    def _style_defaults(self):
+        _gs = self._style._get_grid_cycle()
+        if _gs is not None:
+            self.grid(**_gs)
+        _bcgnd = self._style._get_background_cycle()
+        if _bcgnd is not None:
+            self._axis_options["axis background/.style"] = f"{{{_bcgnd}}}"
+        _add_settgs = self._style._get_additional_settings()
+        if _add_settgs is not None:
+            self._axis_options = _add_settgs | self._axis_options
 
     def _update_size(self):
         if self._fig._get_width():
@@ -629,7 +812,7 @@ class Axes(BaseAxes):
         if kwargs:
             accepted_kwargs = {"color", "c", "linestyle", "ls", "linewidth", "lw", "alpha"}
             kwargs = self._check_kwargs("grid", accepted_kwargs, **kwargs)
-            g = Graph(self, None, None, None, None, **kwargs)._style_string()
+            g = Graph(self, None, {}, None, None, **kwargs)._style_string()
             self._axis_options[f"{selector}grid style"] = f"{{{g}}}"
             
     def set_minorticks_num(self, num):
@@ -708,7 +891,7 @@ class Axes(BaseAxes):
         _plt.axis("off")
         _plt.imshow(*args, **kwargs)
         im_name = f"{str(main_name()[1]).removesuffix('.py')}_{TikzConfig.IMSHOW_SAVENAME}{_next_imshow_num()}.pdf"
-        _plt.savefig(im_name,bbox_inches='tight', pad_inches=0)
+        _plt.savefig(im_name, bbox_inches='tight', pad_inches=0)
         return im_name
 
     def _axis_option_string(self):
@@ -729,7 +912,7 @@ class Axes(BaseAxes):
             if "extent" in self._imshow[1]:
                 bounds = self._imshow[1]["extent"]
             xm, xM, ym, yM = bounds
-            self._elements.insert(0, Graph(self, f"graphics [xmin={xm}, xmax={xM}, ymin={ym}, ymax={yM}] {{{im_name}}}",settings=None, xerr=None, yerr=None, onlayer="axis background"))
+            self._elements.insert(0, Graph(self, f"graphics [xmin={xm}, xmax={xM}, ymin={ym}, ymax={yM}] {{{im_name}}}", settings={}, xerr=None, yerr=None, onlayer="axis background"))
         axis_opt_str = ""
         if self._axis_args:
             axis_opt_str += ",\n".join(self._axis_args)
@@ -762,7 +945,13 @@ class Axes(BaseAxes):
                 self._axis_options["ymax"] = self._fig._next_limname("ymax", self._axis_options.get("ymax", yM))
         if self._axis_options:
             if axis_opt_str: axis_opt_str += ",\n"
-            axis_opt_str += ",\n".join(f"{k}={v}" for k, v in self._axis_options.items())
+            for k, v in self._axis_options.items():
+                if isinstance(v, dict):
+                    axis_opt_str += f"{k}={{"
+                    axis_opt_str += ",\n".join(f"{kk}={vv}" for kk, vv in v.items())
+                    axis_opt_str += "},\n"
+                else:
+                    axis_opt_str += f"{k}={v},\n"
         if self._colorbar:
             axis_opt_str += self._colorbar
         elif self._cmap_bar:
@@ -834,6 +1023,15 @@ class Axes(BaseAxes):
                 defined[attr](kwargs.pop(attr))
 
         super().set(**kwargs)
+
+    def set_facecolor(self, color):
+        ccode, _ = _tex_color(color, self._style)
+        if isinstance(ccode, str):
+            self._axis_options["axis background/.style"] = f"{{fill={ccode}}}"
+        else:
+            r,g,b = ccode
+            self._add_col(r,g,b)
+            self._axis_options["axis background/.style"] = f"{{fill=c{r:.3f}{g:.3f}{b:.3f}}}".replace(".", "")
     
 class Secondary(BaseAxes):
     def __init__(self, primary):
@@ -847,6 +1045,13 @@ class Secondary(BaseAxes):
         self._axis_options["y label style"] = r"{at={(" + str(TikzConfig.SEC_YLABEL_LOC[0]) + "," + str(TikzConfig.SEC_YLABEL_LOC[1]) + ")}, rotate=180}"
 
         self._fig = primary._fig
+        self._style = self._fig._style
+        self._style_defaults()
+
+    def _style_defaults(self):
+        _add_settgs = self._style._get_additional_settings()
+        if _add_settgs is not None:
+            self._axis_options = _add_settgs | self._axis_options
 
     def _axis_option_string(self):
         if self._primary._width:
@@ -868,7 +1073,13 @@ class Secondary(BaseAxes):
         self._axis_options["xmax"] = self._primary._axis_options["xmax"]
         if self._axis_options:
             if axis_opt_str: axis_opt_str += ",\n"
-            axis_opt_str += ",\n".join(f"{k}={v}" for k, v in self._axis_options.items())
+            for k, v in self._axis_options.items():
+                if isinstance(v, dict):
+                    axis_opt_str += f"{k}={{"
+                    axis_opt_str += ",\n".join(f"{kk}={vv}" for kk, vv in v.items())
+                    axis_opt_str += "},\n"
+                else:
+                    axis_opt_str += f"{k}={v},\n"
         return axis_opt_str
     
     def _padding(self):