kaxe 1.4.2__tar.gz → 1.4.4.dev2__tar.gz

{kaxe-1.4.2/src/kaxe.egg-info → kaxe-1.4.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.4.2
+Version: 1.4.4.dev2
 Summary: A small graphing tool for functions, points, equations and more
 Author-email: Valter Yde Daugberg <valteryde@hotmail.com>
 Project-URL: Homepage, https://github.com/valteryde/kaxe

{kaxe-1.4.2 → kaxe-1.4.4.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kaxe"
-version = "1.4.2"
+version = "1.4.4.dev2"
 authors = [
   { name="Valter Yde Daugberg", email="valteryde@hotmail.com" },
 ]

{kaxe-1.4.2 → kaxe-1.4.4.dev2}/src/kaxe/core/legend.py

@@ -3,6 +3,7 @@ from .symbol import makeSymbolShapes, symbol
 from .text import Text
 from .shapes import shapes
 from .styles import AttrObject, ComputedAttribute
+from .svg import SvgDocument
 import math
 from types import MappingProxyType
 from PIL import Image
@@ -46,12 +47,12 @@ class LegendBox(AttrObject):
         self.objects = objects
 
 
-    def finalize(self, parent, sneaky=False): # maybe add as a seperate object
+    def finalize(self, parent, sneaky=False, vector=False): # maybe add as a seperate object
         """
         stadigvæk lidt skrøbelig
 
         if sneaky is True the method will not do anything to parent
-        The function will also just return an image of the legendbox
+        The function will also just return an image of the legendbox (or SvgDocument when vector=True)
 
         """
         self.setAttrMap(parent.attrmap)
@@ -90,6 +91,7 @@ class LegendBox(AttrObject):
             legendGridSpacing = self.getAttr('gaps')
             legendSymbolTextSpacing = self.getAttr('symbolTextSpacing')
             legendGap = self.getAttr('topMargin')
+            legendPadding = max(1, fontSize // 16)
 
             # legendSizeThickness = 2 #NOTE: STYLE
             # legendPadding = (5, 5, 5, 5) # NOTE: STYLE, left bottom right top
@@ -106,19 +108,19 @@ class LegendBox(AttrObject):
                 width = symbolSize[0] + text.width + legendGridSpacing[0] + legendSymbolTextSpacing
                 height = max(symbolSize[1], text.height)
 
-                currentLineWidth += width
-                # hvis bredden er for meget så gå en linje ned
-                if currentLineWidth > legendMaxWidth:
+                if currentLineWidth > 0 and currentLineWidth + width > legendMaxWidth:
                     grid.append({"elements":[], "height":0})
                     currentLineWidth = 0
-                
+
+                currentLineWidth += width
                 grid[-1]["elements"].append((symbol, text, width, height))
                 grid[-1]["height"] = max(grid[-1]["height"], height)
 
+            grid = [row for row in grid if row["elements"]]
             grid.reverse()
 
             # create legends
-            currentLinePos = [0, 0]
+            currentLinePos = [legendPadding, legendPadding]
             maxPos = [0, 0]
             minPos = [math.inf, math.inf]
             for row in grid:
@@ -132,23 +134,24 @@ class LegendBox(AttrObject):
 
                     currentLinePos[0] += width
                     row_mid = y + row["height"] / 2
-                    symbol.x = x
                     if isinstance(symbol, shapes.Circle):
+                        symbol.x = x + symbolSize[0] / 2
                         symbol.centerAlign()
                         symbol.y = row_mid
-                        sym_min_x = symbol.x - symbolSize[0] / 2
-                        sym_max_x = symbol.x + symbolSize[0] / 2
+                        sym_min_x = x
+                        sym_max_x = x + symbolSize[0]
                         sym_min_y = symbol.y - symbolSize[1] / 2
                         sym_max_y = symbol.y + symbolSize[1] / 2
                     else:
+                        symbol.x = x
                         symbol.y = row_mid - symbolSize[1] / 2
                         sym_min_x = symbol.x
                         sym_max_x = symbol.x + symbolSize[0]
                         sym_min_y = symbol.y
                         sym_max_y = symbol.y + symbolSize[1]
                     text.setLeftTopPos(
-                        x + symbolSize[0] + legendSymbolTextSpacing, 
-                        y + text.height/2 + row["height"]/2 #+ text.height + height/2 - text.height/2 #+ height/2 + text.height/2
+                        x + symbolSize[0] + legendSymbolTextSpacing,
+                        y + row["height"] / 2 + text.height / 2,
                     )
 
                     if debug:
@@ -166,8 +169,13 @@ class LegendBox(AttrObject):
 
             if debug: shapes.Circle(0,0, 10, batch=self.batch)
 
-            height = (maxPos[1] - minPos[1])
-            width = (maxPos[0] - minPos[0])
+            minPos[0] -= legendPadding
+            minPos[1] -= legendPadding
+            maxPos[0] += legendPadding
+            maxPos[1] += legendPadding
+
+            height = math.ceil(maxPos[1] - minPos[1])
+            width = math.ceil(maxPos[0] - minPos[0])
             
             ### skub den ned til window 0,0 (her burde title være med)
             # self.batch.push(-minPos[0], -minPos[1])
@@ -192,11 +200,19 @@ class LegendBox(AttrObject):
                 # tilføj plads til legenden
                 parent.addPaddingCondition(bottom=height+legendGap)
 
-            else: # Only works with PILLOW
+            else:
                 self.batch.push(-minPos[0], -minPos[1])
                 self.boxshape.push(-minPos[0], -minPos[1])
+                if vector:
+                    doc = SvgDocument((int(width), int(height)))
+                    self.boxshape.draw(doc)
+                    self.batch.draw(doc)
+                    return doc
                 surface = Image.new('RGBA', (int(width), int(height)), (0,0,0,0))
-
                 self.boxshape.draw(surface)
                 self.batch.draw(surface)
-                return surface
+                return surface
+
+    def finalize_svg_sneaky(self, parent):
+        """Return an SvgDocument sized to the legend for grid SVG export."""
+        return self.finalize(parent, sneaky=True, vector=True)

{kaxe-1.4.2 → kaxe-1.4.4.dev2}/src/kaxe/core/shapes.py

@@ -276,7 +276,9 @@ class Circle(Shape):
         doubleradius = int(2*self.radius)
         circle = Image.new("RGBA", (doubleradius, doubleradius), (0, 0, 0, 0))
         draw = ImageDraw.Draw(circle)
-        pos = (0, 0, 2 * self.radius, 2 * self.radius)
+        # PIL treats the bbox as inclusive on both ends; shrink by half a pixel so
+        # the rendered circle is symmetric and not clipped at the bottom edge.
+        pos = (-0.5, -0.5, 2 * self.radius - 0.5, 2 * self.radius - 0.5)
         if self.fill:
             draw.ellipse(pos, fill=self.color)
         else:

{kaxe-1.4.2 → kaxe-1.4.4.dev2}/src/kaxe/core/svg.py

@@ -368,6 +368,60 @@ class SvgDocument:
         return '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n' + body
 
 
+def parse_svg_root(xml: str) -> ET.Element:
+    """Parse SVG XML and return the root element."""
+    if xml.startswith("<?"):
+        xml = xml.split("\n", 1)[1]
+    root = ET.fromstring(xml)
+    if not (root.tag.endswith("svg") or root.tag == "svg"):
+        raise ValueError("Expected SVG root element")
+    return root
+
+
+def extract_svg_children(root: ET.Element) -> tuple[list[ET.Element], Optional[str]]:
+    """Return drawable children (excluding defs) and optional fondi style text."""
+    fondi_css: Optional[str] = None
+    children: list[ET.Element] = []
+    for child in root:
+        local = child.tag.split("}")[-1] if "}" in child.tag else child.tag
+        if local == "defs":
+            for sub in child:
+                sub_local = sub.tag.split("}")[-1] if "}" in sub.tag else sub.tag
+                if sub_local == "style" and sub.text:
+                    fondi_css = sub.text
+            continue
+        children.append(child)
+    return children, fondi_css
+
+
+def embed_svg_children(
+    doc: SvgDocument,
+    children: list[ET.Element],
+    tx: float,
+    ty: float,
+) -> None:
+    """Embed copied SVG children at top-left offset (SVG y-down coordinates)."""
+    if not children:
+        return
+    group = ET.Element(
+        f"{{{SVG_NS}}}g",
+        {"transform": f"translate({round(tx, 3)},{round(ty, 3)})"},
+    )
+    for child in children:
+        group.append(copy.deepcopy(child))
+    doc._elements.append(group)
+
+
+def merge_fondi_css(doc: SvgDocument, *style_texts: Optional[str]) -> None:
+    """Set fondi font CSS on doc once (skip duplicates and empty)."""
+    if doc._fondi_font_css is not None:
+        return
+    for text in style_texts:
+        if text:
+            doc._fondi_font_css = text
+            return
+
+
 def is_file_path(fname: Any) -> bool:
     """Return True when fname is a filesystem path (str or os.PathLike)."""
     return isinstance(fname, (str, os.PathLike))

{kaxe-1.4.2 → kaxe-1.4.4.dev2}/src/kaxe/core/window.py

@@ -69,6 +69,7 @@ class Window(AttrObject):
     """
 
     name = "Window"
+    supports_vector_export = True
 
     def __init__(self): # |
         """

{kaxe-1.4.2 → kaxe-1.4.4.dev2}/src/kaxe/plot/d3/plot3d.py

@@ -27,6 +27,8 @@ from .axes import Plot3DAxesMixin
 
 
 class Plot3D(Plot3DAxesMixin, Window):
+    supports_vector_export = False
+
     """
     A 3D plotting window with full wireframe box and automatic axis positioning.
     

{kaxe-1.4.2 → kaxe-1.4.4.dev2}/src/kaxe/plot/grid.py

@@ -1,12 +1,28 @@
 
 from io import BytesIO
+from typing import Optional, Union
 from ..core.styles import AttrObject, AttrMap
 from ..core.window import *
 from ..core.legend import LegendBox
-from typing import Union
+from ..core.svg import (
+    SvgDocument,
+    infer_format,
+    is_file_path,
+    parse_svg_root,
+    extract_svg_children,
+    embed_svg_children,
+    merge_fondi_css,
+)
 from PIL import Image
 from .constants import XYZPLOT
 
+
+def _cell_supports_svg(plot) -> bool:
+    if plot == XYZPLOT or isinstance(plot, str):
+        return False
+    return getattr(plot, "supports_vector_export", False)
+
+
 class Grid(AttrObject):
     """
     Assemble multiple plots in one image.
@@ -19,6 +35,7 @@ class Grid(AttrObject):
     >>> grid.addColumn(plt3, plt4)
     >>> grid.show()
     >>> grid.save('fname.png')
+    >>> grid.save('fname.svg')  # 2D vector; 3D cells embed as raster
 
     """
 
@@ -47,6 +64,7 @@ class Grid(AttrObject):
         self.padding = [0,0,0,0]
 
         self.__bakedImage__ = False
+        self.__bakedSvg__ = None
         self.laterDraws = []
 
 
@@ -76,39 +94,27 @@ class Grid(AttrObject):
         self.__legends = legends
 
 
-
-    def __bake__(self):
-        """
-        only supports pillow images
-
-        TODO: Clean up
-        """
-
+    def _prepare_cells(self, vector: bool = False):
+        """Style cells, export to memory, and compute composite layout."""
         grid = self.grid
         gridSize = ((max([len(i) for i in grid])), len(grid))
         self.width, self.height = self.getAttr('width'), self.getAttr('height')
         self.outerPadding = self.getAttr('outerPadding')
 
-        # styles values
-        cellWidth, cellHeight = self.width//gridSize[0], self.height//gridSize[1]
+        cellWidth, cellHeight = self.width // gridSize[0], self.height // gridSize[1]
 
-        # calculated values        
         height = 0
         leftpadding = 0
         rightpadding = 0
         toppadding = 0
         bottompadding = 0
         gapcol = 0
-
-        # add styles to window
-        # and calculate sizes
         maxWidth = 0
+
         for row in grid:
-            
             maxHeight = 0
-            
+
             for colNum, plot in enumerate(row):
-                
                 plot.style(width=cellWidth, height=cellHeight)
                 plot.style(outerPadding=self.outerPadding)
 
@@ -119,86 +125,177 @@ class Grid(AttrObject):
                 if plot == XYZPLOT:
                     plot.forceWidthHeight = True
 
-                plot.save(memfile)
+                if vector and _cell_supports_svg(plot):
+                    plot.save(memfile, format="svg")
+                else:
+                    plot.save(memfile)
+
                 plot.__ioBytes = memfile
+                memfile.seek(0)
 
                 w, h = plot.getSize()
                 maxWidth = max(w, maxWidth)
-                
                 maxHeight = max(h, maxHeight)
-                
-                # calculate paddings
+
                 if colNum == 0:
                     leftpadding = max(leftpadding, plot.padding[0])
                     bottompadding = max(bottompadding, plot.padding[1])
-                
-                # calculate gaps
-                else: # "låner"/genbruger lige else her
-                    
-                    # Da den næste ikke er lavet bruges den forrige
+                else:
                     gapcol = max(gapcol, plot.padding[0] + row[colNum - 1].padding[2])
 
-                if colNum == len(row)-1:
+                if colNum == len(row) - 1:
                     rightpadding = max(rightpadding, plot.padding[2])
                     toppadding = max(toppadding, plot.padding[3])
 
             height += maxHeight
-        
+
         largetsRowNumber = max(len(i) for i in grid)
-        width = gapcol * (largetsRowNumber - 1) + largetsRowNumber * cellWidth + leftpadding + rightpadding
+        width = (
+            gapcol * (largetsRowNumber - 1)
+            + largetsRowNumber * cellWidth
+            + leftpadding
+            + rightpadding
+        )
 
         size = (
             width + self.outerPadding[0] + self.outerPadding[2],
-            height + self.outerPadding[1] + self.outerPadding[3] + toppadding
+            height + self.outerPadding[1] + self.outerPadding[3] + toppadding,
         )
-        
-        # Add legend
+
+        legend_image = None
+        legend_doc = None
+        legend_top_margin = 0
+
         if self.__legends:
             self.legendbox = LegendBox()
             for d in self.__legends:
                 self.legendbox.add(*d)
 
-            legendBoxImage = self.legendbox.finalize(self, sneaky=True)
-
-            size = (
-                size[0],
-                size[1] + legendBoxImage.height + self.legendbox.getAttr('topMargin'),
-            )
+            if vector:
+                legend_doc = self.legendbox.finalize_svg_sneaky(self)
+                legend_h = legend_doc.height
+                legend_top_margin = self.legendbox.getAttr('topMargin')
+            else:
+                legend_image = self.legendbox.finalize(self, sneaky=True)
+                legend_h = legend_image.height
+                legend_top_margin = self.legendbox.getAttr('topMargin')
+
+            size = (size[0], size[1] + legend_h + legend_top_margin)
+
+        return {
+            "grid": grid,
+            "cellWidth": cellWidth,
+            "gapcol": gapcol,
+            "size": size,
+            "leftpadding": leftpadding,
+            "toppadding": toppadding,
+            "legend_image": legend_image,
+            "legend_doc": legend_doc,
+            "legend_top_margin": legend_top_margin,
+        }
+
+
+    def _composite_png(self, layout: dict) -> Image.Image:
+        grid = layout["grid"]
+        size = layout["size"]
+        cellWidth = layout["cellWidth"]
+        gapcol = layout["gapcol"]
+        leftpadding = layout["leftpadding"]
+        toppadding = layout["toppadding"]
 
         image = Image.new('RGBA', size, self.getAttr('backgroundColor'))
 
-        if self.__legends:
-            image.alpha_composite(legendBoxImage, (image.width//2 - legendBoxImage.width//2, image.height - legendBoxImage.height - self.outerPadding[3]))
+        legend_image = layout["legend_image"]
+        if legend_image is not None:
+            image.alpha_composite(
+                legend_image,
+                (
+                    image.width // 2 - legend_image.width // 2,
+                    image.height - legend_image.height - self.outerPadding[3],
+                ),
+            )
 
-        # TEGNER!
-        # add plots to grid image
         y = toppadding + self.outerPadding[1]
 
         for row in grid:
-
             maxHeight = 0
             x = leftpadding + self.outerPadding[0]
 
             for plot in row:
-                """
-                Is a little ineffecient to write and then read from memory with png extenseion
-                but here goes.
-                """
-
-                w, h = plot.getSize()
-
                 img = Image.open(plot.__ioBytes)
+                plot.__ioBytes.seek(0)
                 image.paste(img, (x - plot.padding[0], y - plot.padding[3]))
-            
                 x += cellWidth + gapcol
-                maxHeight = max(maxHeight, h)
+                maxHeight = max(maxHeight, plot.getSize()[1])
 
             y += maxHeight
 
-        self.__bakedImage__ = image
+        return image
+
+
+    def _composite_svg(self, layout: dict) -> str:
+        size = layout["size"]
+        grid = layout["grid"]
+        cellWidth = layout["cellWidth"]
+        gapcol = layout["gapcol"]
+        leftpadding = layout["leftpadding"]
+        toppadding = layout["toppadding"]
+
+        doc = SvgDocument(size)
+        bg = self.getAttr('backgroundColor')
+        if bg[3] != 0:
+            doc.add_rect(0, 0, size[0], size[1], bg)
+
+        legend_doc = layout["legend_doc"]
+        if legend_doc is not None:
+            lx = size[0] // 2 - legend_doc.width // 2
+            ly = size[1] - legend_doc.height - self.outerPadding[3]
+            embed_svg_children(doc, list(legend_doc._elements), lx, ly)
+            merge_fondi_css(doc, legend_doc._fondi_font_css)
+
+        y = toppadding + self.outerPadding[1]
+
+        for row in grid:
+            maxHeight = 0
+            x = leftpadding + self.outerPadding[0]
+
+            for plot in row:
+                px = x - plot.padding[0]
+                py = y - plot.padding[3]
+
+                if _cell_supports_svg(plot):
+                    plot.__ioBytes.seek(0)
+                    xml = plot.__ioBytes.read().decode("utf-8")
+                    root = parse_svg_root(xml)
+                    children, fondi_css = extract_svg_children(root)
+                    embed_svg_children(doc, children, px, py)
+                    merge_fondi_css(doc, fondi_css)
+                else:
+                    plot.__ioBytes.seek(0)
+                    img = Image.open(plot.__ioBytes)
+                    doc.add_image(img, px, py, y_coord="top")
+
+                x += cellWidth + gapcol
+                maxHeight = max(maxHeight, plot.getSize()[1])
+
+            y += maxHeight
+
+        return doc.serialize()
 
+
+    def __bake__(self):
+        layout = self._prepare_cells(vector=False)
+        image = self._composite_png(layout)
+        self.__bakedImage__ = image
         return image
 
+
+    def __bake_svg__(self) -> str:
+        layout = self._prepare_cells(vector=True)
+        xml = self._composite_svg(layout)
+        self.__bakedSvg__ = xml
+        return xml
+
     
     def addRow(self, *row:list):
         """
@@ -232,18 +329,36 @@ class Grid(AttrObject):
             self.grid[i].append(plot)
 
     
-    def save(self, fpath:str):
-        
+    def save(self, fname: Union[str, BytesIO], format: Optional[str] = None):
+        fmt = infer_format(fname, format)
+
+        if fmt == "svg":
+            if self.__bakedSvg__ is not None:
+                xml = self.__bakedSvg__
+            else:
+                xml = self.__bake_svg__()
+
+            if fname is not None:
+                if is_file_path(fname):
+                    with open(fname, 'w', encoding='utf-8') as f:
+                        f.write(xml)
+                else:
+                    fname.write(xml.encode('utf-8'))
+            return
+
         if self.__bakedImage__:
-            self.__bakedImage__.save(fpath)
+            if is_file_path(fname):
+                self.__bakedImage__.save(fname)
+            else:
+                self.__bakedImage__.save(fname, format="png")
             return
 
         img = self.__bake__()
-        
-        if fpath is str:
-            img.save(fpath)
+
+        if isinstance(fname, str):
+            img.save(fname)
         else:
-            img.save(fpath, format="png")
+            img.save(fname, format="png")
 
 
     def show(self):
@@ -277,4 +392,7 @@ class Grid(AttrObject):
 
 
     def getSize(self):
-        return self.__bakedImage__.size
+        if self.__bakedImage__:
+            return self.__bakedImage__.size
+        layout = self._prepare_cells(vector=False)
+        return layout["size"]

{kaxe-1.4.2 → kaxe-1.4.4.dev2/src/kaxe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.4.2
+Version: 1.4.4.dev2
 Summary: A small graphing tool for functions, points, equations and more
 Author-email: Valter Yde Daugberg <valteryde@hotmail.com>
 Project-URL: Homepage, https://github.com/valteryde/kaxe