From f5f7b832de4fe617de721c8b2729aadb0a97451a Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 25 Jan 2026 19:25:17 +0100 Subject: [PATCH 01/16] Cleanup, removed unused args --- src/maxplotlib/canvas/canvas.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index 8fbc51f..a04a252 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -225,7 +225,6 @@ def savefig( layers: list | None = None, layer_by_layer: bool = False, verbose: bool = False, - plot: bool = True, ): filename_no_extension, extension = os.path.splitext(filename) if backend == "matplotlib": @@ -254,7 +253,6 @@ def savefig( else: fig, axs = self.plot( - show=False, backend="matplotlib", savefig=True, layers=layers, @@ -263,7 +261,12 @@ def savefig( if verbose: print(f"Saved {full_filepath}") - def plot(self, backend: Backends = "matplotlib", savefig=False, layers=None): + def plot( + self, + backend: Backends = "matplotlib", + savefig=False, + layers=None, + ): if backend == "matplotlib": return self.plot_matplotlib(savefig=savefig, layers=layers) elif backend == "plotly": From f380df3312c36ae7a8fcef04af031cad4208c24e Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 25 Jan 2026 20:18:17 +0100 Subject: [PATCH 02/16] Added tikzpics as dependency --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 2e61bbd..902de0f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -18,6 +18,7 @@ dependencies = [ "matplotlib", "pint", "plotly", + "tikzpics", ] [project.optional-dependencies] test = [ From 65faf236b18842d0e0f4198dcacbdb9264385a61 Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 25 Jan 2026 20:19:02 +0100 Subject: [PATCH 03/16] Removed src/maxplotlib/backends/matplotlib/utils_old.py --- .../backends/matplotlib/utils_old.py | 852 ------------------ 1 file changed, 852 deletions(-) delete mode 100644 src/maxplotlib/backends/matplotlib/utils_old.py diff --git a/src/maxplotlib/backends/matplotlib/utils_old.py b/src/maxplotlib/backends/matplotlib/utils_old.py deleted file mode 100644 index 2516ab6..0000000 --- a/src/maxplotlib/backends/matplotlib/utils_old.py +++ /dev/null @@ -1,852 +0,0 @@ -# import sys; from os.path import dirname; sys.path.append(f'{dirname(__file__)}/../../') - -# import matplotlib.pylab as pylab -import math -import pickle -from pathlib import Path - -import _pickle as cPickle -import matplotlib.colors as mcolors -import matplotlib.pyplot as plt -import numpy as np -from matplotlib.collections import PatchCollection -from mpl_toolkits.mplot3d import Axes3D -from mpl_toolkits.mplot3d.art3d import Line3DCollection, Poly3DCollection - - -class Color: - def __init__(self, hex_color): - self.hx = hex_color - self.rgb = tuple(int(hex_color.lstrip("#")[i : i + 2], 16) for i in (0, 2, 4)) - - self.rgb_dec = [i / 255 for i in self.rgb] - self.rgb_dec_str = ["{:.6f}".format(i) for i in self.rgb_dec] - - self.rgb_inv = tuple(np.subtract((256, 256, 256), self.rgb)) - self.rgb_dec_inv = [1.0 - c for c in self.rgb_dec] - # self.pgf_col_str = '\definecolor{currentstroke}{rgb}{' - self.pgf_col_str = "{rgb}{" - self.pgf_col_str += self.rgb_dec_str[0] + "," - self.pgf_col_str += self.rgb_dec_str[1] + "," - self.pgf_col_str += self.rgb_dec_str[2] + "}%" - - def invert(self): - inverted_color = Color(self.hx) - - def define_color_str(self, name): - hex_str = self.hx.replace("#", "") - out_str = "\\definecolor{" + name + "}{HTML}{" + hex_str + "}" - out_str += " " * (70 - len(out_str)) + "% https://www.colorhexa.com/" + hex_str - return out_str - - def __str__(self): - return self.hx - - -# https://matplotlib.org/stable/gallery/color/named_colors.html -def mcolors2mplcolors(colors): - names = sorted(colors, key=lambda c: tuple(mcolors.rgb_to_hsv(mcolors.to_rgb(c)))) - col_dict = dict() - for name in names: - col_dict[name] = Color(colors[name]) - return col_dict - - -def import_colors(cmap="pastel"): - col_dict = dict() - col_dict["pastel"] = mcolors2mplcolors(mcolors.CSS4_COLORS) - col_dict["cmap2"] = mcolors2mplcolors(mcolors.CSS4_COLORS) - col_dict["thesis_colors"] = mcolors2mplcolors(mcolors.CSS4_COLORS) - - col_dict["pastel"]["white"] = Color("#ffffff") - col_dict["pastel"]["black"] = Color("#000000") - col_dict["pastel"]["yellow"] = Color("#FFFFB3") - col_dict["pastel"]["dkyellow"] = Color("#FFED6F") - col_dict["pastel"]["purple"] = Color("#BEBADA") - col_dict["pastel"]["dkpurple"] = Color("#BC80BD") - col_dict["pastel"]["red"] = Color("#FB8072") - col_dict["pastel"]["ltred"] = Color("#FFCCCB") - col_dict["pastel"]["dkred"] = Color("#CB0505") - col_dict["pastel"]["orange"] = Color("#FDB462") - col_dict["pastel"]["dkgold"] = Color("#B8860B") - col_dict["pastel"]["blue"] = Color("#80B1D3") - col_dict["pastel"]["dkblue"] = Color("#00008B") - col_dict["pastel"]["deepskyblue"] = Color("#1f78b4") - col_dict["pastel"]["green"] = Color("#B3DE69") - col_dict["pastel"]["ltgreen"] = Color("#CCEBC5") - col_dict["pastel"]["dkgreen"] = Color("#006400") - col_dict["pastel"]["bluegreen"] = Color("#8DD3C7") - col_dict["pastel"]["pink"] = Color("#FCCDE5") - col_dict["pastel"]["ltgray"] = Color("#D9D9D9") - col_dict["pastel"]["dkgray"] = Color("#515151") - col_dict["pastel"]["brown"] = Color("#D2691E") - - col_dict["cmap2"]["white"] = Color("#ffffff") - col_dict["cmap2"]["black"] = Color("#000000") - col_dict["cmap2"]["yellow"] = Color("#ffff99") - col_dict["cmap2"]["dkyellow"] = Color("#FFED6F") - col_dict["cmap2"]["ltpurple"] = Color("#cab2d6") - col_dict["cmap2"]["purple"] = Color("#6a3d9a") - col_dict["cmap2"]["dkpurple"] = Color("#BC80BD") - col_dict["cmap2"]["red"] = Color("#e31a1c") - col_dict["cmap2"]["ltred"] = Color("#fb9a99") - col_dict["cmap2"]["dkred"] = Color("#CB0505") - col_dict["cmap2"]["ltorange"] = Color("#fdbf6f") - col_dict["cmap2"]["orange"] = Color("#ff7f00") - col_dict["cmap2"]["blue"] = Color("#1f78b4") - col_dict["cmap2"]["dkblue"] = Color("#00008B") - col_dict["cmap2"]["deepskyblue"] = Color("#1f78b4") - col_dict["cmap2"]["green"] = Color("#33a02c") - col_dict["cmap2"]["ltgreen"] = Color("#b2df8a") - col_dict["cmap2"]["dkgreen"] = Color("#006400") - col_dict["cmap2"]["bluegreen"] = Color("#8DD3C7") - col_dict["cmap2"]["pink"] = Color("#FCCDE5") - col_dict["cmap2"]["ltgray"] = Color("#D9D9D9") - col_dict["cmap2"]["dkgray"] = Color("#515151") - col_dict["cmap2"]["brown"] = Color("#b15928") - - -def import_col_list(cmap="cmap2"): - col_dict = import_colors(cmap) - col_list = [ - col_dict["black"], - col_dict["blue"], - col_dict["red"], - col_dict["green"], - col_dict["orange"], - col_dict["purple"], - col_dict["gray"], - col_dict["brown"], - # col_dict['green'], - ] - return col_list - - -def id2color(id, cmap="cmap2"): - col_list = import_col_list(cmap=cmap) - return col_list[id % len(col_list)].hx - - -# -# ,------.,--. ,--. -# | .---'`--' ,---. ,--.,--.,--.--. ,---. ,---. ,---. ,-' '-.,--.,--. ,---. -# | `--, ,--.| .-. || || || .--'| .-. : ( .-' | .-. :'-. .-'| || || .-. | -# | |` | |' '-' '' '' '| | \ --. .-' `)\ --. | | ' '' '| '-' ' -# `--' `--'.`- / `----' `--' `----' `----' `----' `--' `----' | |-' -# `---' `--' - - -linestyles = dict() -linestyles["solid"] = "solid" # Same as (0, ()) or '-' -linestyles["dotted"] = "dotted" # Same as (0, (1, 1)) or '.' -linestyles["dashed"] = "dashed" # Same as '--' -linestyles["dashdot"] = "dashdot" # Same as '-.' -linestyles["loosely dotted"] = (0, (1, 10)) -linestyles["dotted"] = (0, (1, 1)) -linestyles["densely dotted"] = (0, (1, 1)) - -linestyles["loosely dashed"] = (0, (5, 10)) -linestyles["dashed"] = (0, (5, 5)) -linestyles["densely dashed"] = (0, (5, 1)) - -linestyles["loosely dashdotted"] = (0, (3, 10, 1, 10)) -linestyles["dashdotted"] = (0, (3, 5, 1, 5)) -linestyles["densely dashdotted"] = (0, (3, 1, 1, 1)) - -linestyles["dashdotdotted"] = (0, (3, 5, 1, 5, 1, 5)) -linestyles["loosely dashdotdotted"] = (0, (3, 10, 1, 10, 1, 10)) -linestyles["densely dashdotdotted"] = (0, (3, 1, 1, 1, 1, 1)) - -linestyle_list = [linestyles[l] for l in linestyles] -linestyle_list_ordered = [ - linestyles["solid"], - linestyles["densely dashdotted"], - linestyles["dashed"], - linestyles["dotted"], -] - - -class figure: - def __init__( - self, - load_file="", - nx_subplots=1, - ny_subplots=1, - width=426.79135, - figsize=None, - scale_width=1, - dpi=300, - threeD=False, - ratio="golden", - legend=True, - axes_grid=False, - gridspec_kw={"wspace": 0.08, "hspace": 0.1}, - legend_position="upper right", - filename="MaxFigureClassInstance", - directory="./", - cmap="cmap2", - fontsize=14, - tex_fonts=True, - ): - # if width == 'singlecol': - # width = 426.79135 / 2.0 - # if width == 'doublecol': - # width = 426.79135 - - self.nx_subplots = nx_subplots - self.ny_subplots = ny_subplots - self.width = width * scale_width - self.dpi = dpi - self.threeD = threeD - self.ratio = ratio - self.legend = legend - self.filename = filename - self.directory = directory - self.axes_grid = axes_grid - self.gridspec_kw = gridspec_kw - self.cmap = cmap - self.col_list = import_colors(self.cmap) - - self.axes_grid_which = "major" - self.grid_alpha = 1.0 - self.grid_linestyle = linestyles["densely dotted"] - self.fontsize = fontsize - # print(self.directory) - if len(self.directory) > 0: - if not self.directory[-1] == "/": - self.directory += "/" - - # - # plt.style.use('seaborn') - # - if not figsize == None: - self.width = figsize[0] - self.ratio = figsize[0] / figsize[1] - - if tex_fonts: - self.setup_tex_fonts() - - if not load_file == "": - self.load(load_file) - elif threeD: - self.create_3dplot() - else: - self.create_lineplot() - - def setup_tex_fonts(self): - self.tex_fonts = { - # Use LaTeX to write all text - "text.usetex": True, - "font.family": "serif", - "pgf.rcfonts": False, # don't setup fonts from rc parameters - # Use 10pt font in plots, to match 10pt font in document - "axes.labelsize": self.fontsize, - "font.size": self.fontsize, - # Make the legend/label fonts a little smaller - "legend.fontsize": self.fontsize, - "xtick.labelsize": self.fontsize, - "ytick.labelsize": self.fontsize, - } - self.setup_plotstyle( - tex_fonts=self.tex_fonts, - axes_grid=self.axes_grid, - axes_grid_which=self.axes_grid_which, - grid_alpha=self.grid_alpha, - grid_linestyle=self.grid_linestyle, - ) - - def create_lineplot(self): - self.fig, self.axs = plt.subplots( - self.ny_subplots, - self.nx_subplots, - figsize=self.set_size( - self.width, - ratio=self.ratio, # - ), # sharex=True,#sharex='all', sharey='all', - dpi=self.dpi, - constrained_layout=False, - gridspec_kw=self.gridspec_kw, - ) - - def create_3dplot(self): - self.fig = plt.figure(figsize=self.set_size(self.width), dpi=self.dpi) - self.axs = self.fig.add_subplot(111, projection="3d") - - def setup_plotstyle( - self, - tex_fonts=True, - axes_grid=True, - axes_grid_which="major", - grid_alpha=0.0, - grid_linestyle="dotted", - ): - if tex_fonts: - plt.rcParams.update(self.tex_fonts) - - plt.rcParams["axes.grid"] = axes_grid # False ## display grid or not - # gridlines at major, minor or both ticks - plt.rcParams["axes.grid.which"] = axes_grid_which - plt.rcParams["grid.alpha"] = grid_alpha # transparency, between 0.0 and 1.0 - plt.rcParams["grid.linestyle"] = grid_linestyle - - plt.rcParams["xtick.direction"] = "in" - plt.rcParams["ytick.direction"] = "in" - - # This is to avoid the overlapping tick labels. - plt.rcParams["xtick.major.pad"] = 8 - plt.rcParams["ytick.major.pad"] = 8 - # plt.rc('text.latex', preamble=r'\usepackage{wasysym}') - - def set_common_xlabel(self, xlabel="common X"): - self.fig.text( - 0.5, - -0.075, - xlabel, - va="center", - ha="center", - fontsize=self.fontsize, - ) - # fig.text(0.04, 0.5, 'common Y', va='center', ha='center', rotation='vertical', fontsize=rcParams['axes.labelsize']) - - def set_size(self, width, fraction=1, ratio="golden"): - """Set figure dimensions to avoid scaling in LaTeX. - Parameters - ---------- - width: float - Document textwidth or columnwidth in pts - fraction: float, optional - Fraction of the width which you wish the figure to occupy - Returns - ------- - fig_dim: tuple - Dimensions of figure in inches - """ - # - # Width of figure (in pts) - if width == "thesis": - width_pt = 426.79135 - elif width == "beamer": - width_pt = 307.28987 - else: - width_pt = width - - # Width of figure - fig_width_pt = width_pt * fraction - - # Convert from pt to inches - inches_per_pt = 1 / 72.27 - - # Golden ratio to set aesthetic figure height - # https://disq.us/p/2940ij3 - golden_ratio = (5**0.5 - 1) / 2 - - # Figure width in inches - fig_width_in = fig_width_pt * inches_per_pt - - if ratio == "golden": - # Figure height in inches - fig_height_in = fig_width_in * golden_ratio - - elif ratio == "square": - # Figure height in inches - fig_height_in = fig_width_in - # print('ratio',ratio) - if type(ratio) == int or type(ratio) == float: - fig_height_in = fig_width_in * ratio - - fig_dim = (fig_width_in, fig_height_in) - - return fig_dim - - def get_axis(self, subfigure): - if subfigure == -1: - return self.axs - elif not isinstance(subfigure, list): - return self.axs[subfigure] - elif isinstance(subfigure, list) and len(subfigure) == 2: - return self.axs[subfigure[0], subfigure[1]] - - def get_limits(self, ax=None): - if ax == None: - xxmin, xxmax = self.axs.get_xlim() - yymin, yymax = self.axs.get_ylim() - else: - xxmin, xxmax = ax.get_xlim() - yymin, yymax = ax.get_ylim() - arr = [xxmin, xxmax, yymin, yymax] - return arr - - def set_labels(self, delta, point, subfigure=-1, axis="x"): - ax = self.get_axis(subfigure) - plt.sca(ax) - if axis == "x": - xmin, xmax = ax.get_xlim() - width = int((xmax - xmin) / delta + 1) * delta - locs, labels = plt.xticks() - i0 = int(xmin / delta) - i1 = int(xmax / delta) - xvec = [] - xvec = np.arange(point - width, point + width + delta, delta) - xvec += point - xvec = xvec[xvec >= xmin] - xvec = xvec[xvec <= xmax] - new_labels = [i * delta for i in range(i0, i1)] - # if precision == 0: new_labels = [int(x) for x in new_labels] - plt.xticks(xvec, xvec) - if axis == "y": - return - - def scale_axis( - self, - subfigure=-1, - axis="x", - axs_in=None, - scale=1.0, - shift=0, - precision=2, - delta=-1, - includepoint=-1, - nticks=5, - locs_labels=None, - ): - # https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.xticks.html - # if subfigure_x == -1 and subfigure_y == -1 and nx_subplots > 1 and ny_subplots > 1: - # print('enter subfigure_x and subfigure_y!') - # return - # if subfigure_x == -1 and subfigure_y == -1: - # ax = self.axs[] - if subfigure == -1: - ax = self.axs - elif not isinstance(subfigure, list): - ax = self.axs[subfigure] - elif isinstance(subfigure, list) and len(subfigure) == 2: - ax = self.axs[subfigure[0], subfigure[1]] - - if not axs_in == None: - ax = axs_in - # print("precision", precision, precision, precision) - plt.sca(ax) - if axis == "x": - if locs_labels == None: - xmin, xmax = ax.get_xlim() - locs, labels = plt.xticks() - if delta == -1 and includepoint == -1: - new_labels = [round((x + shift) * scale, precision) for x in locs] - if precision == 0: - new_labels = [int(x) for x in new_labels] - else: - if delta == -1: - delta = (xmax - xmin) / (nticks - 1) - if includepoint == -1: - includepoint = xmin - width = int((xmax - xmin) / delta + 1) * delta - i0 = int(xmin / delta) - i1 = int(xmax / delta + 1) - locs = np.arange( - includepoint - width, - includepoint + width + delta, - delta, - ) - locs = locs[locs >= xmin - 1e-12] - locs = locs[locs <= xmax + 1e-12] - - new_labels = [round((x + shift) * scale, precision) for x in locs] - if precision == 0: - new_labels = [int(y) for y in new_labels] - new_labels = [f"${l}$" for l in new_labels] - # plt.xticks(locs,new_labels) - ax.set_xticks(locs) - ax.set_xticklabels(new_labels) - ax.axis(xmin=xmin, xmax=xmax) - else: - # plt.xticks(locs_labels['locs'],locs_labels['labels']) - ax.set_xticks(locs_labels["locs"]) - ax.set_xticklabels(locs_labels["labels"]) - - if axis == "y": - if locs_labels == None: - ymin, ymax = ax.get_ylim() - locs, labels = plt.yticks() - if delta == -1 and includepoint == -1: - new_labels = [round((y + shift) * scale, precision) for y in locs] - if precision == 0: - new_labels = [int(y) for y in new_labels] - else: - if delta == -1: - delta = (ymax - ymin) / (nticks - 1) - if includepoint == -1: - includepoint = ymin - width = int((ymax - ymin) / delta + 1) * delta - i0 = int(ymin / delta) - i1 = int(ymax / delta + 1) - locs = np.arange( - includepoint - width, - includepoint + width + delta, - delta, - ) - locs = locs[locs >= ymin - 1e-12] - locs = locs[locs <= ymax + 1e-12] - - new_labels = [round((y + shift) * scale, precision) for y in locs] - if precision == 0: - new_labels = [int(y) for y in new_labels] - new_labels = [f"${l}$" for l in new_labels] - # plt.yticks(locs,new_labels) - - ax.set_yticks(locs) - ax.set_yticklabels(new_labels) - - ax.axis(ymin=ymin, ymax=ymax) - else: - # plt.yticks(locs_labels['locs'],locs_labels['labels']) - ax.set_yticks(locs_labels["locs"]) - ax.set_yticklabels(locs_labels["labels"]) - - def adjustFigAspect(self, aspect=1): - """ - Adjust the subplot parameters so that the figure has the correct - aspect ratio. - """ - xsize, ysize = self.fig.get_size_inches() - minsize = min(xsize, ysize) - xlim = 0.4 * minsize / xsize - ylim = 0.4 * minsize / ysize - if aspect < 1: - xlim *= aspect - else: - ylim /= aspect - self.fig.subplots_adjust( - left=0.5 - xlim, - right=0.5 + xlim, - bottom=0.5 - ylim, - top=0.5 + ylim, - ) - - def add_figure_label( - self, - label, - pos="top left", - bbox=dict(facecolor="white", edgecolor="gray", boxstyle="round"), - ha="left", - va="top", - ax=None, - ): - limits = self.get_limits(ax) - # print(limits) - lx = limits[1] - limits[0] - ly = limits[3] - limits[2] - - if isinstance(pos, str): - if "top" in pos: - y = limits[2] + 0.90 * ly - elif "center in pos": - y = limits[2] + 0.5 * ly - else: - y = limits[2] + 0.05 * ly - - if "left" in pos: - x = limits[0] + 0.1 * lx - else: - x = limits[0] + 0.95 * lx - else: - x = limits[0] + pos[0] * lx - y = limits[2] + pos[1] * ly - - # print(x,y) - if ax == None: - ax = self.axs - ax.text( - x, - y, - f"{label}", - rotation=0, - ha=ha, - va=va, - bbox=bbox, - fontsize=self.fontsize, - ) - - def savefig( - self, - filename="", - formats=["png"], - format="", - create_sh_file=False, - print_imgcat=True, - format_folder=False, - tight_layout=True, - ): - # self.update_figure() - # self.fig.tight_layout() - # print(self.directory) - - if "/" in self.filename: - tmp = self.filename - spl = tmp.split("/") - self.filename = spl[-1] - self.directory = tmp.replace(spl[-1], "") - - if not self.directory == "": - Path(self.directory).mkdir(parents=True, exist_ok=True) - - if isinstance(format, list): - formats = format - format = "" - if not format == "": - formats = [format] - if filename == "": - filename = self.filename - - if formats == "all" or formats == ["all"]: - self.dump() - formats = ["jpg", "pdf", "pgf", "png", "svg", "txt", "pickle", "tex"] - - if isinstance(formats, str): - formats = [formats] - - if format_folder: - for format in formats: - # print('self.directory',self.directory) - Path(self.directory + "/" + format).mkdir(parents=True, exist_ok=True) - - _dir = self.directory - for format in formats: - if format_folder: - self.directory = "{}{}/".format(_dir, format) - # print('pl',format) - if format in [ - "eps", - "jpeg", - "jpg", - "pdf", - "png", - "ps", - "raw", - "rgba", - "svg", - "svgz", - "tif", - "tiff", - ]: - # self.fig.savefig(self.directory + filename + '.' + format,bbox_inches='tight', transparent=False) - if tight_layout: - self.fig.savefig( - self.directory + filename + "." + format, - bbox_inches="tight", - ) - else: - self.fig.savefig(self.directory + filename + "." + format) - elif format == "pgf": - # Save pgf figure - self.fig.savefig( - self.directory + filename + "." + format, - bbox_inches="tight", - ) - - # Replace pgf figure colors with colorlet - # This is based af. - # col_list = self.col_list - file_str = "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n" - file_str += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n" - file_str += "%% Do not forget to add the following lines" - for cmap in ["pastel", "cmap2"]: - col_list = import_colors(cmap) - file_str += "\n\n%% Definitions for " + cmap + "\n\n" - for col in col_list: - file_str += "%" + col_list[col].define_color_str(col) + "\n" - file_str += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n" - file_str += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\n\n" - with open(self.directory + filename + "." + format, "r") as f: - for line in f: - file_str += line - for cmap in ["pastel", "cmap2"]: - col_list = import_colors(cmap) - for col in col_list: - if col_list[col].pgf_col_str in line: - # print(line) - file_str += ( - "\\colorlet{currentstroke}{" + col + "}%\n" - ) - file_str += ( - "\\colorlet{currentfill}{" + col + "}%\n" - ) - file_str += "\\colorlet{textcolor}{" + col + "}%\n" - - with open(self.directory + filename + "." + format, "w") as f: - f.write(file_str) - elif format in ["txt", "dat", "csv"]: - self.matplotlib2txt(self.directory + filename, format) - elif format == "pickle": - pickle.dump(self.fig, open(self.directory + filename + ".pickle", "wb")) - elif format == "tex": - import tikzplotlib - - # tikzplotlib.clean_figure() - tikzplotlib.save(self.directory + filename + ".tex") - else: - try: - plt.savefig( - self.directory + filename + "." + format, - bbox_inches="tight", - ) - except Exception as e: - print( - "ERROR: Could not save figure: " - + self.directory - + filename - + "." - + format, - ) - print(e) - - imgcat_formats = ["png"] - if create_sh_file: - with open("show_latest_image.sh", "w") as f: - for format in formats: - if format in imgcat_formats: - f.write( - "imgcat " + self.directory + filename + "." + format + "\n", - ) - - if print_imgcat and ("png" in formats or "pdf" in formats): - if format_folder: - self.directory = "{}{}/".format(_dir, "png") - self.imgcat(formats) - self.directory = _dir - - # if format in formats: - # print('imgcat ' + filename + '.' + format) - - def imgcat(self, formats="png"): - imgcat_formats = ["png"] - if isinstance(formats, str): - formats = [formats] - for format in formats: - if format in imgcat_formats: - print("imgcat " + self.directory + self.filename + "." + format) - - def matplotlib2txt(self, filename, format="txt"): - # ax = plt.gca() # get axis handle - - x_unit = "mm" - y_unit = "mm" - - max_len_arr = 0 - - # Create a vector with each axis - axs_vec = [] - if self.nx_subplots > 1 and self.ny_subplots > 1: - for i in range(self.nx_subplots): - for j in range(self.ny_subplots): - axs_vec.append(self.axs[i, j]) - elif self.nx_subplots > 1 or self.ny_subplots > 1: - for i in range(self.nx_subplots * self.ny_subplots): - axs_vec.append(self.axs[i]) - else: - axs_vec.append(self.axs) - - # Save all the data - line_names = [] - line_xdata = [] - line_ydata = [] - for iax, ax in enumerate(axs_vec): - for line in ax.lines: - line_names.append(line) - line_xdata.append(line.get_xdata()) - line_ydata.append(line.get_ydata()) - max_len_arr = max(max_len_arr, len(line.get_xdata())) - # print(line_names) - data_mat = np.empty((len(line_names) * 2, max_len_arr)) - data_mat[:, :] = np.NaN - i = 0 - - header = "" - - for name, xdata, ydata in zip(line_names, line_xdata, line_ydata): - data_mat[2 * i, 0 : len(xdata)] = xdata - data_mat[2 * i + 1, 0 : len(ydata)] = ydata - - header += "Axial position, " + str(name) + "," - - i += 1 - - np.savetxt(filename + "." + format, data_mat.T, header=header, delimiter=",") - - def dump( - self, - filename="", - ): - if filename == "": - filename = self.filename + "_dump.txt" - Path(self.directory + "/dump").mkdir(parents=True, exist_ok=True) - with open(self.directory + "dump/" + filename, "wb") as file: - file.write(cPickle.dumps(self.__dict__)) - - def load(self, filename): - with open(filename, "rb") as file: - self.__dict__ = cPickle.loads(file.read()) - - def get_lines(self): - lines = plt.gca().lines - out = [] - for i, line in enumerate(lines): - line_dict = dict() - line_dict["line"] = line - line_dict["line_name"] = str(line) - line_dict["line_xdat"] = line.get_xdata() - line_dict["line_ydat"] = line.get_ydata() - out.append(line_dict) - return out - - def add_label_box( - self, - label="Test", - xpos=0.05, - ypos=0.95, - rotation=0, - ha="left", - va="top", - bbox=dict(facecolor="white", edgecolor="gray", boxstyle="round"), - ): - self.axs.text( - xpos, - ypos, - label, - rotation=rotation, - ha=ha, - va=va, - transform=self.axs.transAxes, - bbox=bbox, - ) - # print(label) - - -def fmt_scientific(x, pos): - a, b = "{:.1e}".format(x).split("e") - b = int(b) - return r"${} \times 10^{{{}}}$".format(a, b) - - -def fmt_10pow(x, pos): - a, b = "{:.1e}".format(x).split("e") - b = int(b) - return r"$10^{{{}}}$".format(b) - - -def fmt_int(x, pos, num_dec): - return r"${}$".format(int(x)) - - -def fmt_1dec(x, pos): - return r"${}$".format(round(x, 1)) - - -def fmt_2dec(x, pos): - return r"${}$".format(round(x, 2)) - - -if __name__ == "__main__": - print("Testing maxplotlib") - mfig = figure(filename="mpl_test") - mfig.axs.plot([0, 1, 2, 3], [0, 0, 1, 1]) - mfig.savefig(formats=["png"]) From c09b63f44df7308fdbbe55c3e4fe70c7ce97d8f9 Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 25 Jan 2026 21:17:02 +0100 Subject: [PATCH 04/16] Added tikzpics backend export --- src/maxplotlib/canvas/canvas.py | 38 ++++++++++-- src/maxplotlib/subfigure/line_plot.py | 29 ++++++++- src/maxplotlib/utils/options.py | 2 +- tutorials/tutorial_02.ipynb | 23 +++++-- tutorials/tutorial_06.ipynb | 12 +--- tutorials/tutorial_07_tikzpics.ipynb | 89 +++++++++++++++++++++++++++ 6 files changed, 171 insertions(+), 22 deletions(-) create mode 100644 tutorials/tutorial_07_tikzpics.ipynb diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index 8fbc51f..c53294a 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -11,7 +11,8 @@ setup_tex_fonts, ) from maxplotlib.subfigure.line_plot import LinePlot -from maxplotlib.subfigure.tikz_figure import TikzFigure +from maxplotlib.subfigure.tikz_figure import TikzFigure as TikzFigureMPL +from tikzpics import TikzFigure from maxplotlib.utils.options import Backends @@ -144,7 +145,7 @@ def add_tikzfigure( row, col = self.generate_new_rowcol(row, col) # Initialize the LinePlot for the given subplot position - tikz_figure = TikzFigure( + tikz_figure = TikzFigureMPL( col=col, row=row, label=label, @@ -263,20 +264,33 @@ def savefig( if verbose: print(f"Saved {full_filepath}") - def plot(self, backend: Backends = "matplotlib", savefig=False, layers=None): + def plot( + self, + backend: Backends = "matplotlib", + savefig=False, + layers=None, + ): if backend == "matplotlib": return self.plot_matplotlib(savefig=savefig, layers=layers) elif backend == "plotly": return self.plot_plotly(savefig=savefig) + elif backend == "tikzpics": + return self.plot_tikzpics(savefig=savefig) else: raise ValueError(f"Invalid backend: {backend}") - def show(self, backend="matplotlib"): + def show( + self, + backend: Backends = "matplotlib", + ): if backend == "matplotlib": self.plot(backend="matplotlib", savefig=False, layers=None) self._matplotlib_fig.show() elif backend == "plotly": plot = self.plot_plotly(savefig=False) + elif backend == "tikzpics": + fig = self.plot_tikzpics(savefig=False) + fig.show() else: raise ValueError("Invalid backend") @@ -329,6 +343,22 @@ def plot_matplotlib(self, savefig=False, layers=None, usetex=False): self._matplotlib_axes = axes return fig, axes + def plot_tikzpics( + self, + savefig=None, + verbose=False, + ) -> TikzFigure: + if len(self.subplots) > 0: + raise NotImplementedError( + "Only one subplot is supported for tikzpics backend." + ) + for (row, col), line_plot in self.subplots.items(): + if verbose: + print(f"Plotting subplot at row {row}, col {col}") + print(f"{line_plot = }") + tikz_subplot = line_plot.plot_tikzpics(verbose=verbose) + return tikz_subplot + def plot_plotly(self, show=True, savefig=None, usetex=False): """ Generate and optionally display the subplots using Plotly. diff --git a/src/maxplotlib/subfigure/line_plot.py b/src/maxplotlib/subfigure/line_plot.py index 9435b37..a457e1c 100644 --- a/src/maxplotlib/subfigure/line_plot.py +++ b/src/maxplotlib/subfigure/line_plot.py @@ -3,8 +3,8 @@ import plotly.graph_objects as go from mpl_toolkits.axes_grid1 import make_axes_locatable -import maxplotlib.subfigure.tikz_figure as tf from maxplotlib.objects.layer import Tikzlayer +from tikzpics import TikzFigure class Node: @@ -224,6 +224,21 @@ def plot_matplotlib( if self.ymax is not None: ax.axis(ymax=self.ymax) + def plot_tikzpics(self, layers=None, verbose: bool = False) -> TikzFigure: + + tikz_figure = TikzFigure() + for layer_name, layer_lines in self.layered_line_data.items(): + if layers and layer_name not in layers: + continue + for line in layer_lines: + if line["plot_type"] == "plot": + x = (line["x"] + self._xshift) * self._xscale + y = (line["y"] + self._yshift) * self._yscale + + nodes = [[xi, yi] for xi, yi in zip(x, y)] + tikz_figure.draw(nodes=nodes, **line["kwargs"]) + return tikz_figure + def plot_plotly(self): """ Plot all lines using Plotly and return a list of traces for each line. @@ -255,7 +270,17 @@ def plot_plotly(self): return traces - def add_node(self, x, y, label=None, content="", layer=0, **kwargs): + # def plot_tikzpics(self): + + def add_node( + self, + x: int | float, + y: int | float, + label: str | None = None, + content: str = "", + layer=0, + **kwargs, + ): """ Add a node to the TikZ figure. diff --git a/src/maxplotlib/utils/options.py b/src/maxplotlib/utils/options.py index 78d5482..6666e4d 100644 --- a/src/maxplotlib/utils/options.py +++ b/src/maxplotlib/utils/options.py @@ -1,3 +1,3 @@ from typing import Literal -Backends = Literal["matplotlib", "plotly"] +Backends = Literal["matplotlib", "plotly", "tikzpics"] diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index 62110a4..0311fa2 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "1", "metadata": {}, "outputs": [], @@ -23,10 +23,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "TikzFigure.__init__() got an unexpected keyword argument 'col'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m c = Canvas(width=\u001b[32m800\u001b[39m, ratio=\u001b[32m0.5\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m tikz = \u001b[43mc\u001b[49m\u001b[43m.\u001b[49m\u001b[43madd_tikzfigure\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgrid\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# Add nodes\u001b[39;00m\n\u001b[32m 5\u001b[39m tikz.add_node(\u001b[32m0\u001b[39m, \u001b[32m0\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mA\u001b[39m\u001b[33m\"\u001b[39m, shape=\u001b[33m\"\u001b[39m\u001b[33mcircle\u001b[39m\u001b[33m\"\u001b[39m, draw=\u001b[33m\"\u001b[39m\u001b[33mblack\u001b[39m\u001b[33m\"\u001b[39m, fill=\u001b[33m\"\u001b[39m\u001b[33mblue\u001b[39m\u001b[33m\"\u001b[39m, layer=\u001b[32m0\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/git_repos/maxplotlib/src/maxplotlib/canvas/canvas.py:149\u001b[39m, in \u001b[36mCanvas.add_tikzfigure\u001b[39m\u001b[34m(self, col, row, label, **kwargs)\u001b[39m\n\u001b[32m 146\u001b[39m row, col = \u001b[38;5;28mself\u001b[39m.generate_new_rowcol(row, col)\n\u001b[32m 148\u001b[39m \u001b[38;5;66;03m# Initialize the LinePlot for the given subplot position\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m149\u001b[39m tikz_figure = \u001b[43mTikzFigure\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 150\u001b[39m \u001b[43m \u001b[49m\u001b[43mcol\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcol\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 151\u001b[39m \u001b[43m \u001b[49m\u001b[43mrow\u001b[49m\u001b[43m=\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 152\u001b[39m \u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 153\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 154\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 155\u001b[39m \u001b[38;5;28mself\u001b[39m._subplot_matrix[row][col] = tikz_figure\n\u001b[32m 157\u001b[39m \u001b[38;5;66;03m# Store the LinePlot instance by its position for easy access\u001b[39;00m\n", + "\u001b[31mTypeError\u001b[39m: TikzFigure.__init__() got an unexpected keyword argument 'col'" + ] + } + ], "source": [ "c = Canvas(width=800, ratio=0.5)\n", "tikz = c.add_tikzfigure(grid=False)\n", @@ -132,7 +145,7 @@ ], "metadata": { "kernelspec": { - "display_name": "env_maxplotlib", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -146,7 +159,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.14.2" } }, "nbformat": 4, diff --git a/tutorials/tutorial_06.ipynb b/tutorials/tutorial_06.ipynb index d783520..6aeed04 100644 --- a/tutorials/tutorial_06.ipynb +++ b/tutorials/tutorial_06.ipynb @@ -38,19 +38,11 @@ "\n", "c.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "env_maxplotlib", + "display_name": "env_maxpic", "language": "python", "name": "python3" }, @@ -64,7 +56,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.13.3" } }, "nbformat": 4, diff --git a/tutorials/tutorial_07_tikzpics.ipynb b/tutorials/tutorial_07_tikzpics.ipynb new file mode 100644 index 0000000..42b3131 --- /dev/null +++ b/tutorials/tutorial_07_tikzpics.ipynb @@ -0,0 +1,89 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0", + "metadata": {}, + "source": [ + "# Tutorial 6" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "from maxplotlib import Canvas\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(self.subplots) = 1\n", + "Plotting subplot at row 0, col 0\n", + "line_plot = \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c = Canvas(width=\"17cm\", ratio=0.5)\n", + "sp = c.add_subplot(grid=False, xlabel=\"x\", ylabel=\"y\")\n", + "sp.add_line([0, 1, 2, 3], [0, 1, 0, 2], label=\"Line 1\", layer=1, line_width=2.0)\n", + "\n", + "c.show(backend=\"tikzpics\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 410a2587c89768d8417e63d7a066173fef48a954 Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 25 Jan 2026 21:56:02 +0100 Subject: [PATCH 05/16] Fixed the tikzpics --> matplotlib export --- src/maxplotlib/backends/matplotlib/utils.py | 9 -- src/maxplotlib/canvas/canvas.py | 161 +++++++++++++++++++- src/maxplotlib/colors/colors.py | 1 - src/maxplotlib/objects/layer.py | 2 +- src/maxplotlib/subfigure/line_plot.py | 2 +- src/maxplotlib/subfigure/tikz_figure.py | 2 - src/maxplotlib/tests/test_canvas.py | 3 +- src/maxplotlib/tests/test_imports.py | 3 +- tutorials/tutorial_02.ipynb | 149 ++++++++++++++++-- tutorials/tutorial_06.ipynb | 1 - 10 files changed, 291 insertions(+), 42 deletions(-) diff --git a/src/maxplotlib/backends/matplotlib/utils.py b/src/maxplotlib/backends/matplotlib/utils.py index 6e15ca5..827fef1 100644 --- a/src/maxplotlib/backends/matplotlib/utils.py +++ b/src/maxplotlib/backends/matplotlib/utils.py @@ -1,18 +1,9 @@ # import sys; from os.path import dirname; sys.path.append(f'{dirname(__file__)}/../../') # import matplotlib.pylab as pylab -import math -import pickle -from pathlib import Path -import _pickle as cPickle -import matplotlib.colors as mcolors import matplotlib.pyplot as plt -import numpy as np import pint -from matplotlib.collections import PatchCollection -from mpl_toolkits.mplot3d import Axes3D -from mpl_toolkits.mplot3d.art3d import Line3DCollection, Poly3DCollection def setup_tex_fonts(fontsize=14, usetex=False): diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index c53294a..67376cf 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -1,18 +1,20 @@ import os +import re from typing import Dict +import matplotlib.patches as patches import matplotlib.pyplot as plt -import plotly.graph_objects as go from plotly.subplots import make_subplots +from tikzpics import TikzFigure from maxplotlib.backends.matplotlib.utils import ( set_size, setup_plotstyle, setup_tex_fonts, ) +from maxplotlib.colors.colors import Color +from maxplotlib.linestyle.linestyle import Linestyle from maxplotlib.subfigure.line_plot import LinePlot -from maxplotlib.subfigure.tikz_figure import TikzFigure as TikzFigureMPL -from tikzpics import TikzFigure from maxplotlib.utils.options import Backends @@ -145,9 +147,7 @@ def add_tikzfigure( row, col = self.generate_new_rowcol(row, col) # Initialize the LinePlot for the given subplot position - tikz_figure = TikzFigureMPL( - col=col, - row=row, + tikz_figure = TikzFigure( label=label, **kwargs, ) @@ -333,7 +333,12 @@ def plot_matplotlib(self, savefig=False, layers=None, usetex=False): for (row, col), subplot in self.subplots.items(): ax = axes[row][col] - subplot.plot_matplotlib(ax, layers=layers) + print("yo") + if isinstance(subplot, TikzFigure): + plot_matplotlib(subplot, ax, layers=layers) + else: + subplot.plot_matplotlib(ax, layers=layers) + print("yo2") # ax.set_title(f"Subplot ({row}, {col})") ax.grid() @@ -573,6 +578,148 @@ def __setitem__(self, key, value): # return latex_code +def plot_matplotlib(tikzfigure: TikzFigure, ax, layers=None): + """ + Plot all nodes and paths on the provided axis using Matplotlib. + + Parameters: + - ax (matplotlib.axes.Axes): Axis on which to plot the figure. + """ + + # Plot paths first so they appear behind nodes + for key, layer in tikzfigure.layers.layers.items(): + print(f"{layer = }") + print(f"Layer: {layer.generate_tikz()}") + + # TODO: Specify which layers to retreive nodes from with layers=layers + nodes = tikzfigure.layers.get_nodes() + paths = tikzfigure.layers.get_paths() + print(nodes) + + for path in paths: + x_coords = [node.x for node in path.nodes] + y_coords = [node.y for node in path.nodes] + + # Parse path color + path_color_spec = path.kwargs.get("color", "black") + try: + color = Color(path_color_spec).to_rgb() + except ValueError as e: + print(e) + color = "black" + + # Parse line width + line_width_spec = path.kwargs.get("line_width", 1) + if isinstance(line_width_spec, str): + match = re.match(r"([\d.]+)(pt)?", line_width_spec) + if match: + line_width = float(match.group(1)) + else: + print( + f"Invalid line width specification: '{line_width_spec}', defaulting to 1", + ) + line_width = 1 + else: + line_width = float(line_width_spec) + + # Parse line style using Linestyle class + style_spec = path.kwargs.get("style", "solid") + linestyle = Linestyle(style_spec).to_matplotlib() + + ax.plot( + x_coords, + y_coords, + color=color, + linewidth=line_width, + linestyle=linestyle, + zorder=1, # Lower z-order to place behind nodes + ) + + # Plot nodes after paths so they appear on top + for node in nodes: + print(node.__dict__) + # Determine shape and size + shape = node.kwargs.get("shape", "circle") + fill_color_spec = node.kwargs.get("fill", "white") + edge_color_spec = node.kwargs.get("draw", "black") + linewidth = float(node.kwargs.get("line_width", 1)) + size = float(node.kwargs.get("size", 1)) + + # Parse colors using the Color class + try: + facecolor = Color(fill_color_spec).to_rgb() + except ValueError as e: + print(e) + facecolor = "white" + + try: + edgecolor = Color(edge_color_spec).to_rgb() + except ValueError as e: + print(e) + edgecolor = "black" + + # Plot shapes + if shape == "circle": + radius = size / 2 + circle = patches.Circle( + (node.x, node.y), + radius, + facecolor=facecolor, + edgecolor=edgecolor, + linewidth=linewidth, + zorder=2, # Higher z-order to place on top of paths + ) + ax.add_patch(circle) + elif shape == "rectangle": + width = height = size + rect = patches.Rectangle( + (node.x - width / 2, node.y - height / 2), + width, + height, + facecolor=facecolor, + edgecolor=edgecolor, + linewidth=linewidth, + zorder=2, # Higher z-order + ) + ax.add_patch(rect) + else: + # Default to circle if shape is unknown + radius = size / 2 + circle = patches.Circle( + (node.x, node.y), + radius, + facecolor=facecolor, + edgecolor=edgecolor, + linewidth=linewidth, + zorder=2, + ) + ax.add_patch(circle) + + # Add text inside the shape + if node.content: + ax.text( + node.x, + node.y, + node.content, + fontsize=10, + ha="center", + va="center", + wrap=True, + zorder=3, # Even higher z-order for text + ) + + # Remove axes, ticks, and legend + ax.axis("off") + + # Adjust plot limits + all_x = [node.x for node in nodes] + all_y = [node.y for node in nodes] + padding = 1 # Adjust padding as needed + ax.set_xlim(min(all_x) - padding, max(all_x) + padding) + ax.set_ylim(min(all_y) - padding, max(all_y) + padding) + ax.set_aspect("equal", adjustable="datalim") + + if __name__ == "__main__": c = Canvas(ncols=2, nrows=2) sp = c.add_subplot() diff --git a/src/maxplotlib/colors/colors.py b/src/maxplotlib/colors/colors.py index d1381ef..fdb117e 100644 --- a/src/maxplotlib/colors/colors.py +++ b/src/maxplotlib/colors/colors.py @@ -1,7 +1,6 @@ import re import matplotlib.colors as mcolors -import matplotlib.patches as patches import numpy as np diff --git a/src/maxplotlib/objects/layer.py b/src/maxplotlib/objects/layer.py index 4ebb71c..c747b9f 100644 --- a/src/maxplotlib/objects/layer.py +++ b/src/maxplotlib/objects/layer.py @@ -1,4 +1,4 @@ -from abc import ABCMeta, abstractmethod +from abc import ABCMeta class Layer(metaclass=ABCMeta): diff --git a/src/maxplotlib/subfigure/line_plot.py b/src/maxplotlib/subfigure/line_plot.py index a457e1c..99b73b4 100644 --- a/src/maxplotlib/subfigure/line_plot.py +++ b/src/maxplotlib/subfigure/line_plot.py @@ -2,9 +2,9 @@ import numpy as np import plotly.graph_objects as go from mpl_toolkits.axes_grid1 import make_axes_locatable +from tikzpics import TikzFigure from maxplotlib.objects.layer import Tikzlayer -from tikzpics import TikzFigure class Node: diff --git a/src/maxplotlib/subfigure/tikz_figure.py b/src/maxplotlib/subfigure/tikz_figure.py index 4751c51..b878b4f 100644 --- a/src/maxplotlib/subfigure/tikz_figure.py +++ b/src/maxplotlib/subfigure/tikz_figure.py @@ -4,8 +4,6 @@ import tempfile import matplotlib.patches as patches -import numpy as np -from matplotlib.image import imread from maxplotlib.colors.colors import Color from maxplotlib.linestyle.linestyle import Linestyle diff --git a/src/maxplotlib/tests/test_canvas.py b/src/maxplotlib/tests/test_canvas.py index 5b7592d..847a2d5 100644 --- a/src/maxplotlib/tests/test_canvas.py +++ b/src/maxplotlib/tests/test_canvas.py @@ -1,6 +1,5 @@ def test(): - import maxplotlib.canvas.canvas - import maxplotlib.subfigure.line_plot + pass if __name__ == "__main__": diff --git a/src/maxplotlib/tests/test_imports.py b/src/maxplotlib/tests/test_imports.py index 302d52d..4eb1309 100644 --- a/src/maxplotlib/tests/test_imports.py +++ b/src/maxplotlib/tests/test_imports.py @@ -3,9 +3,8 @@ @pytest.mark.parametrize("x", [0]) def import_modules(x): - import matplotlib - import maxplotlib + pass if __name__ == "__main__": diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index 0311fa2..6161546 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -10,10 +10,19 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "id": "1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "from maxplotlib import Canvas\n", "\n", @@ -28,15 +37,14 @@ "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "TikzFigure.__init__() got an unexpected keyword argument 'col'", + "ename": "AttributeError", + "evalue": "'TikzFigure' object has no attribute 'add_path'", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m c = Canvas(width=\u001b[32m800\u001b[39m, ratio=\u001b[32m0.5\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m tikz = \u001b[43mc\u001b[49m\u001b[43m.\u001b[49m\u001b[43madd_tikzfigure\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgrid\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# Add nodes\u001b[39;00m\n\u001b[32m 5\u001b[39m tikz.add_node(\u001b[32m0\u001b[39m, \u001b[32m0\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mA\u001b[39m\u001b[33m\"\u001b[39m, shape=\u001b[33m\"\u001b[39m\u001b[33mcircle\u001b[39m\u001b[33m\"\u001b[39m, draw=\u001b[33m\"\u001b[39m\u001b[33mblack\u001b[39m\u001b[33m\"\u001b[39m, fill=\u001b[33m\"\u001b[39m\u001b[33mblue\u001b[39m\u001b[33m\"\u001b[39m, layer=\u001b[32m0\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/git_repos/maxplotlib/src/maxplotlib/canvas/canvas.py:149\u001b[39m, in \u001b[36mCanvas.add_tikzfigure\u001b[39m\u001b[34m(self, col, row, label, **kwargs)\u001b[39m\n\u001b[32m 146\u001b[39m row, col = \u001b[38;5;28mself\u001b[39m.generate_new_rowcol(row, col)\n\u001b[32m 148\u001b[39m \u001b[38;5;66;03m# Initialize the LinePlot for the given subplot position\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m149\u001b[39m tikz_figure = \u001b[43mTikzFigure\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 150\u001b[39m \u001b[43m \u001b[49m\u001b[43mcol\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcol\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 151\u001b[39m \u001b[43m \u001b[49m\u001b[43mrow\u001b[49m\u001b[43m=\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 152\u001b[39m \u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 153\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 154\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 155\u001b[39m \u001b[38;5;28mself\u001b[39m._subplot_matrix[row][col] = tikz_figure\n\u001b[32m 157\u001b[39m \u001b[38;5;66;03m# Store the LinePlot instance by its position for easy access\u001b[39;00m\n", - "\u001b[31mTypeError\u001b[39m: TikzFigure.__init__() got an unexpected keyword argument 'col'" + "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 12\u001b[39m\n\u001b[32m 8\u001b[39m tikz.add_node(\u001b[32m0\u001b[39m, \u001b[32m1\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mD\u001b[39m\u001b[33m\"\u001b[39m, shape=\u001b[33m\"\u001b[39m\u001b[33mcircle\u001b[39m\u001b[33m\"\u001b[39m, draw=\u001b[33m\"\u001b[39m\u001b[33mblack\u001b[39m\u001b[33m\"\u001b[39m, fill=\u001b[33m\"\u001b[39m\u001b[33mblue\u001b[39m\u001b[33m\"\u001b[39m, layer=\u001b[32m2\u001b[39m)\n\u001b[32m 11\u001b[39m \u001b[38;5;66;03m# Add a line between nodes\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m12\u001b[39m \u001b[43mtikz\u001b[49m\u001b[43m.\u001b[49m\u001b[43madd_path\u001b[49m(\n\u001b[32m 13\u001b[39m [\u001b[33m\"\u001b[39m\u001b[33mA\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mB\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mC\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mD\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 14\u001b[39m path_actions=[\u001b[33m\"\u001b[39m\u001b[33mdraw\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mrounded corners\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 15\u001b[39m fill=\u001b[33m\"\u001b[39m\u001b[33mred\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 16\u001b[39m opacity=\u001b[32m1.0\u001b[39m,\n\u001b[32m 17\u001b[39m cycle=\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[32m 18\u001b[39m layer=\u001b[32m1\u001b[39m,\n\u001b[32m 19\u001b[39m )\n\u001b[32m 21\u001b[39m tikz.add_node(\u001b[32m0.5\u001b[39m, \u001b[32m0.5\u001b[39m, content=\u001b[33m\"\u001b[39m\u001b[33mCube\u001b[39m\u001b[33m\"\u001b[39m, layer=\u001b[32m10\u001b[39m)\n\u001b[32m 23\u001b[39m \u001b[38;5;66;03m# tikz.compile_pdf(\"tutorial_02_01.pdf\")\u001b[39;00m\n\u001b[32m 24\u001b[39m \u001b[38;5;66;03m#\u001b[39;00m\n", + "\u001b[31mAttributeError\u001b[39m: 'TikzFigure' object has no attribute 'add_path'" ] } ], @@ -69,33 +77,118 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "yo\n", + "layer = \n", + "Layer: \n", + "% Layer 0\n", + "\\begin{pgfonlayer}{0}\n", + "\\node[shape=circle, draw=black, fill=blue!20] (A) at (-5, 0) {Origin node};\n", + "\\node[shape=rectangle, draw=red, fill=red] (C) at (2, 5) {};\n", + "\\end{pgfonlayer}{0}\n", + "\n", + "layer = \n", + "Layer: \n", + "% Layer 1\n", + "\\begin{pgfonlayer}{1}\n", + "\\node[shape=rectangle, draw=red, fill=white] (B) at (2, 2) {$a^2 + b^2 = c^2$};\n", + "\\end{pgfonlayer}{1}\n", + "\n", + "layer = \n", + "Layer: \n", + "% Layer -10\n", + "\\begin{pgfonlayer}{-10}\n", + "\\node[shape=rectangle, draw=red, fill=red] (node3) at (-1, 5) {};\n", + "\\end{pgfonlayer}{-10}\n", + "\n", + "layer = \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "Layer: \n", + "% Layer -5\n", + "\\begin{pgfonlayer}{-5}\n", + "\\draw[color=green, style=solid, line width=2] (A) to (B) to (C) to (A) to (node3);\n", + "\\end{pgfonlayer}{-5}\n", + "\n", + "[, , , ]\n", + "{'_x': -5, '_y': 0, '_z': None, '_ndim': 2, '_content': 'Origin node', '_label': 'A', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue!20'}}\n", + "{'_x': 2, '_y': 5, '_z': None, '_ndim': 2, '_content': '', '_label': 'C', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'rectangle', 'draw': 'red', 'fill': 'red'}}\n", + "{'_x': 2, '_y': 2, '_z': None, '_ndim': 2, '_content': '$a^2 + b^2 = c^2$', '_label': 'B', '_comment': None, '_layer': 1, '_options': [], '_kwargs': {'shape': 'rectangle', 'draw': 'red', 'fill': 'white'}}\n", + "{'_x': -1, '_y': 5, '_z': None, '_ndim': 2, '_content': '', '_label': 'node3', '_comment': None, '_layer': -10, '_options': [], '_kwargs': {'shape': 'rectangle', 'draw': 'red', 'fill': 'red'}}\n", + "yo2\n", + "yo\n", + "yo2\n" + ] + }, + { + "data": { + "text/plain": [ + "(
,\n", + " array([[, ]],\n", + " dtype=object))" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Ignoring fixed y limits to fulfill fixed data aspect with adjustable data limits.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "c = Canvas(ncols=2, width=\"20cm\", ratio=0.5)\n", "tikz = c.add_tikzfigure(grid=False)\n", "\n", "# Add nodes\n", "node_a = tikz.add_node(\n", - " -5, 0, \"A\", content=\"Origin node\", shape=\"circle\", draw=\"black\", fill=\"blue!20\"\n", + " -5,\n", + " 0,\n", + " label=\"A\",\n", + " content=\"Origin node\",\n", + " shape=\"circle\",\n", + " draw=\"black\",\n", + " fill=\"blue!20\",\n", ")\n", "tikz.add_node(\n", " 2,\n", " 2,\n", - " \"B\",\n", + " label=\"B\",\n", " content=\"$a^2 + b^2 = c^2$\",\n", " shape=\"rectangle\",\n", " draw=\"red\",\n", " fill=\"white\",\n", " layer=1,\n", ")\n", - "tikz.add_node(2, 5, \"C\", shape=\"rectangle\", draw=\"red\", fill=\"red\")\n", + "tikz.add_node(2, 5, label=\"C\", shape=\"rectangle\", draw=\"red\", fill=\"red\")\n", "last_node = tikz.add_node(-1, 5, shape=\"rectangle\", draw=\"red\", fill=\"red\", layer=-10)\n", "\n", - "# Add a line between nodes\n", - "tikz.add_path(\n", + "# # Add a line between nodes\n", + "tikz.draw(\n", " [node_a.label, \"B\", \"C\", \"A\", last_node],\n", " color=\"green\",\n", " style=\"solid\",\n", @@ -122,7 +215,31 @@ "execution_count": null, "id": "4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\documentclass[border=10pt]{standalone}\n", + "\\usepackage{tikz}\n", + "\\begin{document}\n", + "\\begin{tikzpicture}\n", + " % Define the layers library\n", + " \\pgfdeclarelayer{0}\n", + " \\pgfsetlayers{0}\n", + " \n", + " % Layer 0\n", + " \\begin{pgfonlayer}{0}\n", + " \\node (A) at (0, 0) {};\n", + " \\node (B) at (10, 0) {};\n", + " \\draw[->, out=30] (A.center) to (B.center);\n", + " \\end{pgfonlayer}{0}\n", + "\\end{tikzpicture}\n", + "\n", + "\\end{document}\n" + ] + } + ], "source": [ "c = Canvas(width=800, ratio=0.5)\n", "tikz = c.add_tikzfigure(grid=False)\n", diff --git a/tutorials/tutorial_06.ipynb b/tutorials/tutorial_06.ipynb index 6aeed04..514274a 100644 --- a/tutorials/tutorial_06.ipynb +++ b/tutorials/tutorial_06.ipynb @@ -16,7 +16,6 @@ "outputs": [], "source": [ "from maxplotlib import Canvas\n", - "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "%load_ext autoreload\n", From a2e4270f5af7c42678901f2f79c33dbef56c3b0d Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 25 Jan 2026 22:01:02 +0100 Subject: [PATCH 06/16] Generate mpl figure from tikzpics figure --- src/maxplotlib/backends/matplotlib/utils.py | 1 - src/maxplotlib/canvas/canvas.py | 79 +------------------ src/maxplotlib/subfigure/line_plot.py | 1 - tutorials/tutorial_02.ipynb | 85 +++++++++++---------- 4 files changed, 44 insertions(+), 122 deletions(-) diff --git a/src/maxplotlib/backends/matplotlib/utils.py b/src/maxplotlib/backends/matplotlib/utils.py index 827fef1..6d9080b 100644 --- a/src/maxplotlib/backends/matplotlib/utils.py +++ b/src/maxplotlib/backends/matplotlib/utils.py @@ -62,7 +62,6 @@ def _2pt(width, dpi=300): elif isinstance(width, str): length_in = convert_to_inches(width) length_pt = length_in * dpi - # print(f"{length_in = } {length_pt = }") return length_pt else: raise NotImplementedError diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index 67376cf..98e2c87 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -333,12 +333,10 @@ def plot_matplotlib(self, savefig=False, layers=None, usetex=False): for (row, col), subplot in self.subplots.items(): ax = axes[row][col] - print("yo") if isinstance(subplot, TikzFigure): plot_matplotlib(subplot, ax, layers=layers) else: subplot.plot_matplotlib(ax, layers=layers) - print("yo2") # ax.set_title(f"Subplot ({row}, {col})") ax.grid() @@ -507,76 +505,6 @@ def __setitem__(self, key, value): raise IndexError("Subplot index out of range") self._subplot_matrix[row][col] = value - # def generate_matplotlib_code(self): - # """Generate code for plotting the data using matplotlib.""" - # code = "import matplotlib.pyplot as plt\n\n" - # code += f"fig, axes = plt.subplots({self.nrows}, {self.ncols}, figsize={self.figsize})\n\n" - # if self.nrows == 1 and self.ncols == 1: - # code += "axes = [axes] # Single subplot\n\n" - # else: - # code += "axes = axes.flatten()\n\n" - # for idx, (subplot_idx, lines) in enumerate(self.subplots.items()): - # code += f"# Subplot {subplot_idx}\n" - # code += f"ax = axes[{idx}]\n" - # for line in lines: - # x_data = line['x'] - # y_data = line['y'] - # label = line['label'] - # kwargs = line.get('kwargs', {}) - # kwargs_str = ', '.join(f"{k}={repr(v)}" for k, v in kwargs.items()) - # code += f"ax.plot({x_data}, {y_data}, label={repr(label)}" - # if kwargs_str: - # code += f", {kwargs_str}" - # code += ")\n" - # code += "ax.set_xlabel('X-axis')\n" - # code += "ax.set_ylabel('Y-axis')\n" - # if self.nrows * self.ncols > 1: - # code += f"ax.set_title('Subplot {subplot_idx}')\n" - # code += "ax.legend()\n\n" - # code += "plt.tight_layout()\nplt.show()\n" - # return code - - # def generate_latex_plot(self): - # """Generate LaTeX code for plotting the data using pgfplots in subplots.""" - # latex_code = "\\begin{figure}[h!]\n\\centering\n" - # total_subplots = self.nrows * self.ncols - # for idx in range(total_subplots): - # subplot_idx = divmod(idx, self.ncols) - # lines = self.subplots.get(subplot_idx, []) - # if not lines: - # continue # Skip empty subplots - # latex_code += "\\begin{subfigure}[b]{0.45\\textwidth}\n" - # latex_code += " \\begin{tikzpicture}\n" - # latex_code += " \\begin{axis}[\n" - # latex_code += " xlabel={X-axis},\n" - # latex_code += " ylabel={Y-axis},\n" - # if self.nrows * self.ncols > 1: - # latex_code += f" title={{Subplot {subplot_idx}}},\n" - # latex_code += " legend style={at={(1.05,1)}, anchor=north west},\n" - # latex_code += " legend entries={" + ", ".join(f"{{{line['label']}}}" for line in lines) + "}\n" - # latex_code += " ]\n" - # for line in lines: - # options = [] - # kwargs = line.get('kwargs', {}) - # if 'color' in kwargs: - # options.append(f"color={kwargs['color']}") - # if 'linestyle' in kwargs: - # linestyle_map = {'-': 'solid', '--': 'dashed', '-.': 'dash dot', ':': 'dotted'} - # linestyle = linestyle_map.get(kwargs['linestyle'], kwargs['linestyle']) - # options.append(f"style={linestyle}") - # options_str = f"[{', '.join(options)}]" if options else "" - # latex_code += f" \\addplot {options_str} coordinates {{\n" - # for x, y in zip(line['x'], line['y']): - # latex_code += f" ({x}, {y})\n" - # latex_code += " };\n" - # latex_code += " \\end{axis}\n" - # latex_code += " \\end{tikzpicture}\n" - # latex_code += "\\end{subfigure}\n" - # latex_code += "\\hfill\n" if (idx + 1) % self.ncols != 0 else "\n" - # latex_code += "\\caption{Multiple Subplots}\n" - # latex_code += "\\end{figure}\n" - # return latex_code - def plot_matplotlib(tikzfigure: TikzFigure, ax, layers=None): """ @@ -586,15 +514,10 @@ def plot_matplotlib(tikzfigure: TikzFigure, ax, layers=None): - ax (matplotlib.axes.Axes): Axis on which to plot the figure. """ - # Plot paths first so they appear behind nodes - for key, layer in tikzfigure.layers.layers.items(): - print(f"{layer = }") - print(f"Layer: {layer.generate_tikz()}") - # TODO: Specify which layers to retreive nodes from with layers=layers nodes = tikzfigure.layers.get_nodes() paths = tikzfigure.layers.get_paths() - print(nodes) + for path in paths: x_coords = [node.x for node in path.nodes] diff --git a/src/maxplotlib/subfigure/line_plot.py b/src/maxplotlib/subfigure/line_plot.py index 99b73b4..31d43f5 100644 --- a/src/maxplotlib/subfigure/line_plot.py +++ b/src/maxplotlib/subfigure/line_plot.py @@ -300,7 +300,6 @@ def add_node( if layer in self.layers: self.layers[layer].add(node) else: - # print(f"{self.layers = } {layer = }") self.layers[layer] = Tikzlayer(layer) self.layers[layer].add(node) self._node_counter += 1 diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index 6161546..26bd670 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -10,16 +10,19 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "1", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", + "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", + "\u001b[1;31mClick here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." ] } ], @@ -32,20 +35,30 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "2", "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "'TikzFigure' object has no attribute 'add_path'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 12\u001b[39m\n\u001b[32m 8\u001b[39m tikz.add_node(\u001b[32m0\u001b[39m, \u001b[32m1\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mD\u001b[39m\u001b[33m\"\u001b[39m, shape=\u001b[33m\"\u001b[39m\u001b[33mcircle\u001b[39m\u001b[33m\"\u001b[39m, draw=\u001b[33m\"\u001b[39m\u001b[33mblack\u001b[39m\u001b[33m\"\u001b[39m, fill=\u001b[33m\"\u001b[39m\u001b[33mblue\u001b[39m\u001b[33m\"\u001b[39m, layer=\u001b[32m2\u001b[39m)\n\u001b[32m 11\u001b[39m \u001b[38;5;66;03m# Add a line between nodes\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m12\u001b[39m \u001b[43mtikz\u001b[49m\u001b[43m.\u001b[49m\u001b[43madd_path\u001b[49m(\n\u001b[32m 13\u001b[39m [\u001b[33m\"\u001b[39m\u001b[33mA\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mB\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mC\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mD\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 14\u001b[39m path_actions=[\u001b[33m\"\u001b[39m\u001b[33mdraw\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mrounded corners\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 15\u001b[39m fill=\u001b[33m\"\u001b[39m\u001b[33mred\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 16\u001b[39m opacity=\u001b[32m1.0\u001b[39m,\n\u001b[32m 17\u001b[39m cycle=\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[32m 18\u001b[39m layer=\u001b[32m1\u001b[39m,\n\u001b[32m 19\u001b[39m )\n\u001b[32m 21\u001b[39m tikz.add_node(\u001b[32m0.5\u001b[39m, \u001b[32m0.5\u001b[39m, content=\u001b[33m\"\u001b[39m\u001b[33mCube\u001b[39m\u001b[33m\"\u001b[39m, layer=\u001b[32m10\u001b[39m)\n\u001b[32m 23\u001b[39m \u001b[38;5;66;03m# tikz.compile_pdf(\"tutorial_02_01.pdf\")\u001b[39;00m\n\u001b[32m 24\u001b[39m \u001b[38;5;66;03m#\u001b[39;00m\n", - "\u001b[31mAttributeError\u001b[39m: 'TikzFigure' object has no attribute 'add_path'" + "name": "stdout", + "output_type": "stream", + "text": [ + "{'_x': 0, '_y': 0, '_z': None, '_ndim': 2, '_content': '', '_label': 'A', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", + "{'_x': 1, '_y': 0, '_z': None, '_ndim': 2, '_content': '', '_label': 'B', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", + "{'_x': 1, '_y': 1, '_z': None, '_ndim': 2, '_content': '', '_label': 'C', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", + "{'_x': 0, '_y': 1, '_z': None, '_ndim': 2, '_content': '', '_label': 'D', '_comment': None, '_layer': 2, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", + "{'_x': 0.5, '_y': 0.5, '_z': None, '_ndim': 2, '_content': 'Cube', '_label': 'node4', '_comment': None, '_layer': 10, '_options': [], '_kwargs': {}}\n" ] + }, + { + "data": { + "text/plain": [ + "(
, array([[]], dtype=object))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -53,14 +66,14 @@ "tikz = c.add_tikzfigure(grid=False)\n", "\n", "# Add nodes\n", - "tikz.add_node(0, 0, \"A\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(1, 0, \"B\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(1, 1, \"C\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(0, 1, \"D\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=2)\n", + "tikz.add_node(0, 0, label = \"A\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(1, 0, label = \"B\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(1, 1, label = \"C\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(0, 1, label = \"D\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=2)\n", "\n", "\n", "# Add a line between nodes\n", - "tikz.add_path(\n", + "tikz.draw(\n", " [\"A\", \"B\", \"C\", \"D\"],\n", " path_actions=[\"draw\", \"rounded corners\"],\n", " fill=\"red\",\n", @@ -72,12 +85,12 @@ "tikz.add_node(0.5, 0.5, content=\"Cube\", layer=10)\n", "\n", "# tikz.compile_pdf(\"tutorial_02_01.pdf\")\n", - "#" + "c.plot(backend=\"matplotlib\")" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "id": "3", "metadata": {}, "outputs": [ @@ -217,26 +230,14 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "\\documentclass[border=10pt]{standalone}\n", - "\\usepackage{tikz}\n", - "\\begin{document}\n", - "\\begin{tikzpicture}\n", - " % Define the layers library\n", - " \\pgfdeclarelayer{0}\n", - " \\pgfsetlayers{0}\n", - " \n", - " % Layer 0\n", - " \\begin{pgfonlayer}{0}\n", - " \\node (A) at (0, 0) {};\n", - " \\node (B) at (10, 0) {};\n", - " \\draw[->, out=30] (A.center) to (B.center);\n", - " \\end{pgfonlayer}{0}\n", - "\\end{tikzpicture}\n", - "\n", - "\\end{document}\n" + "ename": "NameError", + "evalue": "name 'Canvas' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m c = \u001b[43mCanvas\u001b[49m(width=\u001b[32m800\u001b[39m, ratio=\u001b[32m0.5\u001b[39m)\n\u001b[32m 2\u001b[39m tikz = c.add_tikzfigure(grid=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# Add nodes\u001b[39;00m\n", + "\u001b[31mNameError\u001b[39m: name 'Canvas' is not defined" ] } ], From 830d1eb960ed13235ce43f7a8f86764a7a2da9f9 Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 25 Jan 2026 22:03:13 +0100 Subject: [PATCH 07/16] Cleanup --- src/maxplotlib/canvas/canvas.py | 1 - tutorials/tutorial_02.ipynb | 135 ++++---------------------------- 2 files changed, 16 insertions(+), 120 deletions(-) diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index 98e2c87..b9eb927 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -560,7 +560,6 @@ def plot_matplotlib(tikzfigure: TikzFigure, ax, layers=None): # Plot nodes after paths so they appear on top for node in nodes: - print(node.__dict__) # Determine shape and size shape = node.kwargs.get("shape", "circle") fill_color_spec = node.kwargs.get("fill", "white") diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index 26bd670..e877a3e 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -10,22 +10,10 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "1", "metadata": {}, - "outputs": [ - { - "ename": "", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", - "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", - "\u001b[1;31mClick here for more info. \n", - "\u001b[1;31mView Jupyter log for further details." - ] - } - ], + "outputs": [], "source": [ "from maxplotlib import Canvas\n", "\n", @@ -35,21 +23,10 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "2", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'_x': 0, '_y': 0, '_z': None, '_ndim': 2, '_content': '', '_label': 'A', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", - "{'_x': 1, '_y': 0, '_z': None, '_ndim': 2, '_content': '', '_label': 'B', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", - "{'_x': 1, '_y': 1, '_z': None, '_ndim': 2, '_content': '', '_label': 'C', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", - "{'_x': 0, '_y': 1, '_z': None, '_ndim': 2, '_content': '', '_label': 'D', '_comment': None, '_layer': 2, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue'}}\n", - "{'_x': 0.5, '_y': 0.5, '_z': None, '_ndim': 2, '_content': 'Cube', '_label': 'node4', '_comment': None, '_layer': 10, '_options': [], '_kwargs': {}}\n" - ] - }, { "data": { "text/plain": [ @@ -59,6 +36,17 @@ "execution_count": 2, "metadata": {}, "output_type": "execute_result" + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", + "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", + "\u001b[1;31mClick here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." + ] } ], "source": [ @@ -93,86 +81,7 @@ "execution_count": null, "id": "3", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "yo\n", - "layer = \n", - "Layer: \n", - "% Layer 0\n", - "\\begin{pgfonlayer}{0}\n", - "\\node[shape=circle, draw=black, fill=blue!20] (A) at (-5, 0) {Origin node};\n", - "\\node[shape=rectangle, draw=red, fill=red] (C) at (2, 5) {};\n", - "\\end{pgfonlayer}{0}\n", - "\n", - "layer = \n", - "Layer: \n", - "% Layer 1\n", - "\\begin{pgfonlayer}{1}\n", - "\\node[shape=rectangle, draw=red, fill=white] (B) at (2, 2) {$a^2 + b^2 = c^2$};\n", - "\\end{pgfonlayer}{1}\n", - "\n", - "layer = \n", - "Layer: \n", - "% Layer -10\n", - "\\begin{pgfonlayer}{-10}\n", - "\\node[shape=rectangle, draw=red, fill=red] (node3) at (-1, 5) {};\n", - "\\end{pgfonlayer}{-10}\n", - "\n", - "layer = \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "Layer: \n", - "% Layer -5\n", - "\\begin{pgfonlayer}{-5}\n", - "\\draw[color=green, style=solid, line width=2] (A) to (B) to (C) to (A) to (node3);\n", - "\\end{pgfonlayer}{-5}\n", - "\n", - "[, , , ]\n", - "{'_x': -5, '_y': 0, '_z': None, '_ndim': 2, '_content': 'Origin node', '_label': 'A', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'circle', 'draw': 'black', 'fill': 'blue!20'}}\n", - "{'_x': 2, '_y': 5, '_z': None, '_ndim': 2, '_content': '', '_label': 'C', '_comment': None, '_layer': 0, '_options': [], '_kwargs': {'shape': 'rectangle', 'draw': 'red', 'fill': 'red'}}\n", - "{'_x': 2, '_y': 2, '_z': None, '_ndim': 2, '_content': '$a^2 + b^2 = c^2$', '_label': 'B', '_comment': None, '_layer': 1, '_options': [], '_kwargs': {'shape': 'rectangle', 'draw': 'red', 'fill': 'white'}}\n", - "{'_x': -1, '_y': 5, '_z': None, '_ndim': 2, '_content': '', '_label': 'node3', '_comment': None, '_layer': -10, '_options': [], '_kwargs': {'shape': 'rectangle', 'draw': 'red', 'fill': 'red'}}\n", - "yo2\n", - "yo\n", - "yo2\n" - ] - }, - { - "data": { - "text/plain": [ - "(
,\n", - " array([[, ]],\n", - " dtype=object))" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Ignoring fixed y limits to fulfill fixed data aspect with adjustable data limits.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "c = Canvas(ncols=2, width=\"20cm\", ratio=0.5)\n", "tikz = c.add_tikzfigure(grid=False)\n", @@ -228,19 +137,7 @@ "execution_count": null, "id": "4", "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'Canvas' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m c = \u001b[43mCanvas\u001b[49m(width=\u001b[32m800\u001b[39m, ratio=\u001b[32m0.5\u001b[39m)\n\u001b[32m 2\u001b[39m tikz = c.add_tikzfigure(grid=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# Add nodes\u001b[39;00m\n", - "\u001b[31mNameError\u001b[39m: name 'Canvas' is not defined" - ] - } - ], + "outputs": [], "source": [ "c = Canvas(width=800, ratio=0.5)\n", "tikz = c.add_tikzfigure(grid=False)\n", From 1e6bf11ff97ec0125884b24b97771293756f66e9 Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:10:25 +0100 Subject: [PATCH 08/16] Formatting --- src/maxplotlib/canvas/canvas.py | 12 +++--------- src/maxplotlib/subfigure/tikz_figure.py | 11 +++++++++-- tutorials/tutorial_02.ipynb | 8 ++++---- 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index b9eb927..5e5471f 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -287,7 +287,7 @@ def show( self.plot(backend="matplotlib", savefig=False, layers=None) self._matplotlib_fig.show() elif backend == "plotly": - plot = self.plot_plotly(savefig=False) + self.plot_plotly(savefig=False) elif backend == "tikzpics": fig = self.plot_tikzpics(savefig=False) fig.show() @@ -321,14 +321,12 @@ def plot_matplotlib(self, savefig=False, layers=None, usetex=False): dpi=self.dpi, ) - # print(f"{(fig_width / self._dpi, fig_height / self._dpi) = }") - fig, axes = plt.subplots( self.nrows, self.ncols, figsize=(fig_width, fig_height), squeeze=False, - dpi=self._dpi, + dpi=self.dpi, ) for (row, col), subplot in self.subplots.items(): @@ -371,7 +369,7 @@ def plot_plotly(self, show=True, savefig=None, usetex=False): savefig (str, optional): Filename to save the figure if provided. """ - tex_fonts = setup_tex_fonts( + setup_tex_fonts( fontsize=self.fontsize, usetex=usetex, ) # adjust or redefine for Plotly if needed @@ -456,9 +454,6 @@ def subplot_matrix(self): return self._subplot_matrix # Property setters - @nrows.setter - def dpi(self, value): - self._dpi = value @nrows.setter def nrows(self, value): @@ -518,7 +513,6 @@ def plot_matplotlib(tikzfigure: TikzFigure, ax, layers=None): nodes = tikzfigure.layers.get_nodes() paths = tikzfigure.layers.get_paths() - for path in paths: x_coords = [node.x for node in path.nodes] y_coords = [node.y for node in path.nodes] diff --git a/src/maxplotlib/subfigure/tikz_figure.py b/src/maxplotlib/subfigure/tikz_figure.py index b878b4f..187e486 100644 --- a/src/maxplotlib/subfigure/tikz_figure.py +++ b/src/maxplotlib/subfigure/tikz_figure.py @@ -274,14 +274,21 @@ def generate_tikz(self): reqs = layer.get_reqs() if all([r == layer.label for r in reqs]): ordered_layers.append(layer) - elif all([r in [l.label for l in ordered_layers] for r in reqs]): + elif all( + [_req in [_lay.label for _lay in ordered_layers] for _req in reqs] + ): ordered_layers.append(layer) else: buffered_layers.add(layer) for buffered_layer in buffered_layers: buff_reqs = buffered_layer.get_reqs() - if all([r in [l.label for l in ordered_layers] for r in buff_reqs]): + if all( + [ + _req in [_lay.label for _lay in ordered_layers] + for _req in buff_reqs + ] + ): print("Move layer from buffer") ordered_layers.append(key) buffered_layers.remove(key) diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index e877a3e..bfb0bd6 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -54,10 +54,10 @@ "tikz = c.add_tikzfigure(grid=False)\n", "\n", "# Add nodes\n", - "tikz.add_node(0, 0, label = \"A\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(1, 0, label = \"B\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(1, 1, label = \"C\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(0, 1, label = \"D\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=2)\n", + "tikz.add_node(0, 0, label=\"A\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(1, 0, label=\"B\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(1, 1, label=\"C\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(0, 1, label=\"D\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=2)\n", "\n", "\n", "# Add a line between nodes\n", From e1b339914733e4168fc4ac2a4210829e3947708c Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:13:04 +0100 Subject: [PATCH 09/16] Use tikzpics>=0.1.1 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 902de0f..247957e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -18,7 +18,7 @@ dependencies = [ "matplotlib", "pint", "plotly", - "tikzpics", + "tikzpics>=0.1.1", ] [project.optional-dependencies] test = [ From 732f5a1a38265cba845358a944b0e66165eae53d Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:29:32 +0100 Subject: [PATCH 10/16] Removed tikz related code --- src/maxplotlib/objects/layer.py | 20 - src/maxplotlib/subfigure/line_plot.py | 73 ---- src/maxplotlib/subfigure/tikz_figure.py | 502 ------------------------ tutorials/tutorial_02.ipynb | 31 +- tutorials/tutorial_04.ipynb | 139 +++++-- tutorials/tutorial_05.ipynb | 2 +- 6 files changed, 131 insertions(+), 636 deletions(-) delete mode 100644 src/maxplotlib/objects/layer.py delete mode 100644 src/maxplotlib/subfigure/tikz_figure.py diff --git a/src/maxplotlib/objects/layer.py b/src/maxplotlib/objects/layer.py deleted file mode 100644 index c747b9f..0000000 --- a/src/maxplotlib/objects/layer.py +++ /dev/null @@ -1,20 +0,0 @@ -from abc import ABCMeta - - -class Layer(metaclass=ABCMeta): - def __init__(self, label): - self.label = label - self.items = [] - - -class Tikzlayer(Layer): - def __init__(self, label): - super().__init__(label) - - def generate_tikz(self): - tikz_script = f"\n% Layer {self.label}\n" - tikz_script += f"\\begin{{pgfonlayer}}{{{self.label}}}\n" - for item in self.items: - tikz_script += item.to_tikz() - tikz_script += f"\\end{{pgfonlayer}}{{{self.label}}}\n" - return tikz_script diff --git a/src/maxplotlib/subfigure/line_plot.py b/src/maxplotlib/subfigure/line_plot.py index 31d43f5..8a50cfc 100644 --- a/src/maxplotlib/subfigure/line_plot.py +++ b/src/maxplotlib/subfigure/line_plot.py @@ -4,8 +4,6 @@ from mpl_toolkits.axes_grid1 import make_axes_locatable from tikzpics import TikzFigure -from maxplotlib.objects.layer import Tikzlayer - class Node: def __init__(self, x, y, label="", content="", layer=0, **kwargs): @@ -270,77 +268,6 @@ def plot_plotly(self): return traces - # def plot_tikzpics(self): - - def add_node( - self, - x: int | float, - y: int | float, - label: str | None = None, - content: str = "", - layer=0, - **kwargs, - ): - """ - Add a node to the TikZ figure. - - Parameters: - - x (float): X-coordinate of the node. - - y (float): Y-coordinate of the node. - - label (str, optional): Label of the node. If None, a default label will be assigned. - - **kwargs: Additional TikZ node options (e.g., shape, color). - - Returns: - - node (Node): The Node object that was added. - """ - if label is None: - label = f"node{self._node_counter}" - node = Node(x=x, y=y, label=label, layer=layer, content=content, **kwargs) - self.nodes.append(node) - if layer in self.layers: - self.layers[layer].add(node) - else: - self.layers[layer] = Tikzlayer(layer) - self.layers[layer].add(node) - self._node_counter += 1 - return node - - def add_path(self, nodes, layer=0, **kwargs): - """ - Add a line or path connecting multiple nodes. - - Parameters: - - nodes (list of str): List of node names to connect. - - **kwargs: Additional TikZ path options (e.g., style, color). - - Examples: - - add_path(['A', 'B', 'C'], color='blue') - Connects nodes A -> B -> C with a blue line. - """ - if not isinstance(nodes, list): - raise ValueError("nodes parameter must be a list of node names.") - - nodes = [ - ( - node - if isinstance(node, Node) - else ( - self.get_node(node) - if isinstance(node, str) - else ValueError(f"Invalid node type: {type(node)}") - ) - ) - for node in nodes - ] - path = Path(nodes, **kwargs) - self.paths.append(path) - if layer in self.layers: - self.layers[layer].add(path) - else: - self.layers[layer] = Tikzlayer(layer) - self.layers[layer].add(path) - return path - @property def xmin(self): return self._xmin diff --git a/src/maxplotlib/subfigure/tikz_figure.py b/src/maxplotlib/subfigure/tikz_figure.py deleted file mode 100644 index 187e486..0000000 --- a/src/maxplotlib/subfigure/tikz_figure.py +++ /dev/null @@ -1,502 +0,0 @@ -import os -import re -import subprocess -import tempfile - -import matplotlib.patches as patches - -from maxplotlib.colors.colors import Color -from maxplotlib.linestyle.linestyle import Linestyle - - -class Tikzlayer: - def __init__(self, label): - self.label = label - self.items = [] - - def add(self, item): - self.items.append(item) - - def get_reqs(self): - reqs = set() - for item in self.items: - if isinstance(item, Path): - for node in item.nodes: - if not node.layer == self.label: - reqs.add(node.layer) - return reqs - - def generate_tikz(self): - tikz_script = f"\n% Layer {self.label}\n" - tikz_script += f"\\begin{{pgfonlayer}}{{{self.label}}}\n" - for item in self.items: - tikz_script += item.to_tikz() - tikz_script += f"\\end{{pgfonlayer}}{{{self.label}}}\n" - return tikz_script - - -class TikzWrapper: - def __init__(self, raw_tikz, label="", content="", layer=0, **kwargs): - self.raw_tikz = raw_tikz - self.label = label - self.content = content - self.layer = layer - self.options = kwargs - - def to_tikz(self): - return self.raw_tikz - - -class Node: - def __init__(self, x, y, label="", content="", layer=0, **kwargs): - """ - Represents a TikZ node. - - Parameters: - - x (float): X-coordinate of the node. - - y (float): Y-coordinate of the node. - - name (str, optional): Name of the node. If None, a default name will be assigned. - - **kwargs: Additional TikZ node options (e.g., shape, color). - """ - self.x = x - self.y = y - self.label = label - self.content = content - self.layer = layer - self.options = kwargs - - def to_tikz(self): - """ - Generate the TikZ code for this node. - - Returns: - - tikz_str (str): TikZ code string for the node. - """ - options = ", ".join( - f"{k.replace('_', ' ')}={v}" for k, v in self.options.items() - ) - if options: - options = f"[{options}]" - return f"\\node{options} ({self.label}) at ({self.x}, {self.y}) {{{self.content}}};\n" - - -class Path: - def __init__( - self, - nodes, - path_actions=[], - cycle=False, - label="", - layer=0, - **kwargs, - ): - """ - Represents a path (line) connecting multiple nodes. - - Parameters: - - nodes (list of str): List of node names to connect. - - **kwargs: Additional TikZ path options (e.g., style, color). - """ - self.nodes = nodes - self.path_actions = path_actions - self.cycle = cycle - self.layer = layer - self.label = label - self.options = kwargs - - def to_tikz(self): - """ - Generate the TikZ code for this path. - - Returns: - - tikz_str (str): TikZ code string for the path. - """ - options = ", ".join( - f"{k.replace('_', ' ')}={v}" for k, v in self.options.items() - ) - if len(self.path_actions) > 0: - options = ", ".join(self.path_actions) + ", " + options - if options: - options = f"[{options}]" - path_str = " to ".join(f"({node.label}.center)" for node in self.nodes) - if self.cycle: - path_str += " -- cycle" - return f"\\draw{options} {path_str};\n" - - -class TikzFigure: - def __init__(self, **kwargs): - """ - Initialize the TikzFigure class for creating TikZ figures. - - Parameters: - **kwargs: Arbitrary keyword arguments. - - figsize (tuple): Figure size (default is (10, 6)). - - caption (str): Caption for the figure. - - description (str): Description of the figure. - - label (str): Label for the figure. - - grid (bool): Whether to display grid lines (default is False). - TODO: Add all options - """ - # Set default values - self._figsize = kwargs.get("figsize", (10, 6)) - self._caption = kwargs.get("caption", None) - self._description = kwargs.get("description", None) - self._label = kwargs.get("label", None) - self._grid = kwargs.get("grid", False) - - # Initialize lists to hold Node and Path objects - self.nodes = [] - self.paths = [] - self.layers = {} - - # Counter for unnamed nodes - self._node_counter = 0 - - def add_node(self, x, y, label=None, content="", layer=0, **kwargs): - """ - Add a node to the TikZ figure. - - Parameters: - - x (float): X-coordinate of the node. - - y (float): Y-coordinate of the node. - - label (str, optional): Label of the node. If None, a default label will be assigned. - - **kwargs: Additional TikZ node options (e.g., shape, color). - - Returns: - - node (Node): The Node object that was added. - """ - if label is None: - label = f"node{self._node_counter}" - node = Node(x=x, y=y, label=label, layer=layer, content=content, **kwargs) - self.nodes.append(node) - if layer in self.layers: - self.layers[layer].add(node) - else: - self.layers[layer] = Tikzlayer(layer) - self.layers[layer].add(node) - self._node_counter += 1 - return node - - def add_path(self, nodes, layer=0, **kwargs): - """ - Add a line or path connecting multiple nodes. - - Parameters: - - nodes (list of str): List of node names to connect. - - **kwargs: Additional TikZ path options (e.g., style, color). - - Examples: - - add_path(['A', 'B', 'C'], color='blue') - Connects nodes A -> B -> C with a blue line. - """ - if not isinstance(nodes, list): - raise ValueError("nodes parameter must be a list of node names.") - - nodes = [ - ( - node - if isinstance(node, Node) - else ( - self.get_node(node) - if isinstance(node, str) - else ValueError(f"Invalid node type: {type(node)}") - ) - ) - for node in nodes - ] - path = Path(nodes, **kwargs) - self.paths.append(path) - if layer in self.layers: - self.layers[layer].add(path) - else: - self.layers[layer] = Tikzlayer(layer) - self.layers[layer].add(path) - return path - - def add_raw(self, raw_tikz, layer=0, **kwargs): - tikz = TikzWrapper(raw_tikz) - if layer in self.layers: - self.layers[layer].add(tikz) - else: - self.layers[layer] = Tikzlayer(layer) - self.layers[layer].add(tikz) - return tikz - - def get_node(self, node_label): - for node in self.nodes: - if node.label == node_label: - return node - - def get_layer(self, item): - for layer, layer_items in self.layers.items(): - if item in [layer_item.label for layer_item in layer_items]: - return layer - print(f"Item {item} not found in any layer!") - - def add_tabs(self, tikz_script): - tikz_script_new = "" - tab_str = " " - num_tabs = 0 - for line in tikz_script.split("\n"): - if "\\end" in line: - num_tabs = max(num_tabs - 1, 0) - tikz_script_new += f"{tab_str*num_tabs}{line}\n" - if "\\begin" in line: - num_tabs += 1 - return tikz_script_new - - def generate_tikz(self): - """ - Generate the TikZ script for the figure. - - Returns: - - tikz_script (str): The TikZ script as a string. - """ - tikz_script = "\\begin{tikzpicture}\n" - tikz_script += "% Define the layers library\n" - layers = sorted([str(layer) for layer in self.layers.keys()]) - for layer in layers: - tikz_script += f"\\pgfdeclarelayer{{{layer}}}\n" - tikz_script += f"\\pgfsetlayers{{{','.join(layers)}}}\n" - - # Add grid if enabled - # TODO: Create a Grid class - if self._grid: - tikz_script += ( - " \\draw[step=1cm, gray, very thin] (-10,-10) grid (10,10);\n" - ) - ordered_layers = [] - buffered_layers = set() - - for key, layer in self.layers.items(): - # layer_order, buffered_layers = update_layer_order(layer, layer_order, buffered_layers) - reqs = layer.get_reqs() - if all([r == layer.label for r in reqs]): - ordered_layers.append(layer) - elif all( - [_req in [_lay.label for _lay in ordered_layers] for _req in reqs] - ): - ordered_layers.append(layer) - else: - buffered_layers.add(layer) - - for buffered_layer in buffered_layers: - buff_reqs = buffered_layer.get_reqs() - if all( - [ - _req in [_lay.label for _lay in ordered_layers] - for _req in buff_reqs - ] - ): - print("Move layer from buffer") - ordered_layers.append(key) - buffered_layers.remove(key) - assert ( - len(buffered_layers) == 0 - ), f"Layer order is impossible for layer {[layer.label for layer in buffered_layers]}" - for layer in ordered_layers: - tikz_script += layer.generate_tikz() - - tikz_script += "\\end{tikzpicture}" - - # Wrap in figure environment if necessary - if self._caption or self._description or self._label: - figure_env = "\\begin{figure}\n" + tikz_script + "\n" - if self._caption: - figure_env += f" \\caption{{{self._caption}}}\n" - if self._label: - figure_env += f" \\label{{{self._label}}}\n" - figure_env += "\\end{figure}" - tikz_script = figure_env - tikz_script = self.add_tabs(tikz_script) - return tikz_script - - def savefig(self, filepath): - tikz_code = self.generate_tikz() - with open(filepath, "w") as f: - f.write(tikz_code) - - def generate_standalone(self): - tikz_code = self.generate_tikz() - - # Create a minimal LaTeX document - latex_document = ( - "\\documentclass[border=10pt]{standalone}\n" - "\\usepackage{tikz}\n" - "\\begin{document}\n" - f"{tikz_code}\n" - "\\end{document}" - ) - return latex_document - - def compile_pdf(self, filename="output.pdf"): - """ - Compile the TikZ script into a PDF using pdflatex. - - Parameters: - - filename (str): The name of the output PDF file (default is 'output.pdf'). - - Notes: - - Requires 'pdflatex' to be installed and accessible from the command line. - """ - latex_document = self.generate_standalone() - - # Use a temporary directory to store the LaTeX files - with tempfile.TemporaryDirectory() as tempdir: - tex_file = os.path.join(tempdir, "figure.tex") - with open(tex_file, "w") as f: - f.write(latex_document) - - # Run pdflatex - try: - subprocess.run( - ["pdflatex", "-interaction=nonstopmode", tex_file], - cwd=tempdir, - check=True, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - ) - except subprocess.CalledProcessError as e: - print("An error occurred while compiling the LaTeX document:") - print(e.stderr.decode()) - return - - # Move the output PDF to the desired location - pdf_output = os.path.join(tempdir, "figure.pdf") - if os.path.exists(pdf_output): - os.rename(pdf_output, filename) - print(f"PDF successfully compiled and saved as '{filename}'.") - else: - print("PDF compilation failed. Please check the LaTeX log for details.") - - def plot_matplotlib(self, ax, layers=None): - """ - Plot all nodes and paths on the provided axis using Matplotlib. - - Parameters: - - ax (matplotlib.axes.Axes): Axis on which to plot the figure. - """ - - # Plot paths first so they appear behind nodes - for path in self.paths: - x_coords = [node.x for node in path.nodes] - y_coords = [node.y for node in path.nodes] - - # Parse path color - path_color_spec = path.options.get("color", "black") - try: - color = Color(path_color_spec).to_rgb() - except ValueError as e: - print(e) - color = "black" - - # Parse line width - line_width_spec = path.options.get("line_width", 1) - if isinstance(line_width_spec, str): - match = re.match(r"([\d.]+)(pt)?", line_width_spec) - if match: - line_width = float(match.group(1)) - else: - print( - f"Invalid line width specification: '{line_width_spec}', defaulting to 1", - ) - line_width = 1 - else: - line_width = float(line_width_spec) - - # Parse line style using Linestyle class - style_spec = path.options.get("style", "solid") - linestyle = Linestyle(style_spec).to_matplotlib() - - ax.plot( - x_coords, - y_coords, - color=color, - linewidth=line_width, - linestyle=linestyle, - zorder=1, # Lower z-order to place behind nodes - ) - - # Plot nodes after paths so they appear on top - for node in self.nodes: - # Determine shape and size - shape = node.options.get("shape", "circle") - fill_color_spec = node.options.get("fill", "white") - edge_color_spec = node.options.get("draw", "black") - linewidth = float(node.options.get("line_width", 1)) - size = float(node.options.get("size", 1)) - - # Parse colors using the Color class - try: - facecolor = Color(fill_color_spec).to_rgb() - except ValueError as e: - print(e) - facecolor = "white" - - try: - edgecolor = Color(edge_color_spec).to_rgb() - except ValueError as e: - print(e) - edgecolor = "black" - - # Plot shapes - if shape == "circle": - radius = size / 2 - circle = patches.Circle( - (node.x, node.y), - radius, - facecolor=facecolor, - edgecolor=edgecolor, - linewidth=linewidth, - zorder=2, # Higher z-order to place on top of paths - ) - ax.add_patch(circle) - elif shape == "rectangle": - width = height = size - rect = patches.Rectangle( - (node.x - width / 2, node.y - height / 2), - width, - height, - facecolor=facecolor, - edgecolor=edgecolor, - linewidth=linewidth, - zorder=2, # Higher z-order - ) - ax.add_patch(rect) - else: - # Default to circle if shape is unknown - radius = size / 2 - circle = patches.Circle( - (node.x, node.y), - radius, - facecolor=facecolor, - edgecolor=edgecolor, - linewidth=linewidth, - zorder=2, - ) - ax.add_patch(circle) - - # Add text inside the shape - if node.content: - ax.text( - node.x, - node.y, - node.content, - fontsize=10, - ha="center", - va="center", - wrap=True, - zorder=3, # Even higher z-order for text - ) - - # Remove axes, ticks, and legend - ax.axis("off") - - # Adjust plot limits - all_x = [node.x for node in self.nodes] - all_y = [node.y for node in self.nodes] - padding = 1 # Adjust padding as needed - ax.set_xlim(min(all_x) - padding, max(all_x) + padding) - ax.set_ylim(min(all_y) - padding, max(all_y) + padding) - ax.set_aspect("equal", adjustable="datalim") diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index bfb0bd6..e62be40 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -10,10 +10,22 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", + "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", + "\u001b[1;31mClick here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." + ] + } + ], "source": [ "from maxplotlib import Canvas\n", "\n", @@ -23,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "2", "metadata": {}, "outputs": [ @@ -36,17 +48,6 @@ "execution_count": 2, "metadata": {}, "output_type": "execute_result" - }, - { - "ename": "", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", - "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", - "\u001b[1;31mClick here for more info. \n", - "\u001b[1;31mView Jupyter log for further details." - ] } ], "source": [ @@ -148,7 +149,7 @@ "\n", "\n", "# Add a line between nodes\n", - "tikz.add_path([\"A\", \"B\"], path_actions=[\"->\"], out=30)\n", + "tikz.draw([\"A\", \"B\"], path_actions=[\"->\"], out=30)\n", "\n", "# Generate the TikZ script\n", "# script = tikz.generate_tikz()\n", diff --git a/tutorials/tutorial_04.ipynb b/tutorials/tutorial_04.ipynb index bf46f10..ef2dc8b 100644 --- a/tutorials/tutorial_04.ipynb +++ b/tutorials/tutorial_04.ipynb @@ -10,10 +10,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nTutorial 4.\\n\\nAdd raw tikz code to the tikz subplot.\\n'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "Tutorial 4.\n", @@ -24,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "2", "metadata": {}, "outputs": [], @@ -34,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "3", "metadata": {}, "outputs": [], @@ -45,29 +56,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "4", "metadata": { "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Add nodes\n", - "tikz.add_node(0, 0, \"A\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(10, 0, \"B\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(10, 10, \"C\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", - "tikz.add_node(0, 10, \"D\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=2)" + "tikz.add_node(0, 0, label=\"A\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(10, 0, label=\"B\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(10, 10, label=\"C\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=0)\n", + "tikz.add_node(0, 10, label=\"D\", shape=\"circle\", draw=\"black\", fill=\"blue\", layer=2)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Add a line between nodes\n", - "tikz.add_path(\n", + "tikz.draw(\n", " [\"A\", \"B\", \"C\", \"D\"],\n", " path_actions=[\"draw\", \"rounded corners\"],\n", " fill=\"red\",\n", @@ -79,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "6", "metadata": {}, "outputs": [], @@ -99,20 +132,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "7", "metadata": {}, "outputs": [], "source": [ - "tikz.add_raw(raw_tikz)" + "# TODO: Not implemented in tikzpics yet\n", + "# tikz.add_raw(raw_tikz)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "tikz.add_node(0.5, 0.5, content=\"Cube\", layer=10)" ] @@ -122,14 +167,58 @@ "execution_count": null, "id": "9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "% --------------------------------------------- %\n", + "% Tikzfigure generated by tikzpics v0.1.1 %\n", + "% https://github.com/max-models/tikzpics %\n", + "% --------------------------------------------- %\n", + "\\begin{tikzpicture}\n", + " \n", + " % Define the layers library\n", + " \\pgfdeclarelayer{0}\n", + " \\pgfdeclarelayer{1}\n", + " \\pgfdeclarelayer{10}\n", + " \\pgfdeclarelayer{2}\n", + " \\pgfsetlayers{0,1,10,2}\n", + " \n", + " % Layer 0\n", + " \\begin{pgfonlayer}{0}\n", + " \\node[shape=circle, draw=black, fill=blue] (A) at (0, 0) {};\n", + " \\node[shape=circle, draw=black, fill=blue] (B) at (10, 0) {};\n", + " \\node[shape=circle, draw=black, fill=blue] (C) at (10, 10) {};\n", + " \\end{pgfonlayer}{0}\n", + " \n", + " % Layer 2\n", + " \\begin{pgfonlayer}{2}\n", + " \\node[shape=circle, draw=black, fill=blue] (D) at (0, 10) {};\n", + " \\end{pgfonlayer}{2}\n", + " \n", + " % Layer 1\n", + " \\begin{pgfonlayer}{1}\n", + " \\draw[path actions=['draw', 'rounded corners'], fill=red, opacity=0.5] (A) to (B) to (C) to (D) -- cycle;\n", + " \\end{pgfonlayer}{1}\n", + " \n", + " % Layer 10\n", + " \\begin{pgfonlayer}{10}\n", + " \\node (node4) at (0.5, 0.5) {Cube};\n", + " \\end{pgfonlayer}{10}\n", + "\\end{tikzpicture}\n", + "\n" + ] + } + ], "source": [ "# Generate the TikZ script\n", "script = tikz.generate_tikz()\n", - "print(script)\n", - "# print(tikz.generate_standalone())\n", - "# tikz.compile_pdf(\"tutorial_04_01.pdf\")\n", - "#" + "print(script)" ] } ], @@ -140,7 +229,7 @@ "notebook_metadata_filter": "-all" }, "kernelspec": { - "display_name": "env_maxplotlib", + "display_name": "env_maxpic", "language": "python", "name": "python3" }, @@ -154,7 +243,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.13.3" } }, "nbformat": 4, diff --git a/tutorials/tutorial_05.ipynb b/tutorials/tutorial_05.ipynb index 55334f8..2f70552 100644 --- a/tutorials/tutorial_05.ipynb +++ b/tutorials/tutorial_05.ipynb @@ -44,7 +44,7 @@ "# last_node = sp.add_node(-1, 5, shape='rectangle', draw='red', fill='red', layer=-10)\n", "\n", "# Add a line between nodes\n", - "# sp.add_path([\"A\", \"B\"], color=\"green\", style=\"solid\", line_width=\"2\", layer=-5)\n", + "# sp.draw([\"A\", \"B\"], color=\"green\", style=\"solid\", line_width=\"2\", layer=-5)\n", "\n", "x = np.arange(0, 2 * np.pi, 0.01)\n", "y = np.sin(x)\n", From 59dea27d67a6eb3795740a0adc9854c376687a3b Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:37:59 +0100 Subject: [PATCH 11/16] bugfix --- tutorials/tutorial_02.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index e62be40..dec7e13 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -144,8 +144,8 @@ "tikz = c.add_tikzfigure(grid=False)\n", "\n", "# Add nodes\n", - "tikz.add_node(0, 0, \"A\")\n", - "tikz.add_node(10, 0, \"B\")\n", + "tikz.add_node(0, 0, label=\"A\")\n", + "tikz.add_node(10, 0, label=\"B\")\n", "\n", "\n", "# Add a line between nodes\n", From 90f96ff56f5a7f3d570cd29e92adafe441eab024 Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:39:04 +0100 Subject: [PATCH 12/16] Cleanup --- tutorials/tutorial_02.ipynb | 31 ++++--------------------------- 1 file changed, 4 insertions(+), 27 deletions(-) diff --git a/tutorials/tutorial_02.ipynb b/tutorials/tutorial_02.ipynb index dec7e13..f2e3528 100644 --- a/tutorials/tutorial_02.ipynb +++ b/tutorials/tutorial_02.ipynb @@ -13,19 +13,7 @@ "execution_count": null, "id": "1", "metadata": {}, - "outputs": [ - { - "ename": "", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", - "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", - "\u001b[1;31mClick here for more info. \n", - "\u001b[1;31mView Jupyter log for further details." - ] - } - ], + "outputs": [], "source": [ "from maxplotlib import Canvas\n", "\n", @@ -38,18 +26,7 @@ "execution_count": null, "id": "2", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(
, array([[]], dtype=object))" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "c = Canvas(width=800, ratio=0.5)\n", "tikz = c.add_tikzfigure(grid=False)\n", @@ -161,7 +138,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "env_maxpic", "language": "python", "name": "python3" }, @@ -175,7 +152,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.2" + "version": "3.13.3" } }, "nbformat": 4, From f84faeeacbe6fc69d94b31ec8c1c571db0e4e9bc Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:43:58 +0100 Subject: [PATCH 13/16] bugfix --- src/maxplotlib/canvas/canvas.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index 5e5471f..63c178e 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -349,7 +349,7 @@ def plot_tikzpics( savefig=None, verbose=False, ) -> TikzFigure: - if len(self.subplots) > 0: + if len(self.subplots) > 1: raise NotImplementedError( "Only one subplot is supported for tikzpics backend." ) From 9721221c947d15941b98bc58caca7d571f61cd00 Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:50:05 +0100 Subject: [PATCH 14/16] Don't compile latex in the CI --- tutorials/tutorial_07_tikzpics.ipynb | 45 ++++++---------------------- 1 file changed, 9 insertions(+), 36 deletions(-) diff --git a/tutorials/tutorial_07_tikzpics.ipynb b/tutorials/tutorial_07_tikzpics.ipynb index 42b3131..d3bc587 100644 --- a/tutorials/tutorial_07_tikzpics.ipynb +++ b/tutorials/tutorial_07_tikzpics.ipynb @@ -10,19 +10,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "from maxplotlib import Canvas\n", "\n", @@ -32,42 +23,24 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "2", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "len(self.subplots) = 1\n", - "Plotting subplot at row 0, col 0\n", - "line_plot = \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "c = Canvas(width=\"17cm\", ratio=0.5)\n", "sp = c.add_subplot(grid=False, xlabel=\"x\", ylabel=\"y\")\n", "sp.add_line([0, 1, 2, 3], [0, 1, 0, 2], label=\"Line 1\", layer=1, line_width=2.0)\n", "\n", - "c.show(backend=\"tikzpics\")" + "\n", + "# TODO: Uncomment if pdflatex is installed\n", + "# c.show(backend=\"tikzpics\")" ] } ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "env_maxpic", "language": "python", "name": "python3" }, @@ -81,7 +54,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.2" + "version": "3.13.3" } }, "nbformat": 4, From e31fe2afd7f3a6b82be5ca278aaffe8c2d1cef9b Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 09:57:47 +0100 Subject: [PATCH 15/16] Update version number to 0.1.1 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 247957e..280b999 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "maxplotlibx" -version = "0.1.1" +version = "0.1.2" description = "A reproducible plotting module with various backends and export options." readme = "README.md" requires-python = ">=3.8" From 5dca4c96b9fdc662a8592014b155424dabde9cf2 Mon Sep 17 00:00:00 2001 From: Max Date: Mon, 26 Jan 2026 16:08:27 +0100 Subject: [PATCH 16/16] bugfix in calculating the figure width (#27) * bugfix in calculating the figure width * Removed import * Commented out show of tikzpics graph --- pyproject.toml | 2 +- src/maxplotlib/backends/matplotlib/utils.py | 26 +++++++++++--- src/maxplotlib/canvas/canvas.py | 40 ++++++++++++++++++--- tutorials/tutorial_01.ipynb | 6 ++-- 4 files changed, 61 insertions(+), 13 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 280b999..aa4ecb8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "maxplotlibx" -version = "0.1.2" +version = "0.1.3" description = "A reproducible plotting module with various backends and export options." readme = "README.md" requires-python = ">=3.8" diff --git a/src/maxplotlib/backends/matplotlib/utils.py b/src/maxplotlib/backends/matplotlib/utils.py index 6d9080b..60786b5 100644 --- a/src/maxplotlib/backends/matplotlib/utils.py +++ b/src/maxplotlib/backends/matplotlib/utils.py @@ -56,18 +56,30 @@ def convert_to_inches(length_str): return quantity.to("inch").magnitude # Convert to inches -def _2pt(width, dpi=300): +def _2pt(width, dpi=300, verbose: bool = False): + if verbose: + print(f"Converting width: {width} to points with dpi={dpi}") + if isinstance(width, (int, float)): return width elif isinstance(width, str): length_in = convert_to_inches(width) length_pt = length_in * dpi + if verbose: + print(f"Converted length: {length_in} inches = {length_pt} points") return length_pt else: raise NotImplementedError -def set_size(width, fraction=1, ratio="golden", dpi=300): +# TODO: Use literal types for width and ratio +def set_size( + width: str, + fraction: int | float = 1, + ratio: str | int | float = "golden", + dpi=300, + verbose: bool = False, +) -> tuple: """ Sets figure dimensions to avoid scaling in LaTeX. """ @@ -76,9 +88,11 @@ def set_size(width, fraction=1, ratio="golden", dpi=300): elif width == "beamer": width_pt = 307.28987 else: - width_pt = _2pt(width=width, dpi=dpi) + width_pt = _2pt(width=width, dpi=dpi, verbose=verbose) fig_width_pt = width_pt * fraction + inches_per_pt = 1 / 72.27 + # fig_width_pt = width_pt * fraction # inches_per_pt = 1 / 72.27 # Calculate the figure height based on the desired ratio @@ -91,7 +105,11 @@ def set_size(width, fraction=1, ratio="golden", dpi=300): fig_height_pt = fig_width_pt * ratio else: raise ValueError("Invalid ratio specified.") - fig_dim = (fig_width_pt, fig_height_pt) + + # Convert from points to inches for matplotlib + fig_width_in = fig_width_pt * inches_per_pt + fig_height_in = fig_height_pt * inches_per_pt + fig_dim = (fig_width_in, fig_height_in) return fig_dim diff --git a/src/maxplotlib/canvas/canvas.py b/src/maxplotlib/canvas/canvas.py index c477b3e..a64520e 100644 --- a/src/maxplotlib/canvas/canvas.py +++ b/src/maxplotlib/canvas/canvas.py @@ -267,9 +267,17 @@ def plot( backend: Backends = "matplotlib", savefig=False, layers=None, + verbose: bool = False, ): + if verbose: + print(f"Plotting figure using backend: {backend}") + if backend == "matplotlib": - return self.plot_matplotlib(savefig=savefig, layers=layers) + return self.plot_matplotlib( + savefig=savefig, + layers=layers, + verbose=verbose, + ) elif backend == "plotly": return self.plot_plotly(savefig=savefig) elif backend == "tikzpics": @@ -280,10 +288,19 @@ def plot( def show( self, backend: Backends = "matplotlib", + verbose: bool = False, ): + if verbose: + print(f"Showing figure using backend: {backend}") + if backend == "matplotlib": - self.plot(backend="matplotlib", savefig=False, layers=None) - self._matplotlib_fig.show() + self.plot( + backend="matplotlib", + savefig=False, + layers=None, + verbose=verbose, + ) + # self._matplotlib_fig.show() elif backend == "plotly": self.plot_plotly(savefig=False) elif backend == "tikzpics": @@ -292,13 +309,21 @@ def show( else: raise ValueError("Invalid backend") - def plot_matplotlib(self, savefig=False, layers=None, usetex=False): + def plot_matplotlib( + self, + savefig: bool = False, + layers: list | None = None, + usetex: bool = False, + verbose: bool = False, + ): """ Generate and optionally display the subplots. Parameters: filename (str, optional): Filename to save the figure. """ + if verbose: + print("Generating Matplotlib figure...") tex_fonts = setup_tex_fonts(fontsize=self.fontsize, usetex=usetex) @@ -309,7 +334,9 @@ def plot_matplotlib(self, savefig=False, layers=None, usetex=False): grid_alpha=1.0, grid_linestyle="dotted", ) - + if verbose: + print("Plot style set up.") + print(f"{self._figsize = } {self._width = } {self._ratio = }") if self._figsize is not None: fig_width, fig_height = self._figsize else: @@ -317,7 +344,10 @@ def plot_matplotlib(self, savefig=False, layers=None, usetex=False): width=self._width, ratio=self._ratio, dpi=self.dpi, + verbose=verbose, ) + if verbose: + print(f"Figure size: {fig_width} x {fig_height} points") fig, axes = plt.subplots( self.nrows, diff --git a/tutorials/tutorial_01.ipynb b/tutorials/tutorial_01.ipynb index 53d144f..2b110e4 100644 --- a/tutorials/tutorial_01.ipynb +++ b/tutorials/tutorial_01.ipynb @@ -29,7 +29,7 @@ "metadata": {}, "outputs": [], "source": [ - "c = Canvas(width=\"17cm\", ratio=0.5, fontsize=12)\n", + "c = Canvas(width=\"17mm\", ratio=0.5, fontsize=12)\n", "c.add_line([0, 1, 2, 3], [0, 1, 4, 9], label=\"Line 1\")\n", "c.add_line([0, 1, 2, 3], [0, 2, 3, 4], linestyle=\"dashed\", color=\"red\", label=\"Line 2\")\n", "c.show()" @@ -94,7 +94,7 @@ ], "metadata": { "kernelspec": { - "display_name": "env_maxplotlib", + "display_name": "env_maxpic", "language": "python", "name": "python3" }, @@ -108,7 +108,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.13.3" } }, "nbformat": 4,