kaxe 1.6.2.dev0__tar.gz → 1.7.0__tar.gz

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

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

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

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/chart/bar.py

@@ -1,7 +1,7 @@
 
 from ..core.helper import *
 from ..core.axis import *
-from ..core.styles import getRandomColor, isLightOrDark
+from ..core.styles import isLightOrDark
 from ..core.symbol import symbol
 from ..core.window import Window
 from ..objects.d2.pillar import Pillars
@@ -90,7 +90,7 @@ class Bar(Window):
     def __getColors__(self):
         self.colors = self.getAttr('barColor')
         if self.colors == None:
-            self.colors = [getRandomColor() for _ in range(self.maxNumberAmount)]
+            self.colors = [self.nextSeriesColor() for _ in range(self.maxNumberAmount)]
         elif type(self.colors[0]) is int:
             self.colors = [self.colors]
         

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

@@ -4,7 +4,7 @@ from ..core.helper import *
 import logging
 from ..core.axis import *
 from ..plot.zoom_connector import compute_boxplot_whiskers
-from ..core.styles import getRandomColor, isLightOrDark
+from ..core.styles import isLightOrDark
 from ..core.symbol import symbol as symbols
 from ..core.symbol import makeSymbolShapes
 from ..core.window import Window
@@ -195,7 +195,7 @@ class BoxPlot(Window):
         """
 
         if color is None:
-            color = getRandomColor()
+            color = self.nextSeriesColor()
 
         self.boxplots.append({"data": data, "color": color, "symbol": symbol})
 

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/chart/pie.py

@@ -7,7 +7,7 @@ from ..core.helper import *
 import logging
 from ..core.axis import *
 from ..core.window import Window
-from ..core.styles import getRandomColor, isLightOrDark
+from ..core.styles import isLightOrDark
 from ..core.symbol import symbol
 
 XYPLOT = 'xy'
@@ -135,7 +135,7 @@ class Pie(Window):
 
         colors = self.getAttr('pieColor')
         if colors == None:
-            colors = [getRandomColor() for _ in range(self.pieslices)]
+            colors = [self.nextSeriesColor() for _ in range(self.pieslices)]
         elif type(colors[0]) is int:
             colors = [colors]
 

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/chart/qqplot.py

@@ -4,7 +4,6 @@ import numpy as np
 import statistics
 from ..objects.point import Points2D
 from ..objects.function import Function2D
-from ..core.styles import getRandomColor
 from ..core.symbol import symbol
 
 
@@ -40,12 +39,7 @@ class QQPlot(BoxedPlot):
     def __init__(self, data, quantiles:list=None, color:list=[None, None], size=50):
         
         self.size = size
-
-        self.color = color
-        if color[0] is None:
-            self.color[0] = getRandomColor()
-        if color[1] is None:
-            self.color[1] = getRandomColor()
+        self._pending_colors = list(color)
 
         data = sorted(data)
 
@@ -57,6 +51,13 @@ class QQPlot(BoxedPlot):
 
         super().__init__()
 
+        self.color = self._pending_colors
+        if self.color[0] is None:
+            self.color[0] = self.nextSeriesColor()
+        if self.color[1] is None:
+            self.color[1] = self.nextSeriesColor()
+        del self._pending_colors
+
         points = self.points = self.add(Points2D(
             self.quantiles, 
             self.data, 

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

@@ -1,7 +1,7 @@
 
 from .helper import intersectLines
 from .shapes import shapes
-from .symbol import CustomSymbol, symbol
+from .symbol import symbol
 from .styles import resetColor, setDefaultColors, getRandomColor
 from .axis import Axis
 from .round import koundTeX

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/core/color.py

@@ -231,6 +231,9 @@ class SingleColormap(Colormap):
         super().__init__(arr)
 
 
+from .palette import DEFAULT_SEQUENTIAL_STEPS
+
+
 class Colormaps:
     """
     A collection of predefined colormaps for various color schemes.
@@ -238,7 +241,7 @@ class Colormaps:
     Attributes
     ----------
     standard : Colormap
-        A colormap with a standard set of colors.
+        Default sequential colormap (blue to green, colorblind-safe).
     green : Colormap
         A colormap with various shades of green.
     brown : Colormap
@@ -254,14 +257,7 @@ class Colormaps:
     """
 
 
-    standard = Colormap([
-        "#AFE3C0",
-        "#90C290",
-        "#FF5154",
-        "#91A6FF",
-        "#FAFF7F",
-        "#ED7D3A",
-    ])
+    standard = Colormap(DEFAULT_SEQUENTIAL_STEPS)
     green = Colormap([
         "#004b23",
         "#006400",

kaxe-1.7.0/src/kaxe/core/palette.py

@@ -0,0 +1,42 @@
+"""Default color palettes for Kaxe figures.
+
+Series colors follow the Okabe–Ito palette (colorblind-safe, common in
+publication figures). See: https://jfly.uni-koeln.de/color/
+
+Pure black is omitted from the series cycle; it remains reserved for axes,
+ticks, and text ink.
+"""
+
+from __future__ import annotations
+
+from .color import to_rgba
+
+# Okabe–Ito categorical series (7 colors; black excluded from data series).
+OKABE_ITO_SERIES = [
+    "#E69F00",  # orange
+    "#56B4E9",  # sky blue
+    "#009E73",  # bluish green
+    "#F0E442",  # yellow
+    "#0072B2",  # blue
+    "#D55E00",  # vermillion
+    "#CC79A7",  # reddish purple
+]
+
+# Sequential ramp for heatmaps, contours, and color scales (blue → green).
+DEFAULT_SEQUENTIAL_STEPS = [
+    "#0072B2",
+    "#2088A8",
+    "#329E96",
+    "#009E73",
+    "#3CB371",
+    "#56B4E9",
+]
+
+DEFAULT_SERIES_COLORS = [to_rgba(c) for c in OKABE_ITO_SERIES]
+
+
+def apply_series_palette(color_list: list | None = None) -> list[tuple[int, int, int, int]]:
+    """Normalize a color list to RGBA tuples, or return the default series palette."""
+    if color_list is None:
+        return list(DEFAULT_SERIES_COLORS)
+    return [to_rgba(c) for c in color_list]

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/core/styles.py

@@ -4,41 +4,95 @@ from types import MappingProxyType, FunctionType
 import math
 
 from .color import is_color_attr
+from .palette import DEFAULT_SERIES_COLORS, apply_series_palette
 
 # COLORS
 WHITE = (255,255,255,255)
 BLACK = (0,0,0,255)
 
 colorNum = -1
+colors = list(DEFAULT_SERIES_COLORS)
+
+
+def _series_palette() -> list:
+    return colors
+
+
+def _palette_color_at(index: int) -> tuple:
+    palette = _series_palette()
+    return palette[index % len(palette)]
+
+
 def getRandomColor() -> tuple:
-    """Return the next color from Kaxe's default color cycle.
+    """Return the next color from Kaxe's default series palette.
 
-    Colors rotate through the built-in palette. Call :func:`resetColor` to
-    restart the cycle from the first color.
+    Colors rotate through the built-in Okabe–Ito palette. Each plot window
+    maintains its own cycle for objects added without an explicit color; this
+    global function is for manual use (e.g. ``color=kaxe.getRandomColor()``).
+    Call :func:`resetColor` to restart the global cycle manually.
 
     Returns
     -------
     tuple
-        RGBA color tuple, e.g. ``(222, 107, 72, 255)``.
+        RGBA color tuple, e.g. ``(230, 159, 0, 255)``.
     """
     global colorNum
-    colorNum+=1
-    return colors[colorNum%(len(colors))]
+    colorNum += 1
+    return _palette_color_at(colorNum)
+
 
 def resetColor() -> None:
-    """
-    Resets the global color number to its initial state.
-    This function sets the global variable `colorNum` to -1, effectively
-    resetting any color-related state that depends on this variable.
+    """Reset the global series color cycle to before the first palette color."""
+    global colorNum
+    colorNum = -1
 
-    Note
-    ----
-    This resets all plot color progress
 
-    """
+def _apply_function2d_color(obj, color: tuple) -> None:
+    from .color import to_rgba
+    obj.color = to_rgba(color)
+    obj.legendColor = obj.color
+    if len(obj.color) > 3:
+        obj.fillcolor = (*obj.color[:3], int(obj.color[3] * 0.5))
+    else:
+        obj.fillcolor = (*obj.color, 175)
 
-    global colorNum
-    colorNum = -1
+
+def _apply_fill_color(obj, color: tuple) -> None:
+    from .color import to_rgba
+    rgba = list(to_rgba(color))
+    if len(rgba) > 3:
+        rgba[3] = 100
+    else:
+        rgba.append(100)
+    obj.color = tuple(rgba)
+    obj.legendColor = obj.color
+
+
+def assign_series_color(plot, obj) -> None:
+    """Assign the next series palette color from *plot* when the object defers color."""
+    if getattr(obj, 'randomColor', False):
+        count = getattr(obj, '_autoColorCount', 1)
+        obj.color = [plot.nextSeriesColor() for _ in range(count)]
+        obj.legendColor = obj.color[0]
+        obj.randomColor = False
+        return
+
+    if not getattr(obj, '_autoSeriesColor', False):
+        return
+
+    color = plot.nextSeriesColor()
+    obj._autoSeriesColor = False
+
+    if type(obj).__name__ == 'Function2D':
+        _apply_function2d_color(obj, color)
+    elif type(obj).__name__ == 'Fill':
+        _apply_fill_color(obj, color)
+    else:
+        from .color import Colormap, to_rgba
+        obj.color = to_rgba(color)
+        obj.legendColor = obj.color
+        if type(obj.color) is Colormap:
+            obj.legendColor = obj.color.getColor(0, 1, 2)
 
 
 def isLightOrDark(rgbColor=[0,128,255,255]):
@@ -49,36 +103,17 @@ def isLightOrDark(rgbColor=[0,128,255,255]):
     return False
 
 
-colors = [
-    (222,107,72, 255),
-    (91,200,175, 255),
-    (6,71,137, 255),
-    (8,45,15, 255),
-    # (247,197,72, 255),
-    (251, 111, 146),
-    (0, 53,102),
-    (188, 108,37),
-    (33, 104, 105),
-]
-
 def setDefaultColors(colorList:list):
-    """
-    Set the global default colors for all plots
-    
+    """Replace the global default series palette.
+
     Parameters
     ----------
     colorList : list
-        A list of colors to be set as the default colors. Entries may be RGBA
-        tuples or hex/named color strings (see :func:`kaxe.to_rgba`).
-    
-    Notes
-    -----
-    This function sets the global variable `colors` to the provided list of colors.
+        Colors for the series cycle. Entries may be RGBA tuples or hex/named
+        color strings (see :func:`kaxe.to_rgba`).
     """
-    from .color import to_rgba
-
     global colors
-    colors = [to_rgba(c) for c in colorList]
+    colors = apply_series_palette(colorList)
 
 
 class bcolors:

kaxe-1.7.0/src/kaxe/core/symbol.py

@@ -0,0 +1,140 @@
+
+import math
+
+from .shapes import Batch, Line, Shape, shapes
+
+
+class SymbolGroup(Shape):
+    """Composite symbol built from shapes in a size×size local box."""
+
+    def __init__(self, size: int, parts: list, batch: Batch = None):
+        self.size = int(size)
+        self.parts = parts
+        self.x = 0
+        self.y = 0
+        self.batch = batch
+        super().__init__()
+        if batch:
+            batch.add(self)
+
+    def getBoundingBox(self):
+        return [self.size, self.size]
+
+    def centerAlign(self):
+        self.x -= self.size / 2
+        self.y -= self.size / 2
+
+    def push(self, x, y):
+        self.x += x
+        self.y += y
+
+    def _offset_part(self, part, dx, dy):
+        if isinstance(part, Line):
+            part.push(dx, dy)
+        else:
+            part.x += dx
+            part.y += dy
+
+    def _restore_part(self, part, dx, dy):
+        if isinstance(part, Line):
+            part.push(-dx, -dy)
+        else:
+            part.x -= dx
+            part.y -= dy
+
+    def _draw_parts(self, draw_fn):
+        for part in self.parts:
+            self._offset_part(part, self.x, self.y)
+            draw_fn(part)
+            self._restore_part(part, self.x, self.y)
+
+    def drawPillow(self, surface):
+        self._draw_parts(lambda part: part.drawPillow(surface))
+
+    def drawSvg(self, doc):
+        self._draw_parts(lambda part: part.drawSvg(doc))
+
+
+# SYMBOLS
+class symbol:
+    CIRCLE = 'o'
+    LINE = 'LINE'
+    TRIANGLE = 'TRI'
+    STAR = 'STAR'
+    RECTANGLE = "RECT"
+    LOLLIPOP = 'LOLLIPOP'
+    THICKLINE = 'THICKLINE'
+    CROSS = "CROSS"
+    DONUT = "DONUT"
+
+
+def _triangle_symbol(size: int, color: tuple, batch: Batch):
+    return SymbolGroup(
+        size,
+        [shapes.Polygon((size / 2, 0), (0, size), (size, size), color=color, batch=None)],
+        batch=batch,
+    )
+
+
+def _star_symbol(size: int, color: tuple, batch: Batch):
+    cx = cy = size / 2
+    outer_r = size / 2
+    inner_r = outer_r * 0.4
+    points = []
+    for i in range(10):
+        angle = math.pi / 2 + i * math.pi / 5
+        radius = outer_r if i % 2 == 0 else inner_r
+        points.append((cx + radius * math.cos(angle), cy - radius * math.sin(angle)))
+    return SymbolGroup(size, [shapes.Polygon(*points, color=color, batch=None)], batch=batch)
+
+
+def _cross_symbol(size: int, color: tuple, batch: Batch):
+    thickness = max(1, int(size / 6))
+    parts = [
+        Line(0, 0, size, size, color=color, width=thickness, batch=None),
+        Line(size, 0, 0, size, color=color, width=thickness, batch=None),
+    ]
+    return SymbolGroup(size, parts, batch=batch)
+
+
+def _lollipop_symbol(size: int, color: tuple, batch: Batch):
+    stem_h = max(1, size // 4)
+    stem_y = (size - stem_h) // 2
+    head_r = max(1, size // 3)
+    stem_w = max(1, size - head_r)
+    parts = [
+        shapes.Rectangle(0, stem_y, stem_w, stem_h, color=color, batch=None),
+        shapes.Circle(size - head_r, size // 2, head_r, color=color, batch=None, cornerAlign=False),
+    ]
+    return SymbolGroup(size, parts, batch=batch)
+
+
+def makeSymbolShapes(symb: str, height: int, color: tuple, batch):
+    size = int(height)
+    if symb == symbol.LINE:
+        return shapes.Rectangle(0, 0, size, size / 6, color=color, batch=batch)
+    if symb == symbol.THICKLINE:
+        return shapes.Rectangle(0, 0, size, size / 2, color=color, batch=batch)
+    if symb == symbol.RECTANGLE:
+        return shapes.Rectangle(0, 0, size, size, color=color, batch=batch)
+    if symb == symbol.CIRCLE:
+        return shapes.Circle(0, 0, int(size / 2), cornerAlign=True, color=color, batch=batch)
+    if symb == symbol.TRIANGLE:
+        return _triangle_symbol(size, color, batch)
+    if symb == symbol.STAR:
+        return _star_symbol(size, color, batch)
+    if symb == symbol.LOLLIPOP:
+        return _lollipop_symbol(size, color, batch)
+    if symb == symbol.CROSS:
+        return _cross_symbol(size, color, batch)
+    if symb == symbol.DONUT:
+        return shapes.Circle(
+            0,
+            0,
+            int(size / 2),
+            cornerAlign=True,
+            fill=False,
+            width=max(1, size // 8),
+            color=color,
+            batch=batch,
+        )

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/core/window.py

@@ -10,6 +10,7 @@ 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 .styles import assign_series_color, _palette_color_at
 from PIL import Image
 
 
@@ -112,6 +113,7 @@ class Window(AttrObject):
         bottom to top is always positive
         """
         super().__init__()
+        self._seriesColorNum = -1
         self.identity = None
         
         self.attrmap = AttrMap()
@@ -486,6 +488,7 @@ class Window(AttrObject):
 
     # enables this code to be manipulated with in other subclasses
     def __callFinalizeObject__(self, obj):
+        self._assignSeriesColor(obj)
         obj.finalize(self)
 
     def __addInnerContent__(self):
@@ -674,6 +677,16 @@ class Window(AttrObject):
     def addDrawingFunction(self, shape, z=0):
         self.shapes.append((shape, z))
 
+    def nextSeriesColor(self) -> tuple:
+        self._seriesColorNum += 1
+        return _palette_color_at(self._seriesColorNum)
+
+    def resetSeriesColors(self) -> None:
+        self._seriesColorNum = -1
+
+    def _assignSeriesColor(self, obj) -> None:
+        assign_series_color(self, obj)
+
     # api
     def add(self, obj):
         """
@@ -691,6 +704,7 @@ class Window(AttrObject):
         """
 
         if self.identity in obj.supports:
+            self._assignSeriesColor(obj)
             self.objects.append(obj)
         else:
             logging.error(f'{obj}, is not supported in {self}')

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/objects/d2/__init__.py

@@ -10,3 +10,4 @@ from .arrow import Arrow
 from .bubble import Bubble
 from .contour import Contour
 from .fill import Fill
+from .guide_grid import PolarGuideGrid

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/objects/d2/arrow.py

@@ -45,8 +45,10 @@ class Arrow:
     
         # color
         if color is None:
-            self.color = getRandomColor()
+            self.color = None
+            self._autoSeriesColor = True
         else:
+            self._autoSeriesColor = False
             self.color = to_rgba(color)
     
         self.legendColor = self.color

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/objects/d2/equation.py

@@ -1,6 +1,5 @@
 
 from ...core.shapes import shapes
-from ...core.styles import getRandomColor
 from ...core.color import to_rgba
 from ...core.symbol import symbol
 from ...plot import identities
@@ -141,10 +140,12 @@ class Equation:
         
         self.width = width
         if color is None:
-            self.color = getRandomColor()
+            self.color = None
+            self._autoSeriesColor = True
         else:
+            self._autoSeriesColor = False
             self.color = to_rgba(color)
-        self.legendColor = self.color # default
+        self.legendColor = self.color
         
         self.dots = []
         self.dotsPosAbstract = set()

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/objects/d2/fill.py

@@ -51,16 +51,13 @@ class Fill:
 
         # color
         if color is None:
-            self.color = list(getRandomColor())
-            if len(self.color) > 3:
-                self.color[3] = 100
-            else:
-                self.color.append(100)
-            self.color = tuple(self.color)
+            self.color = None
+            self._autoSeriesColor = True
+            self.legendColor = None
         else:
+            self._autoSeriesColor = False
             self.color = to_rgba(color)
-    
-        self.legendColor = self.color
+            self.legendColor = self.color
 
         self.supports = [identities.XYPLOT]
 

{kaxe-1.6.2.dev0 → kaxe-1.7.0}/src/kaxe/objects/d2/function.py

@@ -1,7 +1,7 @@
 
 from typing import Callable, Optional, Sequence, Tuple, Union
 from .point import Points2D
-from ...core.styles import getRandomColor
+from ...core.styles import _apply_function2d_color
 from ...core.color import to_rgba
 from ...core.helper import *
 from ...core.shapes import shapes
@@ -86,20 +86,17 @@ class Function2D:
         self.dashed = dashed
 
         if color is None:
-            self.color = getRandomColor()
+            self.color = None
+            self._autoSeriesColor = True
         else:
-            self.color = to_rgba(color)
-        self.legendColor = self.color
+            self._autoSeriesColor = False
+            _apply_function2d_color(self, to_rgba(color))
 
         self.legendSymbol = symbol.LINE
         if self.dotted:
             self.legendSymbol = symbol.CIRCLE
 
         self.thickness = width
-        if len(self.color) > 3:
-            self.fillcolor = (*self.color[:3], int(self.color[3]*0.5))
-        else:
-            self.fillcolor = (*self.color, 175)
 
         self.otherArgs = args
         self.otherKwargs = kwargs