kaxe 1.4.9.dev0__tar.gz → 1.5.0__tar.gz

{kaxe-1.4.9.dev0/src/kaxe.egg-info → kaxe-1.5.0}/PKG-INFO

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

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

{kaxe-1.4.9.dev0 → kaxe-1.5.0}/src/kaxe/objects/d2/__init__.py

@@ -1,6 +1,7 @@
 
 from .point import Points2D
 from .equation import Equation
+from .inequality import Inequality
 from .function import Function2D
 from .pillar import Pillars, Histogram
 from .map import HeatMap, ColorScale

kaxe-1.5.0/src/kaxe/objects/d2/inequality.py

@@ -0,0 +1,216 @@
+
+from ...core.shapes import shapes
+from ...core.color import to_rgba
+from ...core.symbol import symbol
+from ...plot import identities
+from .equation import Equation
+
+_OPS = {
+    '<=': lambda d: d > 0,
+    'le': lambda d: d > 0,
+    '≤': lambda d: d > 0,
+    '<': lambda d: d >= 0,
+    'lt': lambda d: d >= 0,
+    '>=': lambda d: d < 0,
+    'ge': lambda d: d < 0,
+    '≥': lambda d: d < 0,
+    '>': lambda d: d <= 0,
+    'gt': lambda d: d <= 0,
+}
+
+
+def _resolve_plot(parent):
+    from ...core.d3.translator import getEquivalent2DPlot
+
+    if getattr(parent, 'identity', None) == identities.XYZPLOT:
+        return getEquivalent2DPlot(parent)
+    return parent
+
+
+def _eval_diff(parent, left, right, px, py):
+    try:
+        x, y = parent.inversepixel(px, py)
+        if x is None or y is None:
+            return None
+        return left(x, y) - right(x, y)
+    except (TypeError, ZeroDivisionError, ValueError):
+        return None
+
+
+class Inequality:
+    """
+    A class to represent a two-variable inequality ``left op right``.
+
+    Draws the boundary curve (same as :class:`Equation`) and red diagonal
+    hatching on the forbidden side of the inequality.
+
+    Supported in classical plots, polar plot and 3D plots as a 2D object with ``z=0``.
+
+    Parameters
+    ----------
+    left : callable
+        Left side of the inequality.
+    right : callable
+        Right side of the inequality.
+    op : str, optional
+        Comparison operator: ``<=``, ``<``, ``>=``, or ``>`` (default is ``<=``).
+    color : tuple | list, optional
+        Boundary line color. Random if omitted.
+    width : int, optional
+        Boundary line thickness (default is 2).
+    hatch_color : tuple | list, optional
+        Color of forbidden-region hatching (default is red with transparency).
+    hatch_spacing : int, optional
+        Pixel spacing between parallel hatch lines (default is 10).
+    hatch_width : int, optional
+        Hatch line thickness (default is 1).
+    computePadding : int, optional
+        Extra padding when sampling the plot area (default is 50).
+
+    Examples
+    --------
+    >>> g = lambda x, y: x + y - 3
+    >>> ineq = Inequality(g, lambda x, y: 0)
+    >>> plt.add(ineq)
+    """
+
+    def __init__(
+        self,
+        left,
+        right,
+        op='<=',
+        color=None,
+        width=2,
+        hatch_color=(255, 0, 0, 180),
+        hatch_spacing=10,
+        hatch_width=1,
+        computePadding=50,
+    ):
+        self.left = left
+        self.right = right
+        self.computePadding = computePadding
+        self.hatch_spacing = hatch_spacing
+        self.hatch_width = hatch_width
+        self.hatch_color = to_rgba(hatch_color)
+
+        if op not in _OPS:
+            raise ValueError(f"Unsupported operator {op!r}; use one of {sorted(_OPS)}")
+        self.op = op
+        self._is_forbidden = _OPS[op]
+
+        self.boundary = Equation(left, right, color=color, width=width, computePadding=computePadding)
+        self.hatch_batch = shapes.Batch()
+        self.color = self.boundary.color
+        self.legendColor = self.boundary.legendColor
+        self.width = width
+
+        self.supports = [identities.XYPLOT, identities.POLAR, identities.XYZPLOT]
+
+    def __build_hatch__(self, parent):
+        box = parent.windowBox
+        x0 = box[0] - self.computePadding
+        x1 = box[2] + self.computePadding
+        y0 = box[1] - self.computePadding
+        y1 = box[3] + self.computePadding
+
+        width = x1 - x0
+        height = y1 - y0
+        spacing = self.hatch_spacing
+        sample_step = 2
+        eps = 1e-9
+
+        scale = getattr(parent, 'getVisualScale', lambda: 1.0)()
+        hatch_width = max(1, int(self.hatch_width * scale))
+
+        max_extent = int(width + height)
+        for offset in range(-int(height), int(width + height), spacing):
+            segment_start = None
+            last_point = None
+
+            for t in range(0, max_extent, sample_step):
+                px = x0 + t
+                py = y0 + t + offset
+
+                if px < x0 or px > x1 or py < y0 or py > y1:
+                    if segment_start is not None and last_point is not None:
+                        self.__add_hatch_segment__(segment_start, last_point, hatch_width)
+                    segment_start = None
+                    last_point = None
+                    continue
+
+                if not parent.inside(px, py):
+                    if segment_start is not None and last_point is not None:
+                        self.__add_hatch_segment__(segment_start, last_point, hatch_width)
+                    segment_start = None
+                    last_point = None
+                    continue
+
+                diff = _eval_diff(parent, self.left, self.right, px, py)
+                forbidden = diff is not None and abs(diff) >= eps and self._is_forbidden(diff)
+
+                if forbidden:
+                    point = (px, py)
+                    if segment_start is None:
+                        segment_start = point
+                    last_point = point
+                elif segment_start is not None and last_point is not None:
+                    self.__add_hatch_segment__(segment_start, last_point, hatch_width)
+                    segment_start = None
+                    last_point = None
+
+            if segment_start is not None and last_point is not None:
+                self.__add_hatch_segment__(segment_start, last_point, hatch_width)
+
+    def __add_hatch_segment__(self, start, end, hatch_width):
+        if start == end:
+            return
+        shapes.Line(
+            start[0],
+            start[1],
+            end[0],
+            end[1],
+            color=self.hatch_color,
+            width=hatch_width,
+            batch=self.hatch_batch,
+        )
+
+    def finalize(self, parent):
+        from ...core.d3.translator import translate2DTo3DObjects, has3DReference
+
+        plot = _resolve_plot(parent)
+        self.boundary.finalize(plot)
+        self.__build_hatch__(plot)
+
+        if has3DReference(plot):
+            translate2DTo3DObjects(plot, self.hatch_batch)
+
+    def push(self, x, y):
+        self.hatch_batch.push(x, y)
+        self.boundary.push(x, y)
+
+    def draw(self, *args, **kwargs):
+        self.hatch_batch.draw(*args, **kwargs)
+        self.boundary.draw(*args, **kwargs)
+
+    def legend(self, text: str, symbol=symbol.LINE, color=None):
+        """
+        Adds a legend entry for this inequality.
+
+        Parameters
+        ----------
+        text : str
+            The text to display in the legend.
+        symbol : symbols, optional
+            The symbol to use in the legend.
+        color : optional
+            Legend color. Uses the boundary color if omitted.
+
+        Returns
+        -------
+        self
+        """
+        self.legendText = text
+        self.legendSymbol = symbol
+        if color:
+            self.legendColor = to_rgba(color)
+        return self

{kaxe-1.4.9.dev0 → kaxe-1.5.0}/src/kaxe/objects/d2/map.py

@@ -6,8 +6,9 @@ from ...core.shapes import shapes
 from ...core.text import Text
 from ...core.round import koundTeX
 from ...plot import identities
-from typing import Union
+from typing import Callable, Union
 from ...core.color import Colormaps
+from ...core.bounds import DEFAULT_DOMAIN_2D
 
 
 class ColorScale:
@@ -204,14 +205,97 @@ class HeatMap:
         else:
             self.maxValue = max([max(row) for row in self.data])
 
-        self.farLeft = len(data[0]) * self.unitPerPixel[0]
         self.farRight = position[0]
-        self.farTop = len(data) * self.unitPerPixel[1]
+        self.farLeft = position[0] + len(data[0]) * self.unitPerPixel[0]
         self.farBottom = position[1]
+        self.farTop = position[1] + len(data) * self.unitPerPixel[1]
         
         self.supports = [identities.XYPLOT]
 
-    
+    @classmethod
+    def fromFunction(
+        cls,
+        f: Callable,
+        numSamples: int = 100,
+        domain=None,
+        cmap=Colormaps.standard,
+        minValue=None,
+        maxValue=None,
+        *args,
+        **kwargs,
+    ):
+        """
+        Build a heatmap by sampling a 2D function on a regular grid.
+
+        Parameters
+        ----------
+        f : callable
+            Function ``f(x, y)`` returning the value at each grid point.
+            May accept numpy arrays for vectorized evaluation.
+        numSamples : int, optional
+            Number of cells per axis (default is 100).
+        domain : tuple, optional
+            Placement region ``(x0, x1, y0, y1)`` in plot coordinates
+            (default is ``(-10, 10, -10, 10)``).
+        cmap : Colormap, optional
+            Colormap for value-to-color mapping.
+        minValue : float or int, optional
+            Minimum value for the color scale. Calculated from data if omitted.
+        maxValue : float or int, optional
+            Maximum value for the color scale. Calculated from data if omitted.
+        *args
+            Additional positional arguments passed to ``f``.
+        **kwargs
+            Additional keyword arguments passed to ``f``.
+
+        Returns
+        -------
+        HeatMap
+
+        Examples
+        --------
+        >>> import math
+        >>> hm = kaxe.HeatMap.fromFunction(
+        ...     lambda x, y: math.sin(x) * math.cos(y),
+        ...     numSamples=100,
+        ...     domain=(-10, 10, -10, 10),
+        ... )
+        >>> plt.add(hm)
+        """
+        if domain is None:
+            domain = DEFAULT_DOMAIN_2D
+        x0, x1, y0, y1 = domain
+        n = numSamples
+        dx = (x1 - x0) / n
+        dy = (y1 - y0) / n
+
+        xs = np.linspace(x0 + dx / 2, x1 - dx / 2, n)
+        ys = np.linspace(y0 + dy / 2, y1 - dy / 2, n)
+
+        data = None
+        try:
+            x_grid, y_grid = np.meshgrid(xs, ys)
+            z_vals = np.asarray(f(x_grid, y_grid, *args, **kwargs), dtype=np.float64)
+            if z_vals.shape == (n, n):
+                data = z_vals.tolist()
+        except Exception:
+            pass
+
+        if data is None:
+            data = [
+                [float(f(x, y, *args, **kwargs)) for x in xs]
+                for y in ys
+            ]
+
+        return cls(
+            data,
+            cmap=cmap,
+            unitPerPixel=[dx, dy],
+            position=(x0, y0),
+            minValue=minValue,
+            maxValue=maxValue,
+        )
+
     def finalize(self, parent):
 
         # get size of one box

{kaxe-1.4.9.dev0 → kaxe-1.5.0/src/kaxe.egg-info}/PKG-INFO

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

@@ -60,6 +60,7 @@ src/kaxe/objects/d2/contour.py
 src/kaxe/objects/d2/equation.py
 src/kaxe/objects/d2/fill.py
 src/kaxe/objects/d2/function.py
+src/kaxe/objects/d2/inequality.py
 src/kaxe/objects/d2/map.py
 src/kaxe/objects/d2/parameter.py
 src/kaxe/objects/d2/pillar.py
@@ -127,4 +128,5 @@ src/kaxe/resources/computer-modern-family/cmu.typewriter-text-variable-width-med
 src/kaxe/resources/computer-modern-family/readme.txt
 tests/test.py
 tests/test2.py
-tests/test3.py
+tests/test3.py
+tests/test_5.py

kaxe-1.5.0/tests/test_5.py

@@ -0,0 +1,15 @@
+
+import sys
+
+sys.path.append('./src')
+
+import kaxe
+
+plt = kaxe.Plot()
+
+f = lambda x,y: (x - 1) ** 2 + (y - 2) ** 2
+g = lambda x,y: x + y - 3
+
+plt.add(kaxe.Contour(f))
+plt.add(kaxe.Inequality(g, lambda x,y: 0, hatch_spacing=50))
+plt.show()