Added a Linestyle and Color class

Author: max-models

src/maxplotlib/canvas/canvas.py

@@ -139,7 +139,6 @@ def plot_matplotlib(self, show=True, savefig=False):
         else:
             fig_width, fig_height = plt_utils.set_size(width=self._width, ratio=self._ratio)
 
-        print(fig_width, fig_height, fig_width / self._dpi, fig_height / self._dpi)
         fig, axes = plt.subplots(self.nrows, self.ncols, figsize=(fig_width / self._dpi, fig_height / self._dpi), squeeze=False, dpi = self._dpi)
 
         for (row, col), subplot in self.subplots.items():

src/maxplotlib/colors/__init__.py

@@ -0,0 +1,83 @@
+import numpy as np
+import matplotlib.colors as mcolors
+import matplotlib.patches as patches
+import re
+
+class Color:
+    def __init__(self, color_spec):
+        """
+        Initialize the Color object by parsing the color specification.
+
+        Parameters:
+        - color_spec: Can be a TikZ color string (e.g., 'blue!20'), a standard color name,
+                      an RGB tuple, a hex code, etc.
+        """
+        self.color_spec = color_spec
+        self.rgb = self._parse_color(color_spec)
+
+    def _parse_color(self, color_spec):
+        """
+        Internal method to parse the color specification and convert it to an RGB tuple.
+
+        Parameters:
+        - color_spec: The color specification.
+
+        Returns:
+        - rgb: A tuple of (r, g, b) values, each between 0 and 1.
+        """
+        # If it's already an RGB tuple or list
+        if isinstance(color_spec, (list, tuple)) and len(color_spec) == 3:
+            # Normalize values if necessary
+            rgb = tuple(float(c) / 255 if c > 1 else float(c) for c in color_spec)
+            return rgb
+
+        # If it's a hex code
+        if isinstance(color_spec, str) and color_spec.startswith('#'):
+            return mcolors.hex2color(color_spec)
+
+        # If it's a TikZ color string
+        match = re.match(r'(\w+)!([\d.]+)', color_spec)
+        if match:
+            base_color_name, percentage = match.groups()
+            percentage = float(percentage)
+            base_color = mcolors.to_rgb(base_color_name)
+            white = np.array([1.0, 1.0, 1.0])
+            mix = percentage / 100.0
+            color = mix * np.array(base_color) + (1 - mix) * white
+            return tuple(color)
+
+        # Else, try to parse as a standard color name
+        try:
+            return mcolors.to_rgb(color_spec)
+        except ValueError:
+            raise ValueError(f"Invalid color specification: '{color_spec}'")
+
+    def to_rgb(self):
+        """
+        Return the color as an RGB tuple.
+
+        Returns:
+        - rgb: A tuple of (r, g, b) values, each between 0 and 1.
+        """
+        return self.rgb
+
+    def to_hex(self):
+        """
+        Return the color as a hex code.
+
+        Returns:
+        - hex_code: A string representing the color in hex format.
+        """
+        return mcolors.to_hex(self.rgb)
+
+    def to_rgba(self, alpha=1.0):
+        """
+        Return the color as an RGBA tuple.
+
+        Parameters:
+        - alpha (float): The alpha (opacity) value between 0 and 1.
+
+        Returns:
+        - rgba: A tuple of (r, g, b, a) values.
+        """
+        return (*self.rgb, alpha)

src/maxplotlib/colors/colors.py

@@ -0,0 +1,57 @@
+import re
+
+class Linestyle:
+    def __init__(self, style_spec):
+        """
+        Initialize the Linestyle object by parsing the style specification.
+
+        Parameters:
+        - style_spec: Can be a TikZ-style line style string (e.g., 'dashed', 'dotted', 'solid', 'dashdot'),
+                      or a custom dash pattern.
+        """
+        self.style_spec = style_spec
+        self.matplotlib_style = self._parse_style(style_spec)
+
+    def _parse_style(self, style_spec):
+        """
+        Internal method to parse the style specification and convert it to a Matplotlib linestyle.
+
+        Parameters:
+        - style_spec: The style specification.
+
+        Returns:
+        - linestyle: A Matplotlib linestyle string or dash pattern.
+        """
+        # Predefined mappings from TikZ to Matplotlib
+        linestyle_mapping = {
+            'solid': 'solid',
+            'dashed': 'dashed',
+            'dotted': 'dotted',
+            'dashdot': 'dashdot',
+            # You can add more styles or custom dash patterns
+        }
+
+        # Check for predefined styles
+        if style_spec in linestyle_mapping:
+            return linestyle_mapping[style_spec]
+        else:
+            # Check if it's a custom dash pattern, e.g., 'dash pattern=on 5pt off 2pt'
+            match = re.match(r'dash pattern=on ([\d.]+)pt off ([\d.]+)pt', style_spec)
+            if match:
+                on_length = float(match.group(1))
+                off_length = float(match.group(2))
+                # Matplotlib dash pattern is specified in points
+                return (0, (on_length, off_length))
+            else:
+                # Default to solid if style is unknown
+                print(f"Unknown line style: '{style_spec}', defaulting to 'solid'")
+                return 'solid'
+
+    def to_matplotlib(self):
+        """
+        Return the line style in Matplotlib format.
+
+        Returns:
+        - linestyle: A Matplotlib linestyle string or dash sequence.
+        """
+        return self.matplotlib_style

src/maxplotlib/linestyle/__init__.py

@@ -2,6 +2,13 @@
 import os
 import tempfile
 from matplotlib.image import imread
+import numpy as np
+import re
+
+
+import matplotlib.patches as patches
+from maxplotlib.colors.colors import Color
+from maxplotlib.linestyle.linestyle import Linestyle
 
 class Node:
     def __init__(self, x, y, label="", content="",**kwargs):
@@ -214,11 +221,132 @@ def compile_pdf(self, filename='output.pdf'):
                 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):
         """
-        Plot all lines on the provided axis.
+        Plot all nodes and paths on the provided axis using Matplotlib.
 
         Parameters:
-        ax (matplotlib.axes.Axes): Axis on which to plot the lines.
+        - 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 = [next(node.x for node in self.nodes if node.label == label) for label in path.nodes]
+            y_coords = [next(node.y for node in self.nodes if node.label == label) for label 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')