kaxe 1.7.0.dev0__tar.gz → 1.7.1__tar.gz

{kaxe-1.7.0.dev0/src/kaxe.egg-info → kaxe-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.7.0.dev0
+Version: 1.7.1
 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.7.0.dev0 → kaxe-1.7.1}/pyproject.toml

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

{kaxe-1.7.0.dev0 → kaxe-1.7.1}/src/kaxe/__init__.py

@@ -42,6 +42,7 @@ from .core import symbol
 from .core import Colormaps, SingleColormap, Colormap, to_rgba
 from .core.window import Window, AttrObject, AttrMap, setSetting
 from .core import Axis
+from .core.thin import thin_points
 from .project import save_project, load_project
 
 try:

{kaxe-1.7.0.dev0 → kaxe-1.7.1}/src/kaxe/chart/box.py

@@ -9,6 +9,14 @@ from ..core.symbol import symbol as symbols
 from ..core.symbol import makeSymbolShapes
 from ..core.window import Window
 
+
+def _overlay_y_offset(index, count, box_height, jitter_frac):
+    if count <= 1:
+        return 0.0
+    t = index / (count - 1)
+    return (t - 0.5) * jitter_frac * box_height
+
+
 class BoxPlot(Window):
     """
     Box plot for 1-d data 
@@ -37,6 +45,7 @@ class BoxPlot(Window):
         self.attrmap.default('symbolHeight', ComputedAttribute(lambda m: m.getAttr('lineWidth')*4))
         self.attrmap.default('fill', True)
         self.attrmap.default('lineColor', (0,0,0,255))
+        self.attrmap.default('overlayJitter', 0.8)
 
         self.attrmap.submit(Axis)
         self.attrmap.submit(Marker)
@@ -46,6 +55,7 @@ class BoxPlot(Window):
         self.maxNumber = 0
         self.maxNumberAmount = 0
         self.boxplots = []
+        self.overlays = []
         self.numberAmount = 0
 
         self.legendsLabels = []
@@ -73,11 +83,22 @@ class BoxPlot(Window):
             boxplot["whiskers"] = (leftwhisker, rightwhisker)
             boxplot["quantile"] = (leftbox, rightbox)
 
+        n_boxes = len(self.boxplots)
+        for overlay in self.overlays:
+            box = overlay["box"]
+            if box < 0 or box >= n_boxes:
+                raise ValueError(
+                    f"overlay box index {box} out of range; expected 0..{n_boxes - 1}"
+                )
+            if overlay["data"]:
+                min_ = min(min_, *overlay["data"])
+                max_ = max(max_, *overlay["data"])
+
         # important styles
         boxHeight = (self.getAttr('height')-self.getAttr('boxGap')*(len(self.boxplots)+1))/len(self.boxplots)
         lineWidth = self.getAttr('lineWidth')
         fill = self.getAttr('fill')
-
+        overlayJitter = self.getAttr('overlayJitter')
 
         self.axis.addStartAndEnd(min_, max_)
 
@@ -91,9 +112,27 @@ class BoxPlot(Window):
         self.axis.finalize(self)        
         self.axis.autoAddMarkers(self)
 
+        box_geometry = {}
+        for user_index, boxplot in enumerate(self.boxplots):
+            render_index = n_boxes - 1 - user_index
+            median = np.median(boxplot["data"])
+            _, y = self.axis.get(median)
+            y += self.getAttr('boxGap') * (render_index + 1)
+            y0 = render_index * boxHeight + y
+            y1 = (render_index + 1) * boxHeight + y
+            box_geometry[user_index] = {"centerLine": (y0 + y1) / 2}
+
         for i, label in enumerate(self.legendsLabels):
             if label: self.legendbox.add(label, color=self.boxplots[i]["color"], symbol=self.boxplots[i]["symbol"])
 
+        for overlay in self.overlays:
+            if overlay["legend"]:
+                self.legendbox.add(
+                    overlay["legend"],
+                    color=overlay["color"],
+                    symbol=overlay["symbol"],
+                )
+
         self.boxbatch = shapes.Batch()
         self.addDrawingFunction(self.boxbatch)
         
@@ -151,14 +190,31 @@ class BoxPlot(Window):
             shapes.Line(wxl, y0, wxl, y1, width=lineWidth, batch=self.boxbatch, color=lineColor)
             shapes.Line(wxr, y0, wxr, y1, width=lineWidth, batch=self.boxbatch, color=lineColor)
             
-            for i in data:
+            for value in data:
                 # Outliers: points outside the whisker range (beyond fence)
-                if i < leftwhisker or i > rightwhisker:
+                if value < leftwhisker or value > rightwhisker:
                     height = self.getAttr('symbolHeight')
                     symbol = makeSymbolShapes(boxplot["symbol"], height, color=boxplot["color"], batch=self.boxbatch)
-                    symbol.x = self.axis.get(i)[0]
+                    symbol.x = self.axis.get(value)[0]
                     symbol.y = centerLine - height/2
 
+        symbolHeight = self.getAttr('symbolHeight')
+        for overlay in self.overlays:
+            geom = box_geometry[overlay["box"]]
+            centerLine = geom["centerLine"]
+            data = overlay["data"]
+            count = len(data)
+            for j, value in enumerate(data):
+                offset = _overlay_y_offset(j, count, boxHeight, overlayJitter)
+                symbol = makeSymbolShapes(
+                    overlay["symbol"],
+                    symbolHeight,
+                    color=overlay["color"],
+                    batch=self.boxbatch,
+                )
+                symbol.x = self.axis.get(value)[0]
+                symbol.y = centerLine + offset - symbolHeight / 2
+
 
 
         # title
@@ -199,6 +255,59 @@ class BoxPlot(Window):
 
         self.boxplots.append({"data": data, "color": color, "symbol": symbol})
 
+    def overlay(
+        self,
+        data: Union[list, tuple],
+        box: int = 0,
+        color=None,
+        symbol: str = symbols.CIRCLE,
+        legend: str = None,
+    ):
+        """
+        Overlay custom points on a box plot row.
+
+        Use this to highlight subgroups within a box, each with its own color
+        and symbol. Points are jittered vertically within the target box row.
+
+        Parameters
+        ----------
+        data : list or tuple
+            Numeric x-values to plot.
+        box : int, optional
+            Index of the target box in ``add()`` order (0 = first ``add()``).
+        color : tuple, optional
+            Point color. Defaults to the next series color.
+        symbol : str, optional
+            Marker symbol. Default is circle.
+        legend : str, optional
+            Legend label for this overlay series.
+
+        Returns
+        -------
+        self
+            Returns the chart instance for chaining.
+
+        Examples
+        --------
+        >>> chart.add([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+        >>> chart.overlay([2, 3, 4], box=0, color=(220, 50, 50, 255), legend="low")
+        >>> chart.overlay([8, 9, 10], box=0, color=(50, 80, 220, 255), legend="high")
+        """
+
+        if color is None:
+            color = self.nextSeriesColor()
+
+        self.overlays.append(
+            {
+                "data": data,
+                "box": box,
+                "color": color,
+                "symbol": symbol,
+                "legend": legend,
+            }
+        )
+        return self
+
     
     def legends(self, *legends):
         """

kaxe-1.7.1/src/kaxe/core/thin.py

@@ -0,0 +1,255 @@
+"""Utilities for reducing large point series before plotting."""
+
+from typing import List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+
+from .helper import isRealNumber
+
+
+def decimate_by_distance(
+    points: Sequence[Tuple[float, float]],
+    min_distance: float,
+) -> List[Tuple[float, float]]:
+    """
+    Sequential min-distance filter on a polyline; always keeps endpoints.
+
+    Parameters
+    ----------
+    points : sequence of (x, y)
+        Points in traversal order.
+    min_distance : float
+        Minimum Euclidean distance between consecutive kept points.
+    """
+    if min_distance <= 0:
+        return list(points)
+    if len(points) < 2:
+        return list(points)
+
+    result = [points[0]]
+    last = points[0]
+    min_dist_sq = min_distance * min_distance
+
+    for point in points[1:]:
+        dx = point[0] - last[0]
+        dy = point[1] - last[1]
+        if dx * dx + dy * dy >= min_dist_sq:
+            result.append(point)
+            last = point
+
+    if result[-1] != points[-1]:
+        result.append(points[-1])
+
+    return result
+
+
+def _decimate_indices_by_distance(
+    coords: Sequence[Tuple[float, float]],
+    min_distance: float,
+) -> List[int]:
+    if len(coords) < 2:
+        return list(range(len(coords)))
+
+    kept = [0]
+    last = coords[0]
+    min_dist_sq = min_distance * min_distance
+
+    for i in range(1, len(coords)):
+        point = coords[i]
+        dx = point[0] - last[0]
+        dy = point[1] - last[1]
+        if dx * dx + dy * dy >= min_dist_sq:
+            kept.append(i)
+            last = point
+
+    if kept[-1] != len(coords) - 1:
+        kept.append(len(coords) - 1)
+
+    return kept
+
+
+def _filter_finite(
+    x: Sequence,
+    y: Sequence,
+    z: Optional[Sequence] = None,
+) -> Union[Tuple[list, list], Tuple[list, list, list]]:
+    cx, cy, cz = [], [], []
+    for i in range(len(x)):
+        if not (isRealNumber(x[i]) and isRealNumber(y[i])):
+            continue
+        if z is not None and not isRealNumber(z[i]):
+            continue
+        cx.append(x[i])
+        cy.append(y[i])
+        if z is not None:
+            cz.append(z[i])
+
+    if z is not None:
+        return cx, cy, cz
+    return cx, cy
+
+
+def _thin_every(n: int, every: int) -> List[int]:
+    if every <= 0:
+        raise ValueError("every must be a positive integer")
+    if n == 0:
+        return []
+    indices = list(range(0, n, every))
+    if indices[-1] != n - 1:
+        indices.append(n - 1)
+    return indices
+
+
+def _thin_max_points(n: int, max_points: int) -> List[int]:
+    if max_points <= 0:
+        raise ValueError("max_points must be a positive integer")
+    if n <= max_points:
+        return list(range(n))
+
+    indices = np.linspace(0, n - 1, max_points, dtype=int)
+    kept = []
+    seen = set()
+    for idx in indices:
+        i = int(idx)
+        if i not in seen:
+            seen.add(i)
+            kept.append(i)
+
+    if kept[0] != 0:
+        kept.insert(0, 0)
+    if kept[-1] != n - 1:
+        kept.append(n - 1)
+
+    return kept
+
+
+def _data_to_pixel(plot, x_val: float, y_val: float) -> Tuple[float, float]:
+    width = plot.getAttr("width")
+    height = plot.getAttr("height")
+    x0, x1, y0, y1 = plot.windowAxis[:4]
+    scale_x = width / (x1 - x0)
+    scale_y = height / (y1 - y0)
+    offset_x = x0 * scale_x
+    offset_y = y0 * scale_y
+    padding = getattr(plot, "padding", [0, 0, 0, 0])
+    px = x_val * scale_x - offset_x + padding[0]
+    py = y_val * scale_y - offset_y + padding[1]
+    return px, py
+
+
+def _ensure_plot_ready(plot) -> None:
+    if not hasattr(plot, "getAttr"):
+        raise ValueError("plot must provide getAttr() for width and height")
+    if plot.getAttr("width") is None or plot.getAttr("height") is None:
+        raise ValueError("plot must have width and height set (e.g. via theme())")
+
+    window_axis = getattr(plot, "windowAxis", None)
+    if window_axis is None or any(v is None for v in window_axis[:4]):
+        raise ValueError(
+            "plot must have fixed axis bounds (pass explicit window limits to Plot)"
+        )
+
+
+def _pixel_coords(plot, x: Sequence, y: Sequence) -> Tuple[List[int], List[Tuple[float, float]]]:
+    _ensure_plot_ready(plot)
+
+    indices = []
+    coords = []
+    for i, (xi, yi) in enumerate(zip(x, y)):
+        px, py = _data_to_pixel(plot, float(xi), float(yi))
+        indices.append(i)
+        coords.append((px, py))
+
+    return indices, coords
+
+
+def _subset(indices: List[int], *arrays: Sequence) -> tuple:
+    return tuple([arrays[i][j] for j in indices] for i in range(len(arrays)))
+
+
+def thin_points(
+    x,
+    y,
+    z=None,
+    *,
+    every: Optional[int] = None,
+    min_distance: Optional[float] = None,
+    max_points: Optional[int] = None,
+    space: str = "data",
+    plot=None,
+) -> tuple:
+    """
+    Reduce a large point series before plotting.
+
+    Provide exactly one of ``every``, ``min_distance``, or ``max_points``.
+
+    Parameters
+    ----------
+    x, y : array-like
+        Point coordinates in input order.
+    z : array-like, optional
+        Optional third coordinate; thinned with the same indices as x and y.
+    every : int, optional
+        Keep every nth point by index (always keeps first and last).
+    min_distance : float, optional
+        Keep points at least this far apart. Uses data coordinates by default;
+        with ``space="pixel"``, distance is measured in screen pixels.
+    max_points : int, optional
+        Cap the number of points via uniform index sampling (always keeps
+        first and last when possible).
+    space : str, optional
+        ``"data"`` (default) or ``"pixel"``. Only affects ``min_distance``.
+    plot : plot window, optional
+        Required when ``space="pixel"`` and ``min_distance`` is set. Must have
+        fixed axis bounds and width/height (e.g. ``kaxe.Plot([x0, x1, y0, y1])``
+        with ``theme()`` applied).
+
+    Returns
+    -------
+    tuple
+        ``(x, y)`` or ``(x, y, z)`` with the thinned coordinates.
+    """
+    modes = [
+        every is not None,
+        min_distance is not None,
+        max_points is not None,
+    ]
+    if sum(modes) != 1:
+        raise ValueError("Exactly one of every, min_distance, or max_points must be provided")
+
+    if space not in ("data", "pixel"):
+        raise ValueError('space must be "data" or "pixel"')
+
+    if z is None:
+        cx, cy = _filter_finite(x, y)
+        cz = None
+    else:
+        cx, cy, cz = _filter_finite(x, y, z)
+
+    n = len(cx)
+    if n == 0:
+        return (cx, cy, cz) if cz is not None else (cx, cy)
+
+    if every is not None:
+        kept = _thin_every(n, every)
+    elif max_points is not None:
+        kept = _thin_max_points(n, max_points)
+    else:
+        if min_distance <= 0:
+            raise ValueError("min_distance must be positive")
+        if space == "pixel":
+            if plot is None:
+                raise ValueError('plot is required when space="pixel"')
+            data_indices, coords = _pixel_coords(plot, cx, cy)
+            if len(coords) < 2:
+                kept = data_indices
+            else:
+                local_kept = _decimate_indices_by_distance(coords, min_distance)
+                kept = [data_indices[i] for i in local_kept]
+        else:
+            coords = [(float(cx[i]), float(cy[i])) for i in range(n)]
+            kept = _decimate_indices_by_distance(coords, min_distance)
+
+    if cz is not None:
+        return _subset(kept, cx, cy, cz)
+    return _subset(kept, cx, cy)

{kaxe-1.7.0.dev0 → kaxe-1.7.1}/src/kaxe/objects/d2/inequality.py

@@ -4,6 +4,7 @@ from ...core.shapes import shapes
 from ...core.color import to_rgba
 from ...core.symbol import symbol
 from ...core.helper import isRealNumber
+from ...core.thin import decimate_by_distance
 from ...plot import identities
 from .equation import Equation, trace_contour_polylines
 
@@ -50,27 +51,10 @@ def _eval_diff(parent, left, right, px, py):
 def _boundary_band_points(boundary, parent):
     points = []
     for polyline in trace_contour_polylines(boundary.dotsPosAbstract, parent):
-        points.extend(_decimate_polyline(polyline, min_step=8))
+        points.extend(decimate_by_distance(polyline, 8))
     return points
 
 
-def _decimate_polyline(polyline, min_step=8):
-    if len(polyline) < 2:
-        return polyline
-    result = [polyline[0]]
-    last = polyline[0]
-    min_step_sq = min_step * min_step
-    for point in polyline[1:]:
-        dx = point[0] - last[0]
-        dy = point[1] - last[1]
-        if dx * dx + dy * dy >= min_step_sq:
-            result.append(point)
-            last = point
-    if result[-1] != polyline[-1]:
-        result.append(polyline[-1])
-    return result
-
-
 def _build_band_cells(points, band, x0, y0, x1, y1):
     cell = max(1, int(band / 2))
     reach = band + cell * 0.7071067811865476

{kaxe-1.7.0.dev0 → kaxe-1.7.1/src/kaxe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.7.0.dev0
+Version: 1.7.1
 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.7.0.dev0 → kaxe-1.7.1}/src/kaxe.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ src/kaxe/core/svg.py
 src/kaxe/core/svg_pdf.py
 src/kaxe/core/symbol.py
 src/kaxe/core/text.py
+src/kaxe/core/thin.py
 src/kaxe/core/window.py
 src/kaxe/core/d3/backend.py
 src/kaxe/core/d3/camera.py