kaxe 1.5.2.dev1__tar.gz → 1.5.5__tar.gz

{kaxe-1.5.2.dev1/src/kaxe.egg-info → kaxe-1.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.5.2.dev1
+Version: 1.5.5
 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.5.2.dev1 → kaxe-1.5.5}/pyproject.toml

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

{kaxe-1.5.2.dev1 → kaxe-1.5.5}/src/kaxe/core/helper.py

@@ -45,6 +45,74 @@ def vlen(v):
     return math.sqrt(sum([i**2 for i in v]))
 
 
+def contour_label_angle(polyline, index):
+    """Readable tangent angle in degrees for text placed on a contour polyline."""
+    n = len(polyline)
+    if n < 2:
+        return 0
+
+    if index <= 0:
+        p0, p1 = polyline[0], polyline[1]
+    elif index >= n - 1:
+        p0, p1 = polyline[-2], polyline[-1]
+    else:
+        p0, p1 = polyline[index - 1], polyline[index + 1]
+
+    dx = p1[0] - p0[0]
+    dy = p1[1] - p0[1]
+    if dx == 0 and dy == 0:
+        return 0
+
+    angle = math.degrees(math.atan2(-dy, dx))
+    if angle > 90:
+        angle -= 180
+    elif angle < -90:
+        angle += 180
+    return angle
+
+
+def resample_polyline(points, spacing):
+    """
+    Emit points every `spacing` pixels along polyline arc length.
+
+    Points are placed at uniform screen-space intervals by interpolating
+    along segments, so output density is non-uniform in data/index space.
+    """
+    if spacing <= 0 or len(points) < 2:
+        return list(points)
+
+    result = [points[0]]
+    dist_since_last = 0.0
+    prev = points[0]
+
+    for i in range(1, len(points)):
+        cur = points[i]
+        seg_dx = cur[0] - prev[0]
+        seg_dy = cur[1] - prev[1]
+        seg_len = math.hypot(seg_dx, seg_dy)
+
+        if seg_len == 0:
+            prev = cur
+            continue
+
+        pos_on_seg = 0.0
+        while dist_since_last + (seg_len - pos_on_seg) >= spacing:
+            need = spacing - dist_since_last
+            pos_on_seg += need
+            t = pos_on_seg / seg_len
+            result.append((prev[0] + t * seg_dx, prev[1] + t * seg_dy))
+            dist_since_last = 0.0
+
+        dist_since_last += seg_len - pos_on_seg
+        prev = cur
+
+    last = points[-1]
+    if result[-1] != last:
+        result.append(last)
+
+    return result
+
+
 def vectorScalar(v, s):
     return [i*s for i in v]
 

kaxe-1.5.5/src/kaxe/core/ipython_display.py

@@ -0,0 +1,32 @@
+"""Jupyter / IPython inline display helpers."""
+
+from io import BytesIO
+
+
+def is_notebook():
+    from .window import terminaltype
+
+    return terminaltype in ("jupyter", "ipython")
+
+
+def jupyter_display_width():
+    from .window import settings
+
+    return settings.get("jupyterDisplayWidth", 800)
+
+
+def to_png_bytes(plot):
+    """Render a plot or grid to PNG bytes in memory."""
+    buf = BytesIO()
+    plot.save(buf)
+    return buf.getvalue()
+
+
+def display_png_bytes(data, width=None):
+    """Display PNG bytes inline in a Jupyter or IPython session."""
+    from IPython import display  # pyright: ignore[reportMissingModuleSource]
+
+    if width is None:
+        width = jupyter_display_width()
+    image = display.Image(data=data, width=width, unconfined=True)
+    display.display(image)

kaxe-1.5.5/src/kaxe/core/progress.py

@@ -0,0 +1,47 @@
+"""Progress bar helpers for terminal and notebook rendering."""
+
+import time
+
+import tqdm
+
+
+class _NoProgress:
+    def update(self, n=1):
+        pass
+
+    def close(self):
+        pass
+
+
+class _DeferredProgress:
+    """Text progress bar that appears only after a time threshold."""
+
+    def __init__(self, total, desc, threshold):
+        self.total = total
+        self.desc = desc
+        self.threshold = threshold
+        self.start = time.time()
+        self.pbar = None
+        self.count = 0
+
+    def update(self, n=1):
+        self.count += n
+        if self.pbar is None and time.time() - self.start >= self.threshold:
+            self.pbar = tqdm.tqdm(total=self.total, desc=self.desc, initial=self.count)
+        if self.pbar is not None:
+            self.pbar.update(n)
+
+    def close(self):
+        if self.pbar is not None:
+            self.pbar.close()
+
+
+def make_progress_bar(show, total, desc):
+    from .window import settings, terminaltype
+
+    if not show:
+        return _NoProgress()
+    if terminaltype == "terminal":
+        return tqdm.tqdm(total=total, desc=desc)
+    threshold = settings.get("jupyterLoadingThreshold", 1.0)
+    return _DeferredProgress(total, desc, threshold)

{kaxe-1.5.2.dev1 → kaxe-1.5.5}/src/kaxe/core/window.py

@@ -8,14 +8,9 @@ from .styles import *
 from .legend import LegendBox
 from .shapes import shapes
 from .svg import SvgDocument, infer_format, is_file_path
+from .progress import make_progress_bar
+from .ipython_display import display_png_bytes, is_notebook, to_png_bytes
 from PIL import Image
-import tqdm
-from random import randint
-import os
-try:
-    from IPython import display # pyright: ignore[reportMissingModuleSource]
-except ImportError:
-    pass
 
 
 """
@@ -38,7 +33,11 @@ except:
     pass
 
 
-settings = {"removeInfo":False}
+settings = {
+    "removeInfo": False,
+    "jupyterLoadingThreshold": 1.0,
+    "jupyterDisplayWidth": 800,
+}
 
 def compute_adjust_styles(
     procentWidth,
@@ -82,6 +81,11 @@ def setSetting(**kwargs):
         removeInfo : bool
             When ``True``, suppress progress bars and bake timing logs.
             Useful in notebooks and batch scripts.
+        jupyterLoadingThreshold : float
+            Seconds before a progress bar appears in Jupyter (default 1.0).
+            Fast plots stay quiet.
+        jupyterDisplayWidth : int
+            Width in pixels for inline notebook display (default 800).
 
     Examples
     --------
@@ -140,7 +144,7 @@ class Window(AttrObject):
 
         self.legendbox = LegendBox()
         self.offset = [0,0]
-        self.showProgressBar = terminaltype == "terminal" 
+        self.showProgressBar = terminaltype != "terminal"
         self.printDebugInfo = True
 
         if settings["removeInfo"]:
@@ -487,17 +491,17 @@ class Window(AttrObject):
     def __addInnerContent__(self):
         
         # finalizeing objects
-        if self.showProgressBar: pbar = tqdm.tqdm(total=len(self.objects), desc='Baking')
+        pbar = make_progress_bar(self.showProgressBar, len(self.objects), 'Baking')
         for obj in self.objects:
             self.__callFinalizeObject__(obj)
-            if self.showProgressBar: pbar.update()
+            pbar.update()
             self.addDrawingFunction(obj)
-        if self.showProgressBar:pbar.close()
+        pbar.close()
 
 
     def __pillowPaint__(self, fname=None):
         startTime = time.time()
-        if self.showProgressBar: pbar = tqdm.tqdm(total=len(self.shapes), desc='Decorating')
+        pbar = make_progress_bar(self.showProgressBar, len(self.shapes), 'Decorating')
 
         winSize = self.width+self.padding[0]+self.padding[2], self.height+self.padding[1]+self.padding[3]
         surface = Image.new('RGBA', winSize)
@@ -508,8 +512,7 @@ class Window(AttrObject):
 
         for shape in self.shapes:
             shape.draw(surface)
-            
-            if self.showProgressBar: pbar.update()
+            pbar.update()
 
         if fname is not None:
             if is_file_path(fname):
@@ -517,7 +520,7 @@ class Window(AttrObject):
             else:
                 surface.save(fname, format="png")
 
-        if self.showProgressBar: pbar.close()
+        pbar.close()
         if self.printDebugInfo: logging.info('Painted in {}s'.format(str(round(time.time() - startTime, 4))))
         
         return surface
@@ -525,7 +528,7 @@ class Window(AttrObject):
 
     def __svgPaint__(self, fname=None) -> str:
         startTime = time.time()
-        if self.showProgressBar: pbar = tqdm.tqdm(total=len(self.shapes), desc='Decorating SVG')
+        pbar = make_progress_bar(self.showProgressBar, len(self.shapes), 'Decorating SVG')
 
         winSize = self.width+self.padding[0]+self.padding[2], self.height+self.padding[1]+self.padding[3]
         doc = SvgDocument(winSize)
@@ -536,7 +539,7 @@ class Window(AttrObject):
 
         for shape in self.shapes:
             shape.draw(doc)
-            if self.showProgressBar: pbar.update()
+            pbar.update()
 
         xml = doc.serialize()
 
@@ -547,7 +550,7 @@ class Window(AttrObject):
             else:
                 fname.write(xml.encode('utf-8'))
 
-        if self.showProgressBar: pbar.close()
+        pbar.close()
         if self.printDebugInfo: logging.info('Painted SVG in {}s'.format(str(round(time.time() - startTime, 4))))
 
         return xml
@@ -555,7 +558,7 @@ class Window(AttrObject):
 
     def __pdfPaint__(self, fname=None) -> bytes:
         startTime = time.time()
-        if self.showProgressBar: pbar = tqdm.tqdm(total=len(self.shapes), desc='Decorating PDF')
+        pbar = make_progress_bar(self.showProgressBar, len(self.shapes), 'Decorating PDF')
 
         winSize = self.width+self.padding[0]+self.padding[2], self.height+self.padding[1]+self.padding[3]
         doc = SvgDocument(winSize)
@@ -566,11 +569,11 @@ class Window(AttrObject):
 
         for shape in self.shapes:
             shape.draw(doc)
-            if self.showProgressBar: pbar.update()
+            pbar.update()
 
         pdf_bytes = doc.to_pdf(fname)
 
-        if self.showProgressBar: pbar.close()
+        pbar.close()
         if self.printDebugInfo: logging.info('Painted PDF in {}s'.format(str(round(time.time() - startTime, 4))))
 
         return pdf_bytes
@@ -651,23 +654,20 @@ class Window(AttrObject):
         --------
         >>> plt.show( )
         """
-
-        fname = 'plot{}.png'.format(''.join([str(randint(0,9)) for i in range(10)]))
-
-        if terminaltype != "terminal":
-            self.save(fname)
-            i = display.Image(filename=fname, width=800, unconfined=True)
-            display.display(i)
-            os.remove(fname)
-
+        data = to_png_bytes(self)
+        if is_notebook():
+            display_png_bytes(data)
         else:
-            
-            self.save(fname)
-            pilImage = Image.open(fname)
-            pilImage.show()
-            os.remove(fname)
+            Image.open(BytesIO(data)).show()
+
+    def _repr_png_(self):
+        if not is_notebook():
+            return None
+        return to_png_bytes(self)
 
-        return fname
+    def __repr__(self):
+        n = len(getattr(self, "objects", []))
+        return f"<{type(self).__name__} with {n} object(s)>"
 
     # shape
     # for at kunne overskrive den nederste funktion indføres denne

kaxe-1.5.5/src/kaxe/objects/d2/contour.py

@@ -0,0 +1,305 @@
+
+import math
+
+from ...core.styles import *
+from ...core.shapes import shapes
+from ...core.symbol import symbol as symbols
+from ...core.helper import contour_label_angle
+from ...core.text import Text
+from ...core.round import koundTeX
+from ...plot import identities
+from .equation import Equation, trace_contour_polylines
+from types import FunctionType
+from typing import Union
+from ...core.color import Colormaps, Colormap, to_rgba
+
+
+def _format_contour_level(z, a, b, steps):
+    step_size = abs(b - a) / steps if steps else abs(b - a)
+    if step_size > 0:
+        digits = max(4, int(-math.log10(step_size)) + 2)
+    else:
+        digits = 4
+    return str(koundTeX(round(z, digits)))
+
+
+def _polyline_arc_length(polyline):
+    total = 0.0
+    for i in range(1, len(polyline)):
+        dx = polyline[i][0] - polyline[i - 1][0]
+        dy = polyline[i][1] - polyline[i - 1][1]
+        total += math.hypot(dx, dy)
+    return total
+
+
+def _simplify_polyline(polyline):
+    if not polyline:
+        return []
+
+    simplified = [polyline[0]]
+    for point in polyline[1:]:
+        if point != simplified[-1]:
+            simplified.append(point)
+
+    if len(simplified) > 2 and simplified[0] == simplified[-1]:
+        simplified.pop()
+
+    return simplified
+
+
+def _point_at_arc_length(polyline, target):
+    if not polyline:
+        return 0, (0, 0)
+
+    if target <= 0:
+        return 0, polyline[0]
+
+    walked = 0.0
+    for i in range(1, len(polyline)):
+        dx = polyline[i][0] - polyline[i - 1][0]
+        dy = polyline[i][1] - polyline[i - 1][1]
+        seg_len = math.hypot(dx, dy)
+        if seg_len == 0:
+            continue
+        if walked + seg_len >= target:
+            t = (target - walked) / seg_len
+            px = polyline[i - 1][0] + t * dx
+            py = polyline[i - 1][1] + t * dy
+            return i, (px, py)
+        walked += seg_len
+
+    return len(polyline) - 1, polyline[-1]
+
+
+def _closest_polyline_index(polyline, point):
+    best_index = 0
+    best_dist = float('inf')
+    for i, (px, py) in enumerate(polyline):
+        dist = (px - point[0]) ** 2 + (py - point[1]) ** 2
+        if dist < best_dist:
+            best_dist = dist
+            best_index = i
+    return best_index
+
+
+def _label_positions(polyline, spacing, max_labels=2):
+    polyline = _simplify_polyline(polyline)
+    if len(polyline) < 2:
+        return []
+
+    arc = _polyline_arc_length(polyline)
+    if arc < spacing:
+        return []
+
+    num_labels = min(max_labels, max(1, int(arc / spacing)))
+    positions = []
+    for k in range(num_labels):
+        target = (k + 0.5) * arc / num_labels
+        index, point = _point_at_arc_length(polyline, target)
+        positions.append((point, _closest_polyline_index(polyline, point)))
+
+    return positions
+
+
+def _point_in_expanded_bbox(x, y, bbox, padding):
+    left, top, width, height = bbox
+    return (
+        left - padding <= x <= left + width + padding
+        and top - padding <= y <= top + height + padding
+    )
+
+
+class Contour:
+    """
+    A class used to represent a Contour.
+    
+    Parameters
+    ----------
+    func3D : FunctionType
+        A function that represents the 3D function to be contoured.
+    a : Union[int, float], optional
+        The starting value for the contour range (default is -20).
+    b : Union[int, float], optional
+        The ending value for the contour range (default is 20).
+    steps : Union[int, float], optional
+        The number of steps in the contour (default is 15).
+    colorMap : Colormap, optional
+        The colormap to be used for the contour (default is None, which uses the standard colormap).
+    lineThickness : int, optional
+        The thickness of the contour lines (default is 10).
+    computePadding: int, optional
+        When generating the contour equations some padding can be needed to include the edges properly (default is 50).
+    label : bool, optional
+        Draw inline level labels on contour lines (default is True).
+    labelSpacing : int, optional
+        Minimum pixel spacing between labels along a contour (default is 100).
+    labelColor : tuple, optional
+        Color of inline contour labels (default is black).
+        
+    Examples
+    --------
+    >>> def example_func(x, y):
+    >>>     return x**2 + y**2
+    >>> contour = Contour(example_func)
+    >>> plt.add(contour)
+
+    """
+    
+    def __init__(
+        self,
+        func3D: FunctionType,
+        a: Union[int, float] = -20,
+        b: Union[int, float] = 20,
+        steps: Union[int, float] = 15,
+        colorMap: Colormap = None,
+        lineThickness: int = 2,
+        computePadding: int = 50,
+        label: bool = True,
+        labelSpacing: int = 100,
+        labelColor=(0, 0, 0, 255),
+    ):
+        self.batch = shapes.Batch()
+    
+        self.func = func3D
+        self.a = a
+        self.b = b
+        self.steps = steps
+
+        self.lineThickness = lineThickness
+        self.label = label
+        self.labelSpacing = labelSpacing
+        self.labelColor = to_rgba(labelColor)
+    
+        # color
+        if colorMap is None:
+            self.color = Colormaps.standard
+        else:
+            self.color = colorMap
+    
+        self.legendColor = self.color.getColor(5, -10, 10)
+
+        self.supports = [identities.XYPLOT, identities.POLAR, identities.XYZPLOT]
+
+        self.__equations = []
+
+        self.computePadding = computePadding
+
+    
+    def finalize(self, parent):
+        plot_parent = parent
+        label_parent = parent
+        if parent == identities.XYZPLOT:
+            from ...core.d3.translator import getEquivalent2DPlot
+            label_parent = getEquivalent2DPlot(parent)
+
+        for i in range(self.steps):
+            z = self.a + (self.b - self.a) * i / self.steps
+
+            eq = Equation(
+                lambda *args, z=z: z,
+                self.func,
+                color=self.color.getColor(z, self.a, self.b),
+                width=self.lineThickness,
+                computePadding=self.computePadding,
+            )
+            eq.finalize(plot_parent)
+            self.__equations.append((z, eq))
+
+        if self.label and label_parent == identities.XYPLOT:
+            self.__finalizeLabels__(label_parent)
+
+    def __finalizeLabels__(self, parent):
+        fontSize = parent.getAttr('fontSize')
+        padding = max(2, fontSize // 8)
+        label_bboxes = []
+
+        for z, eq in self.__equations:
+            label_text = _format_contour_level(z, self.a, self.b, self.steps)
+            polylines = trace_contour_polylines(eq.dotsPosAbstract, parent)
+            polylines = sorted(
+                polylines,
+                key=lambda polyline: _polyline_arc_length(_simplify_polyline(polyline)),
+                reverse=True,
+            )
+            polylines = [
+                polyline
+                for polyline in polylines
+                if _polyline_arc_length(_simplify_polyline(polyline)) >= self.labelSpacing
+            ][:3]
+
+            for polyline in polylines:
+                for point, index in _label_positions(polyline, self.labelSpacing):
+                    angle = contour_label_angle(polyline, index)
+                    text = Text(
+                        label_text,
+                        int(point[0]),
+                        int(point[1]),
+                        fontSize=fontSize,
+                        color=self.labelColor,
+                        rotate=int(angle),
+                        anchor_x='center',
+                        anchor_y='center',
+                    )
+
+                    left, top = text.getLeftTopPos()
+                    shapes.Rectangle(
+                        left - padding,
+                        top - padding,
+                        text.width + 2 * padding,
+                        text.height + 2 * padding,
+                        color=WHITE,
+                        batch=self.batch,
+                    )
+                    text.batch = self.batch
+                    self.batch.add(text)
+
+                    label_bboxes.append(text.getBoundingBox())
+
+        if not label_bboxes:
+            return
+
+        suppress_padding = max(4, fontSize // 4)
+        for _, eq in self.__equations:
+            for dot in eq.dots:
+                for bbox in label_bboxes:
+                    if _point_in_expanded_bbox(dot.x, dot.y, bbox, suppress_padding):
+                        dot.hide()
+                        break
+
+    
+    def push(self, x, y):
+        for _, eq in self.__equations:
+            eq.push(x, y)
+        self.batch.push(x, y)
+
+    
+    def draw(self, surface):
+        for _, eq in self.__equations:
+            eq.draw(surface)
+        self.batch.draw(surface)
+
+
+    def legend(self, text:str, symbol=symbols.LINE, color=None):
+        """
+        Adds a legend
+        
+        Parameters
+        ----------
+        text : str
+            The text to be displayed in the legend.
+        symbol : symbols, optional
+            The symbol to be used in the legend.
+        color : optional
+            The color to be used for the legend text. If not provided, the default color will be used.
+        
+        Returns
+        -------
+        self : object
+            Returns the instance of the arrow object with the updated legend.        
+        """
+
+        self.legendText = text
+        self.legendSymbol = symbol
+        if color:
+            self.legendColor = to_rgba(color)
+        return self