kaxe 1.5.7.dev0__tar.gz → 1.6.0.dev0__tar.gz

{kaxe-1.5.7.dev0/src/kaxe.egg-info → kaxe-1.6.0.dev0}/PKG-INFO

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

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

{kaxe-1.5.7.dev0 → kaxe-1.6.0.dev0}/src/kaxe/core/helper.py

@@ -87,6 +87,41 @@ def contour_label_angle(func, parent, px, py, polyline=None, tangent_window=40):
     return rotation
 
 
+def bbox_intersects_box(bbox, box_ltrb):
+    """Return True if bbox intersects box_ltrb.
+
+    ``bbox`` is ``(left, top, width, height)``; ``box_ltrb`` is
+    ``[left, top, right, bottom]`` (same as ``windowBox``).
+    """
+    left, top, width, height = bbox
+    right = left + width
+    bottom = top + height
+    box_left, box_top, box_right, box_bottom = box_ltrb
+    return not (
+        right <= box_left
+        or left >= box_right
+        or bottom <= box_top
+        or top >= box_bottom
+    )
+
+
+def intersect_bbox_with_box(bbox, box_ltrb):
+    """Return intersection of bbox with box_ltrb as (left, top, w, h), or None."""
+    left, top, width, height = bbox
+    right = left + width
+    bottom = top + height
+    box_left, box_top, box_right, box_bottom = box_ltrb
+
+    ix0 = max(left, box_left)
+    iy0 = max(top, box_top)
+    ix1 = min(right, box_right)
+    iy1 = min(bottom, box_bottom)
+
+    if ix0 >= ix1 or iy0 >= iy1:
+        return None
+    return (int(ix0), int(iy0), int(ix1 - ix0), int(iy1 - iy0))
+
+
 def bbox_overlaps(a, b, padding=0):
     """Return True if two axis-aligned boxes overlap.
 

{kaxe-1.5.7.dev0 → kaxe-1.6.0.dev0}/src/kaxe/core/shapes.py

@@ -33,6 +33,22 @@ def blitImageToSurface(surface:Image, image:Image, pos:Union[tuple, list]):
     return surface.paste(image, (int(pos[0]), int(pos[1])), image)
 
 
+def blit_image_clipped(surface, image, dest_left, dest_top, clip_ltrb):
+    """Paste ``image`` at (dest_left, dest_top), clipped to clip_ltrb [l,t,r,b]."""
+    from .helper import intersect_bbox_with_box
+
+    dest_bbox = (int(dest_left), int(dest_top), image.width, image.height)
+    intersection = intersect_bbox_with_box(dest_bbox, clip_ltrb)
+    if intersection is None:
+        return
+
+    ix, iy, iw, ih = intersection
+    src_x = ix - int(dest_left)
+    src_y = iy - int(dest_top)
+    cropped = image.crop((src_x, src_y, src_x + iw, src_y + ih))
+    blitImageToSurface(surface, cropped, (ix, iy))
+
+
 def newImage(width, height, color):
     img = Image.new('RGBA', (int(width), int(height)), color=color)
     return img

{kaxe-1.5.7.dev0 → kaxe-1.6.0.dev0}/src/kaxe/core/svg.py

@@ -57,6 +57,8 @@ class SvgDocument:
         self._width, self._height = int(size[0]), int(size[1])
         self._elements: list[ET.Element] = []
         self._fondi_font_css: Optional[str] = None
+        self._clip_defs: dict[tuple[int, int, int, int], str] = {}
+        self._clip_counter = 0
 
     @property
     def height(self) -> int:
@@ -77,6 +79,42 @@ class SvgDocument:
         self._elements.append(el)
         return el
 
+    def get_clip_id(self, box_ltrb) -> str:
+        """Return a stable clip-path id for a kaxe [left, top, right, bottom] box."""
+        key = tuple(int(v) for v in box_ltrb)
+        if key in self._clip_defs:
+            return self._clip_defs[key]
+
+        clip_id = f"kaxe-clip-{self._clip_counter}"
+        self._clip_counter += 1
+        self._clip_defs[key] = clip_id
+        return clip_id
+
+    def _clip_rect_element(self, box_ltrb) -> ET.Element:
+        left, top, right, bottom = (int(v) for v in box_ltrb)
+        svg_y = self.flip_y(bottom)
+        height = bottom - top
+        width = right - left
+        return ET.Element(
+            f"{{{SVG_NS}}}rect",
+            {
+                "x": str(left),
+                "y": str(svg_y),
+                "width": str(width),
+                "height": str(height),
+            },
+        )
+
+    def append_clipped(self, element: ET.Element, box_ltrb) -> None:
+        """Append ``element`` inside a group clipped to ``box_ltrb``."""
+        clip_id = self.get_clip_id(box_ltrb)
+        group = ET.Element(
+            f"{{{SVG_NS}}}g",
+            {"clip-path": f"url(#{clip_id})"},
+        )
+        group.append(element)
+        self._elements.append(group)
+
     def add_rect(
         self,
         x: float,
@@ -284,6 +322,7 @@ class SvgDocument:
         y_coord: str = "bottom",
         rotate: float = 0,
         rotate_center: Optional[tuple[float, float]] = None,
+        clip_box: Optional[list] = None,
     ) -> None:
         """Place an image; y is in kaxe coords (y-up). y_coord='bottom' or 'top'."""
         href = pil_to_data_uri(img)
@@ -302,7 +341,14 @@ class SvgDocument:
         if rotate:
             cx, cy = rotate_center or (x + img.width / 2, svg_top + img.height / 2)
             attribs["transform"] = f"rotate({-rotate},{cx},{cy})"
-        self.add_element("image", attribs)
+        el = ET.Element(
+            f"{{{SVG_NS}}}image",
+            {k: str(v) for k, v in attribs.items() if v is not None},
+        )
+        if clip_box is not None:
+            self.append_clipped(el, clip_box)
+        else:
+            self._elements.append(el)
 
     def _ensure_fondi_fonts(self) -> None:
         if self._fondi_font_css is not None:
@@ -319,6 +365,7 @@ class SvgDocument:
         *,
         rotate: float = 0,
         rotate_center: Optional[tuple[float, float]] = None,
+        clip_box: Optional[list] = None,
     ) -> None:
         """Embed a fondi scene (vector math text) at SVG top-left coordinates."""
         from fondi.backends import render_svg
@@ -347,7 +394,10 @@ class SvgDocument:
         group = ET.Element(f"{{{SVG_NS}}}g", {"transform": transform})
         for child in list(inner):
             group.append(copy.deepcopy(child))
-        self._elements.append(group)
+        if clip_box is not None:
+            self.append_clipped(group, clip_box)
+        else:
+            self._elements.append(group)
 
     def serialize(self) -> str:
         root = ET.Element(
@@ -359,10 +409,18 @@ class SvgDocument:
                 "viewBox": f"0 0 {self._width} {self._height}",
             },
         )
-        if self._fondi_font_css is not None:
+        if self._fondi_font_css is not None or self._clip_defs:
             defs = ET.SubElement(root, f"{{{SVG_NS}}}defs")
-            style = ET.SubElement(defs, f"{{{SVG_NS}}}style")
-            style.text = self._fondi_font_css
+            if self._fondi_font_css is not None:
+                style = ET.SubElement(defs, f"{{{SVG_NS}}}style")
+                style.text = self._fondi_font_css
+            for box_ltrb, clip_id in self._clip_defs.items():
+                clip_path = ET.SubElement(
+                    defs,
+                    f"{{{SVG_NS}}}clipPath",
+                    {"id": clip_id},
+                )
+                clip_path.append(self._clip_rect_element(box_ltrb))
         for el in self._elements:
             root.append(el)
         body = ET.tostring(root, encoding="unicode")

{kaxe-1.5.7.dev0 → kaxe-1.6.0.dev0}/src/kaxe/core/text.py

@@ -76,10 +76,12 @@ class Text(Shape):
                  anchor_x:str="center", 
                  anchor_y:str="center", 
                  cacheImage=True,
+                 clip_box=None,
                  *args, **kwargs
         ):
         
         self.batch = batch
+        self.clip_box = list(clip_box) if clip_box is not None else None
         self.color = color
         self.rotate = rotate
         self.fontSize = fontSize
@@ -164,9 +166,29 @@ class Text(Shape):
         self.__center__[1] = self.__leftTop__[1] - self.height/2
 
 
+    def _pil_clip_box(self, surface):
+        if self.clip_box is None:
+            return None
+        left, top, right, bottom = self.clip_box
+        return [
+            left,
+            surface.height - bottom,
+            right,
+            surface.height - top,
+        ]
+
     def drawPillow(self, surface):
         [y] = flipHorizontal(surface, self.__center__[1] + self.height/2)
-        blitImageToSurface(surface, self.img, (self.__leftTop__[0], y))
+        if self.clip_box is not None:
+            blit_image_clipped(
+                surface,
+                self.img,
+                self.__leftTop__[0],
+                y,
+                self._pil_clip_box(surface),
+            )
+        else:
+            blitImageToSurface(surface, self.img, (self.__leftTop__[0], y))
 
     def drawSvg(self, doc):
         kaxe_top = self.__center__[1] + self.height / 2
@@ -187,6 +209,7 @@ class Text(Shape):
                 scene_top,
                 rotate=self.rotate,
                 rotate_center=rotate_center,
+                clip_box=self.clip_box,
             )
             return
 
@@ -197,6 +220,7 @@ class Text(Shape):
             y_coord="top",
             rotate=self.rotate,
             rotate_center=rotate_center,
+            clip_box=self.clip_box,
         )
 
 
@@ -208,6 +232,11 @@ class Text(Shape):
         self.__center__[1] += int(y)
         self.__leftTop__[0] += int(x)
         self.__leftTop__[1] += int(y)
+        if self.clip_box is not None:
+            self.clip_box[0] += int(x)
+            self.clip_box[1] += int(y)
+            self.clip_box[2] += int(x)
+            self.clip_box[3] += int(y)
 
 
     def getIncludeArguments(self):

{kaxe-1.5.7.dev0 → kaxe-1.6.0.dev0}/src/kaxe/objects/d2/contour.py

@@ -4,7 +4,7 @@ import math
 from ...core.styles import *
 from ...core.shapes import shapes
 from ...core.symbol import symbol as symbols
-from ...core.helper import bbox_overlaps, contour_label_angle, resample_polyline
+from ...core.helper import bbox_intersects_box, bbox_overlaps, contour_label_angle
 from ...core.text import Text
 from ...core.round import koundTeX
 from ...plot import identities
@@ -32,6 +32,56 @@ def _polyline_arc_length(polyline):
     return total
 
 
+def _polyline_is_closed(polyline, tolerance=2.0):
+    if len(polyline) < 3:
+        return False
+    dx = polyline[0][0] - polyline[-1][0]
+    dy = polyline[0][1] - polyline[-1][1]
+    return math.hypot(dx, dy) <= tolerance
+
+
+def _polyline_total_arc(polyline, closed):
+    arc = _polyline_arc_length(polyline)
+    if closed:
+        dx = polyline[0][0] - polyline[-1][0]
+        dy = polyline[0][1] - polyline[-1][1]
+        arc += math.hypot(dx, dy)
+    return arc
+
+
+def _point_at_arc_length(polyline, target, closed=False):
+    if not polyline:
+        return 0, (0, 0)
+
+    total = _polyline_total_arc(polyline, closed)
+    if total <= 0:
+        return 0, polyline[0]
+
+    if closed:
+        target = target % total
+    elif target >= total:
+        return len(polyline) - 1, polyline[-1]
+
+    walked = 0.0
+    segment_count = len(polyline) - 1 + (1 if closed else 0)
+
+    for seg in range(segment_count):
+        i = seg if seg < len(polyline) - 1 else len(polyline) - 1
+        j = (seg + 1) if seg < len(polyline) - 1 else 0
+        dx = polyline[j][0] - polyline[i][0]
+        dy = polyline[j][1] - polyline[i][1]
+        seg_len = math.hypot(dx, dy)
+        if seg_len == 0:
+            continue
+        if walked + seg_len >= target:
+            t = (target - walked) / seg_len
+            point = (polyline[i][0] + t * dx, polyline[i][1] + t * dy)
+            return i, point
+        walked += seg_len
+
+    return len(polyline) - 1, polyline[-1]
+
+
 def _simplify_polyline(polyline):
     if not polyline:
         return []
@@ -47,44 +97,34 @@ def _simplify_polyline(polyline):
     return simplified
 
 
-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
+_LABEL_PHASE_GOLDEN = 0.618033988749895
 
 
-def _label_candidates(polyline, spacing, max_candidates=None):
+def _label_candidates(polyline, spacing, max_candidates=None, phase=0.0):
     polyline = _simplify_polyline(polyline)
     if len(polyline) < 2:
         return []
 
-    arc = _polyline_arc_length(polyline)
+    closed = _polyline_is_closed(polyline)
+    arc = _polyline_total_arc(polyline, closed)
     if arc < spacing:
         return []
 
+    num_labels = max(1, int(arc / spacing))
+    if max_candidates is not None:
+        num_labels = min(num_labels, max_candidates)
+
     candidates = []
-    for point in resample_polyline(polyline, spacing)[1:-1]:
-        index = _closest_polyline_index(polyline, point)
+    for k in range(num_labels):
+        fraction = (k + 0.5 + phase) / num_labels
+        if closed:
+            fraction = fraction % 1.0
+        elif fraction > 1.0:
+            continue
+        target = fraction * arc
+        index, point = _point_at_arc_length(polyline, target, closed)
         candidates.append((point, index, arc))
 
-    if not candidates and arc >= spacing:
-        mid_index = len(polyline) // 2
-        candidates.append((polyline[mid_index], mid_index, arc))
-
-    if max_candidates is not None and len(candidates) > max_candidates:
-        if max_candidates <= 1:
-            return candidates[:1]
-        last = len(candidates) - 1
-        candidates = [
-            candidates[int(i * last / (max_candidates - 1))]
-            for i in range(max_candidates)
-        ]
-
     return candidates
 
 
@@ -236,6 +276,10 @@ class Contour:
                         polyline,
                         self.labelSpacing,
                         max_candidates=self.labelMaxPerLevel,
+                        phase=(
+                            level_index / max(self.steps, 1)
+                            + (level_index * _LABEL_PHASE_GOLDEN) % 1.0
+                        ) % 1.0,
                     )
                 ):
                     candidates.append({
@@ -278,8 +322,12 @@ class Contour:
                 rotate=round(angle),
                 anchor_x='center',
                 anchor_y='center',
+                clip_box=list(parent.windowBox),
             )
             bbox = text.getBoundingBox()
+            if not bbox_intersects_box(bbox, parent.windowBox):
+                continue
+
             label_padding = max(
                 collision_padding,
                 int(max(bbox[2], bbox[3]) * 0.15),

{kaxe-1.5.7.dev0 → kaxe-1.6.0.dev0}/src/kaxe/objects/d2/inequality.py

@@ -5,7 +5,7 @@ from ...core.color import to_rgba
 from ...core.symbol import symbol
 from ...core.helper import isRealNumber
 from ...plot import identities
-from .equation import Equation
+from .equation import Equation, trace_contour_polylines
 
 
 def _as_2d_expr(expr):
@@ -47,6 +47,81 @@ def _eval_diff(parent, left, right, px, py):
         return None
 
 
+def _point_segment_distance_sq(px, py, x1, y1, x2, y2):
+    dx = x2 - x1
+    dy = y2 - y1
+    if dx == 0 and dy == 0:
+        dpx = px - x1
+        dpy = py - y1
+        return dpx * dpx + dpy * dpy
+    t = max(0.0, min(1.0, ((px - x1) * dx + (py - y1) * dy) / (dx * dx + dy * dy)))
+    cx = x1 + t * dx
+    cy = y1 + t * dy
+    dpx = px - cx
+    dpy = py - cy
+    return dpx * dpx + dpy * dpy
+
+
+def _min_distance_sq_to_segments(px, py, segments):
+    if not segments:
+        return float('inf')
+    return min(
+        _point_segment_distance_sq(px, py, x1, y1, x2, y2)
+        for x1, y1, x2, y2 in segments
+    )
+
+
+def _boundary_segments(boundary, parent):
+    segments = []
+    for polyline in trace_contour_polylines(boundary.dotsPosAbstract, parent):
+        if len(polyline) < 2:
+            continue
+        decimated = _decimate_polyline(polyline, min_step=12)
+        for i in range(len(decimated) - 1):
+            x1, y1 = decimated[i]
+            x2, y2 = decimated[i + 1]
+            segments.append((x1, y1, x2, y2))
+    return segments
+
+
+def _decimate_polyline(polyline, min_step=12):
+    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(segments, band, x0, y0, x1, y1):
+    cell = max(1, int(band / 2))
+    band_sq = band * band
+    cols = int((x1 - x0) / cell) + 1
+    rows = int((y1 - y0) / cell) + 1
+    near = set()
+    for ci in range(cols):
+        for ri in range(rows):
+            cx = x0 + ci * cell + cell * 0.5
+            cy = y0 + ri * cell + cell * 0.5
+            if _min_distance_sq_to_segments(cx, cy, segments) <= band_sq:
+                near.add((ci, ri))
+    return cell, near, x0, y0
+
+
+def _point_in_band_cells(px, py, cell, near, origin_x, origin_y):
+    ci = int((px - origin_x) // cell)
+    ri = int((py - origin_y) // cell)
+    return (ci, ri) in near
+
+
 class Inequality:
     """
     A class to represent a two-variable inequality ``left op right``.
@@ -77,6 +152,9 @@ class Inequality:
     hatch_angle : float, optional
         Hatch line angle in degrees, measured counter-clockwise from the
         horizontal axis (default is 45).
+    hatch_band : float, optional
+        Maximum pixel distance from the boundary to draw hatching. When
+        omitted, the entire forbidden side is hatched.
     computePadding : int, optional
         Extra padding when sampling the plot area (default is 50).
 
@@ -98,6 +176,7 @@ class Inequality:
         hatch_spacing=10,
         hatch_width=1,
         hatch_angle=45,
+        hatch_band=None,
         computePadding=50,
     ):
         self.left = _as_2d_expr(left)
@@ -106,6 +185,7 @@ class Inequality:
         self.hatch_spacing = hatch_spacing
         self.hatch_width = hatch_width
         self.hatch_angle = hatch_angle
+        self.hatch_band = hatch_band
         self.hatch_color = to_rgba(hatch_color)
 
         if op not in _OPS:
@@ -128,12 +208,20 @@ class Inequality:
         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
 
+        boundary_segments = None
+        band_cells = None
+        if self.hatch_band is not None:
+            boundary_segments = _boundary_segments(self.boundary, parent)
+            if not boundary_segments:
+                return
+            band_cells = _build_band_cells(
+                boundary_segments, self.hatch_band, x0, y0, x1, y1
+            )
+
         scale = getattr(parent, 'getVisualScale', lambda: 1.0)()
         hatch_width = max(1, int(self.hatch_width * scale))
 
@@ -199,6 +287,14 @@ class Inequality:
                 forbidden = self._is_forbidden(diff)
 
                 if forbidden:
+                    if band_cells is not None:
+                        cell, near, origin_x, origin_y = band_cells
+                        if not _point_in_band_cells(px, py, cell, near, origin_x, origin_y):
+                            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
                     point = (px, py)
                     if segment_start is None:
                         segment_start = point

{kaxe-1.5.7.dev0 → kaxe-1.6.0.dev0/src/kaxe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.5.7.dev0
+Version: 1.6.0.dev0
 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