kaxe 1.4.6.dev0__tar.gz → 1.4.8__tar.gz

{kaxe-1.4.6.dev0/src/kaxe.egg-info → kaxe-1.4.8}/PKG-INFO

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

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

kaxe-1.4.8/src/kaxe/core/bounds.py

@@ -0,0 +1,143 @@
+"""Coarse sampling helpers for auto-scaling plot windows from functions."""
+
+import math
+from typing import Callable, Optional, Sequence, Tuple
+
+import numpy as np
+
+from .helper import isRealNumber
+
+DEFAULT_DOMAIN_1D = (-10.0, 10.0)
+DEFAULT_DOMAIN_2D = (-10.0, 10.0, -10.0, 10.0)
+DEFAULT_MARGIN = 0.05
+BOUNDS_SAMPLES_1D = 128
+BOUNDS_SAMPLES_2D = 32
+
+
+def is_finite(value) -> bool:
+    return isRealNumber(value) and math.isfinite(value)
+
+
+def apply_margin(lo: float, hi: float, fraction: float = DEFAULT_MARGIN) -> Tuple[float, float]:
+    if lo == hi:
+        return lo - 1.0, hi + 1.0
+    span = hi - lo
+    pad = span * fraction
+    return lo - pad, hi + pad
+
+
+def resolve_interval(
+    user_domain: Optional[Sequence[float]],
+    plot_lo,
+    plot_hi,
+    default: Tuple[float, float],
+) -> Tuple[float, float]:
+    if plot_lo is not None and plot_hi is not None:
+        return float(plot_lo), float(plot_hi)
+    if user_domain is not None:
+        return float(user_domain[0]), float(user_domain[1])
+    return default
+
+
+def sample_1d(
+    f: Callable,
+    x0: float,
+    x1: float,
+    n: int = BOUNDS_SAMPLES_1D,
+) -> Tuple[Optional[float], Optional[float], Optional[float], Optional[float]]:
+    if x0 == x1:
+        x0 -= 0.5
+        x1 += 0.5
+
+    xs = np.linspace(x0, x1, n)
+    ys = []
+    for x in xs:
+        try:
+            y = f(float(x))
+        except Exception:
+            continue
+        if is_finite(y):
+            ys.append(float(y))
+
+    if not ys:
+        return None, None, None, None
+
+    return float(x0), float(x1), min(ys), max(ys)
+
+
+def sample_2d(
+    f: Callable,
+    x0: float,
+    x1: float,
+    y0: float,
+    y1: float,
+    n: int = BOUNDS_SAMPLES_2D,
+) -> Tuple[
+    Optional[float],
+    Optional[float],
+    Optional[float],
+    Optional[float],
+    Optional[float],
+    Optional[float],
+]:
+    if x0 == x1:
+        x0 -= 0.5
+        x1 += 0.5
+    if y0 == y1:
+        y0 -= 0.5
+        y1 += 0.5
+
+    xs = np.linspace(x0, x1, n)
+    ys = np.linspace(y0, y1, n)
+    x_grid, y_grid = np.meshgrid(xs, ys, indexing="ij")
+
+    zs = []
+    try:
+        z_vals = np.asarray(f(x_grid, y_grid), dtype=np.float64)
+        if z_vals.shape == x_grid.shape and np.issubdtype(z_vals.dtype, np.floating):
+            for z in z_vals.ravel():
+                if is_finite(z):
+                    zs.append(float(z))
+    except Exception:
+        for x in xs:
+            for y in ys:
+                try:
+                    z = f(float(x), float(y))
+                except Exception:
+                    continue
+                if is_finite(z):
+                    zs.append(float(z))
+
+    if not zs:
+        return None, None, None, None, None, None
+
+    return float(x0), float(x1), float(y0), float(y1), min(zs), max(zs)
+
+
+def sample_polar_1d(
+    f: Callable,
+    n: int = BOUNDS_SAMPLES_1D,
+) -> Tuple[Optional[float], Optional[float]]:
+    rs = []
+    for i in range(n):
+        theta = 2.0 * math.pi * i / n
+        try:
+            r = f(theta)
+        except Exception:
+            continue
+        if is_finite(r):
+            rs.append(float(r))
+
+    if not rs:
+        return None, None
+
+    r_min = min(0.0, min(rs))
+    r_max = max(rs)
+    return apply_margin(r_min, r_max)
+
+
+def append_axis_values(values: list, lo, hi):
+    if lo is not None:
+        values.append(lo)
+    if hi is not None:
+        values.append(hi)

{kaxe-1.4.6.dev0 → kaxe-1.4.8}/src/kaxe/core/d3/openglrender.py

@@ -13,7 +13,6 @@ from .objects.line import Line3D, FlatLine3D, Line3DObject, FlatLine3DObject
 from .objects.point import Point3D, Point3DObject
 import psutil
 process = psutil.Process()
-import sys
 import sdl2
 import sdl2.ext
 import sdl2.video
@@ -994,14 +993,12 @@ class OpenGLRender:
             lasttime = time.time()
             while sdl2.SDL_PollEvent(event):
                 if event.type == sdl2.SDL_QUIT:
-                    running = False
                     self.quit(gl_context, window)
-                    sys.exit()
+                    return
                 elif event.type == sdl2.SDL_KEYDOWN:
                     if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
                         self.quit(gl_context, window)
-                        running = False
-                        sys.exit()
+                        return
                     
                     if event.key.keysym.sym == sdl2.SDLK_RETURN and (event.key.keysym.mod & sdl2.KMOD_ALT):
                         # Toggle fullscreen on Alt+Enter

{kaxe-1.4.6.dev0 → kaxe-1.4.8}/src/kaxe/core/window.py

@@ -268,23 +268,27 @@ class Window(AttrObject):
         if len(self.windowAxis) != 6:
             [self.windowAxis.append(None) for _ in range(6 - len(self.windowAxis))]
 
-        # har ingen effekt på 3D
         if sorted(self.windowAxis, key=lambda x: x==None)[-1] == None:
             x = []
             y = []
             z = []
             for i in self.objects:
-                if hasattr(i, 'bounds'):
-                    bounds = i.bounds()
-                    x.append(bounds[0])
-                    x.append(bounds[1])
-                    y.append(bounds[2])
-                    y.append(bounds[3])
-                    try:
-                        z.append(bounds[4])
-                        z.append(bounds[5])
-                    except IndexError as e:
-                        pass
+                bounds_fn = getattr(i, 'bounds', None)
+                if callable(bounds_fn):
+                    bounds = bounds_fn(plot_window=self.windowAxis, plot=self)
+                    if bounds:
+                        if bounds[0] is not None:
+                            x.append(bounds[0])
+                        if len(bounds) > 1 and bounds[1] is not None:
+                            x.append(bounds[1])
+                        if len(bounds) > 2 and bounds[2] is not None:
+                            y.append(bounds[2])
+                        if len(bounds) > 3 and bounds[3] is not None:
+                            y.append(bounds[3])
+                        if len(bounds) > 4 and bounds[4] is not None:
+                            z.append(bounds[4])
+                        if len(bounds) > 5 and bounds[5] is not None:
+                            z.append(bounds[5])
                     continue
 
                 try:

{kaxe-1.4.6.dev0 → kaxe-1.4.8}/src/kaxe/objects/d2/function.py

@@ -1,5 +1,5 @@
 
-from typing import Callable
+from typing import Callable, Optional, Sequence, Tuple, Union
 from .point import Points2D
 from ...core.styles import getRandomColor
 from ...core.color import to_rgba
@@ -7,9 +7,16 @@ from ...core.helper import *
 from ...core.shapes import shapes
 from ...core.symbol import symbol
 from ...core.helper import isRealNumber
+from ...core.bounds import (
+    DEFAULT_DOMAIN_1D,
+    DEFAULT_MARGIN,
+    apply_margin,
+    resolve_interval,
+    sample_1d,
+    sample_polar_1d,
+)
 from ...plot import identities
 from random import randint
-from typing import Union
 
 class Function2D:
     """
@@ -30,6 +37,11 @@ class Function2D:
         If greater than 0, the function plot line will be dotted with the specified distance between dots. Default is 0.
     dashed : int, optional
         If greater than 0, the function plot line will be dashed with the specified distance between dashes. Default is 0.
+    domain : tuple, optional
+        Sampling interval ``(x0, x1)`` for auto-scaled x when the plot window
+        does not fix x. Default is ``(-10, 10)``.
+    range : tuple, optional
+        Fixed output interval ``(y0, y1)`` for the y axis when auto-scaling.
     args : tuple, optional
         Additional positional arguments to be passed to the function f.
     kwargs : dict, optional
@@ -56,6 +68,8 @@ class Function2D:
                  width:int=10,
                  dotted:int=0,
                  dashed:int=0,
+                 domain:Optional[Sequence[float]]=None,
+                 range:Optional[Sequence[float]]=None,
                  *args, 
                  **kwargs
                 ):
@@ -90,9 +104,75 @@ class Function2D:
         self.otherArgs = args
         self.otherKwargs = kwargs
 
+        self.domain = tuple(domain) if domain is not None else None
+        self.range = tuple(range) if range is not None else None
+
         self.supports = [identities.XYPLOT, identities.POLAR, identities.LOGPLOT]
 
 
+    def _call(self, x):
+        return self.function(x, *self.otherArgs, **self.otherKwargs)
+
+    def bounds(self, plot_window=None, plot=None):
+        """
+        Estimate data bounds for auto-scaling.
+
+        Returns up to six values ``[x0, x1, y0, y1, z0, z1]``. Entries are
+        ``None`` when that axis is fixed by the plot window or not applicable.
+        """
+        if plot_window is None and plot is not None:
+            plot_window = getattr(plot, 'windowAxis', None)
+
+        plot_identity = getattr(plot, 'identity', None) if plot is not None else None
+        first_axis_log = getattr(plot, 'firstAxisLog', False) if plot is not None else False
+        second_axis_log = getattr(plot, 'secondAxisLog', False) if plot is not None else False
+
+        if plot_identity == identities.POLAR:
+            wa = plot_window or [None, None]
+            if wa[0] is not None and wa[1] is not None:
+                return [wa[0], wa[1], None, None]
+            r0, r1 = sample_polar_1d(self._call)
+            if r0 is None:
+                return [None, None, None, None]
+            return [r0, r1, None, None]
+
+        wa = list(plot_window or [None, None, None, None])
+        while len(wa) < 4:
+            wa.append(None)
+
+        default_x = (0.01, 10.0) if first_axis_log else DEFAULT_DOMAIN_1D
+        x0, x1 = resolve_interval(self.domain, wa[0], wa[1], default_x)
+        if first_axis_log and x0 <= 0:
+            x0 = 0.01
+
+        auto_x = wa[0] is None or wa[1] is None
+        auto_y = wa[2] is None or wa[3] is None
+
+        if self.range is not None:
+            y0, y1 = float(self.range[0]), float(self.range[1])
+        elif auto_y:
+            _, _, y0, y1 = sample_1d(self._call, x0, x1)
+            if y0 is None:
+                return [None, None, None, None]
+            if second_axis_log:
+                if y0 <= 0:
+                    y0 = 0.01
+                if y1 <= 0:
+                    y1 = 0.01
+            y0, y1 = apply_margin(y0, y1)
+        else:
+            y0, y1 = None, None
+
+        if auto_x:
+            x0, x1 = apply_margin(x0, x1)
+            if first_axis_log and x0 <= 0:
+                x0 = 0.01
+        else:
+            x0, x1 = None, None
+
+        return [x0, x1, y0, y1]
+
+
     def __call__(self, x):
         return self.function(x, *self.otherArgs, **self.otherKwargs)
 

{kaxe-1.4.6.dev0 → kaxe-1.4.8}/src/kaxe/objects/d3/function.py

@@ -13,6 +13,14 @@ import numpy as np
 import math
 import numbers
 import time
+from typing import Optional, Sequence
+
+from ...core.bounds import (
+    DEFAULT_DOMAIN_1D,
+    apply_margin,
+    resolve_interval,
+    sample_2d,
+)
 
 
 
@@ -75,6 +83,14 @@ class Function3D(Base3DObject):
         Whether to fill the plot. default is True
     drawDiagonalLines: bool
         Whether to draw diagonal lines in triangles when fill is False. default is False
+    domain : tuple, optional
+        Sampling interval for the two independent axes. For ``axis="xy"`` this is
+        ``(x0, x1, y0, y1)``; for ``axis="xz"`` it is ``(x0, x1, z0, z1)``; for
+        ``axis="yz"`` it is ``(y0, y1, z0, z1)``. Defaults to ``(-10, 10)`` on
+        each independent axis when the plot window does not fix them.
+    range : tuple, optional
+        Fixed interval ``(lo, hi)`` on the dependent axis (z for ``axis="xy"``,
+        y for ``axis="xz"``, x for ``axis="yz"``).
     excludeLight : bool, optional
         Whether to exclude lighting effects. Default is True.
     
@@ -93,6 +109,8 @@ class Function3D(Base3DObject):
                  drawDiagonalLines:bool=False, 
                  axis="xy", 
                  excludeLight=True,
+                 domain:Optional[Sequence[float]]=None,
+                 range:Optional[Sequence[float]]=None,
                  *args, 
                  **kwargs
         ):
@@ -106,6 +124,9 @@ class Function3D(Base3DObject):
         self.otherKwargs = kwargs
         self.excludeLight = excludeLight
 
+        self.domain = tuple(domain) if domain is not None else None
+        self.range = tuple(range) if range is not None else None
+
         self.fill = fill
         self.drawDiagonalLines = drawDiagonalLines
         
@@ -124,8 +145,80 @@ class Function3D(Base3DObject):
             self.numPoints = 25
 
 
-    
+    _AXIS_IDX = {'x': (0, 1), 'y': (2, 3), 'z': (4, 5)}
+
+    def _call(self, a, b):
+        return self.f(a, b, *self.otherArgs, **self.otherKwargs)
+
+    def _resolve_axis_interval(self, axis_name, plot_window, domain_slice):
+        lo_i, hi_i = self._AXIS_IDX[axis_name]
+        plot_lo = plot_window[lo_i] if len(plot_window) > lo_i else None
+        plot_hi = plot_window[hi_i] if len(plot_window) > hi_i else None
+        user = domain_slice if domain_slice is not None else None
+        return resolve_interval(user, plot_lo, plot_hi, DEFAULT_DOMAIN_1D)
+
+    def _axis_auto(self, axis_name, plot_window):
+        lo_i, hi_i = self._AXIS_IDX[axis_name]
+        if len(plot_window) <= hi_i:
+            return True
+        return plot_window[lo_i] is None or plot_window[hi_i] is None
+
+    def bounds(self, plot_window=None, plot=None):
+        """
+        Estimate data bounds for auto-scaling 3D plots.
+
+        Returns ``[x0, x1, y0, y1, z0, z1]`` with ``None`` for fixed axes.
+        """
+        if plot_window is None and plot is not None:
+            plot_window = getattr(plot, 'windowAxis', None)
+
+        wa = list(plot_window or [None] * 6)
+        while len(wa) < 6:
+            wa.append(None)
+
+        ind0, ind1 = self.axis[0], self.axis[1]
+        dep = self.dependantVariable
 
+        domain = self.domain
+        d0 = domain[0:2] if domain is not None else None
+        d1 = domain[2:4] if domain is not None else None
+
+        if self.axis == 'xy':
+            u_axis, v_axis = 'x', 'y'
+        elif self.axis == 'xz':
+            u_axis, v_axis = 'x', 'z'
+        else:
+            u_axis, v_axis = 'y', 'z'
+
+        u0, u1 = self._resolve_axis_interval(u_axis, wa, d0)
+        v0, v1 = self._resolve_axis_interval(v_axis, wa, d1)
+
+        result = [None] * 6
+
+        for axis_name, lo, hi in ((u_axis, u0, u1), (v_axis, v0, v1)):
+            if not self._axis_auto(axis_name, wa):
+                continue
+            lo, hi = apply_margin(lo, hi)
+            lo_i, hi_i = self._AXIS_IDX[axis_name]
+            result[lo_i] = lo
+            result[hi_i] = hi
+
+        if self.range is not None:
+            dep_lo, dep_hi = float(self.range[0]), float(self.range[1])
+        elif self._axis_auto(dep, wa):
+            _, _, _, _, dep_lo, dep_hi = sample_2d(self._call, u0, u1, v0, v1)
+            if dep_lo is None:
+                return result
+            dep_lo, dep_hi = apply_margin(dep_lo, dep_hi)
+        else:
+            return result
+
+        dep_lo_i, dep_hi_i = self._AXIS_IDX[dep]
+        result[dep_lo_i] = dep_lo
+        result[dep_hi_i] = dep_hi
+        return result
+
+    
     def __addTriangle__(self, render, p1, p2, p3, color, isRealpoint):
         
         # dont draw vertical vertices

{kaxe-1.4.6.dev0 → kaxe-1.4.8}/src/kaxe/objects/function.py

@@ -19,6 +19,11 @@ class Function:
         The number of points to plot for 3D functions. Default is None.
     fill : bool, optional
         Whether to fill the area under the function plot for 3D functions. Default is True.
+    domain : tuple, optional
+        Sampling interval for auto-scaled axes. See :class:`kaxe.Function2D` and
+        :class:`kaxe.Function3D`.
+    range : tuple, optional
+        Fixed output interval on the dependent axis when auto-scaling.
     *args : tuple
         Additional positional arguments to pass to the function f.
     **kwargs : dict
@@ -53,5 +58,5 @@ class Function:
 
         if n == 2:
             from .d3.function import Function3D
-            return Function3D(f, color=color, numPoints=numPoints, fill=fill)
+            return Function3D(f, color=color, numPoints=numPoints, fill=fill, *args, **kwargs)
 

{kaxe-1.4.6.dev0 → kaxe-1.4.8}/src/kaxe/plot/polar.py

@@ -61,8 +61,33 @@ class PolarPlot(Window):
 
     # creating plotting window
     def __calculateWindowBorders__(self):
-        if self.windowAxis[0] is None: self.windowAxis[0] = 0
-        if self.windowAxis[1] is None: self.windowAxis[1] = 10
+        if self.windowAxis[0] is None:
+            self.windowAxis[0] = 0
+
+        if self.windowAxis[1] is not None:
+            return
+
+        r_vals = []
+        for obj in self.objects:
+            bounds_fn = getattr(obj, 'bounds', None)
+            if callable(bounds_fn):
+                bounds = bounds_fn(plot_window=self.windowAxis, plot=self)
+                if bounds:
+                    if bounds[0] is not None:
+                        r_vals.append(bounds[0])
+                    if bounds[1] is not None:
+                        r_vals.append(bounds[1])
+                continue
+            try:
+                r_vals.append(obj.farLeft)
+                r_vals.append(obj.farRight)
+            except AttributeError:
+                continue
+
+        if r_vals:
+            self.windowAxis[1] = max(r_vals)
+        else:
+            self.windowAxis[1] = 10
 
 
     def __addRoundLines__(self):

{kaxe-1.4.6.dev0 → kaxe-1.4.8/src/kaxe.egg-info}/PKG-INFO

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

@@ -15,6 +15,7 @@ src/kaxe/chart/pie.py
 src/kaxe/chart/qqplot.py
 src/kaxe/core/__init__.py
 src/kaxe/core/axis.py
+src/kaxe/core/bounds.py
 src/kaxe/core/color.py
 src/kaxe/core/draw.py
 src/kaxe/core/fileloader.py