kaxe 1.5.5.dev0__tar.gz → 1.5.6__tar.gz

{kaxe-1.5.5.dev0/src/kaxe.egg-info → kaxe-1.5.6}/PKG-INFO

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

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

{kaxe-1.5.5.dev0 → kaxe-1.5.6}/src/kaxe/core/helper.py

@@ -71,6 +71,32 @@ def contour_label_angle(polyline, index):
     return angle
 
 
+def bbox_overlaps(a, b, padding=0):
+    """Return True if two axis-aligned boxes overlap.
+
+    Each box is ``(left, top, width, height)`` as returned by ``Text.getBoundingBox()``.
+    """
+    ax, ay, aw, ah = a
+    bx, by, bw, bh = b
+
+    a_center = (ax + aw / 2, ay + ah / 2)
+    b_center = (bx + bw / 2, by + bh / 2)
+    a_size = (aw + 2 * padding, ah + 2 * padding)
+    b_size = (bw + 2 * padding, bh + 2 * padding)
+
+    a_top_right = (a_center[0] + a_size[0] / 2, a_center[1] + a_size[1] / 2)
+    a_bottom_left = (a_center[0] - a_size[0] / 2, a_center[1] - a_size[1] / 2)
+    b_top_right = (b_center[0] + b_size[0] / 2, b_center[1] + b_size[1] / 2)
+    b_bottom_left = (b_center[0] - b_size[0] / 2, b_center[1] - b_size[1] / 2)
+
+    return not (
+        a_top_right[0] < b_bottom_left[0]
+        or a_bottom_left[0] > b_top_right[0]
+        or a_top_right[1] < b_bottom_left[1]
+        or a_bottom_left[1] > b_top_right[1]
+    )
+
+
 def resample_polyline(points, spacing):
     """
     Emit points every `spacing` pixels along polyline arc length.

{kaxe-1.5.5.dev0 → kaxe-1.5.6}/src/kaxe/objects/d2/contour.py

@@ -4,13 +4,13 @@ import math
 from ...core.styles import *
 from ...core.shapes import shapes
 from ...core.symbol import symbol as symbols
-from ...core.helper import contour_label_angle
+from ...core.helper import bbox_overlaps, contour_label_angle, resample_polyline
 from ...core.text import Text
 from ...core.round import koundTeX
 from ...plot import identities
 from .equation import Equation, trace_contour_polylines
 from types import FunctionType
-from typing import Union
+from typing import Optional, Union
 from ...core.color import Colormaps, Colormap, to_rgba
 
 
@@ -47,30 +47,6 @@ def _simplify_polyline(polyline):
     return simplified
 
 
-def _point_at_arc_length(polyline, target):
-    if not polyline:
-        return 0, (0, 0)
-
-    if target <= 0:
-        return 0, polyline[0]
-
-    walked = 0.0
-    for i in range(1, len(polyline)):
-        dx = polyline[i][0] - polyline[i - 1][0]
-        dy = polyline[i][1] - polyline[i - 1][1]
-        seg_len = math.hypot(dx, dy)
-        if seg_len == 0:
-            continue
-        if walked + seg_len >= target:
-            t = (target - walked) / seg_len
-            px = polyline[i - 1][0] + t * dx
-            py = polyline[i - 1][1] + t * dy
-            return i, (px, py)
-        walked += seg_len
-
-    return len(polyline) - 1, polyline[-1]
-
-
 def _closest_polyline_index(polyline, point):
     best_index = 0
     best_dist = float('inf')
@@ -82,7 +58,7 @@ def _closest_polyline_index(polyline, point):
     return best_index
 
 
-def _label_positions(polyline, spacing, max_labels=2):
+def _label_candidates(polyline, spacing):
     polyline = _simplify_polyline(polyline)
     if len(polyline) < 2:
         return []
@@ -91,14 +67,16 @@ def _label_positions(polyline, spacing, max_labels=2):
     if arc < spacing:
         return []
 
-    num_labels = min(max_labels, max(1, int(arc / spacing)))
-    positions = []
-    for k in range(num_labels):
-        target = (k + 0.5) * arc / num_labels
-        index, point = _point_at_arc_length(polyline, target)
-        positions.append((point, _closest_polyline_index(polyline, point)))
+    candidates = []
+    for point in resample_polyline(polyline, spacing)[1:-1]:
+        index = _closest_polyline_index(polyline, point)
+        candidates.append((point, index, arc))
 
-    return positions
+    if not candidates and arc >= spacing:
+        mid_index = len(polyline) // 2
+        candidates.append((polyline[mid_index], mid_index, arc))
+
+    return candidates
 
 
 def _point_in_expanded_bbox(x, y, bbox, padding):
@@ -132,7 +110,15 @@ class Contour:
     label : bool, optional
         Draw inline level labels on contour lines (default is True).
     labelSpacing : int, optional
-        Minimum pixel spacing between labels along a contour (default is 100).
+        Minimum pixel spacing between label candidates along a contour (default is 100).
+    labelCollisionPadding : int, optional
+        Extra pixel gap required between placed label bounding boxes (default is 4).
+    labelMinArc : int, optional
+        Minimum polyline arc length to consider for labels (default is labelSpacing).
+    labelMaxBranches : int, optional
+        Maximum number of polylines per level to label (default is 1).
+    labelMaxPerLevel : int, optional
+        Hard cap on labels placed per level; unlimited when None (default is None).
     labelColor : tuple, optional
         Color of inline contour labels (default is black).
         
@@ -156,6 +142,10 @@ class Contour:
         computePadding: int = 50,
         label: bool = True,
         labelSpacing: int = 100,
+        labelCollisionPadding: int = 4,
+        labelMinArc: Optional[int] = None,
+        labelMaxBranches: int = 1,
+        labelMaxPerLevel: Optional[int] = None,
         labelColor=(0, 0, 0, 255),
     ):
         self.batch = shapes.Batch()
@@ -168,6 +158,10 @@ class Contour:
         self.lineThickness = lineThickness
         self.label = label
         self.labelSpacing = labelSpacing
+        self.labelCollisionPadding = labelCollisionPadding
+        self.labelMinArc = labelSpacing if labelMinArc is None else labelMinArc
+        self.labelMaxBranches = labelMaxBranches
+        self.labelMaxPerLevel = labelMaxPerLevel
         self.labelColor = to_rgba(labelColor)
     
         # color
@@ -208,12 +202,10 @@ class Contour:
         if self.label and label_parent == identities.XYPLOT:
             self.__finalizeLabels__(label_parent)
 
-    def __finalizeLabels__(self, parent):
-        fontSize = parent.getAttr('fontSize')
-        padding = max(2, fontSize // 8)
-        label_bboxes = []
+    def __collectCandidates__(self, parent):
+        candidates = []
 
-        for z, eq in self.__equations:
+        for level_index, (z, eq) in enumerate(self.__equations):
             label_text = _format_contour_level(z, self.a, self.b, self.steps)
             polylines = trace_contour_polylines(eq.dotsPosAbstract, parent)
             polylines = sorted(
@@ -224,36 +216,68 @@ class Contour:
             polylines = [
                 polyline
                 for polyline in polylines
-                if _polyline_arc_length(_simplify_polyline(polyline)) >= self.labelSpacing
-            ][:3]
-
-            for polyline in polylines:
-                for point, index in _label_positions(polyline, self.labelSpacing):
-                    angle = contour_label_angle(polyline, index)
-                    text = Text(
-                        label_text,
-                        int(point[0]),
-                        int(point[1]),
-                        fontSize=fontSize,
-                        color=self.labelColor,
-                        rotate=int(angle),
-                        anchor_x='center',
-                        anchor_y='center',
-                    )
-
-                    left, top = text.getLeftTopPos()
-                    shapes.Rectangle(
-                        left - padding,
-                        top - padding,
-                        text.width + 2 * padding,
-                        text.height + 2 * padding,
-                        color=WHITE,
-                        batch=self.batch,
-                    )
-                    text.batch = self.batch
-                    self.batch.add(text)
-
-                    label_bboxes.append(text.getBoundingBox())
+                if _polyline_arc_length(_simplify_polyline(polyline)) >= self.labelMinArc
+            ][: self.labelMaxBranches]
+
+            for branch_index, polyline in enumerate(polylines):
+                simplified = _simplify_polyline(polyline)
+                arc = _polyline_arc_length(simplified)
+                for candidate_index, (point, index, _) in enumerate(
+                    _label_candidates(polyline, self.labelSpacing)
+                ):
+                    candidates.append({
+                        "z": z,
+                        "level_index": level_index,
+                        "branch_index": branch_index,
+                        "candidate_index": candidate_index,
+                        "arc": arc,
+                        "polyline": polyline,
+                        "point": point,
+                        "index": index,
+                        "label_text": label_text,
+                    })
+
+        candidates.sort(
+            key=lambda item: (-item["arc"], item["level_index"], item["branch_index"], item["candidate_index"])
+        )
+        return candidates
+
+    def __finalizeLabels__(self, parent):
+        fontSize = parent.getAttr('fontSize')
+        placed_bboxes = []
+        label_bboxes = []
+        placed_per_level = {}
+
+        for candidate in self.__collectCandidates__(parent):
+            level_index = candidate["level_index"]
+            if self.labelMaxPerLevel is not None:
+                if placed_per_level.get(level_index, 0) >= self.labelMaxPerLevel:
+                    continue
+
+            angle = contour_label_angle(candidate["polyline"], candidate["index"])
+            text = Text(
+                candidate["label_text"],
+                int(candidate["point"][0]),
+                int(candidate["point"][1]),
+                fontSize=fontSize,
+                color=self.labelColor,
+                rotate=int(angle),
+                anchor_x='center',
+                anchor_y='center',
+            )
+            bbox = text.getBoundingBox()
+
+            if any(
+                bbox_overlaps(bbox, placed_bbox, self.labelCollisionPadding)
+                for placed_bbox in placed_bboxes
+            ):
+                continue
+
+            text.batch = self.batch
+            self.batch.add(text)
+            placed_bboxes.append(bbox)
+            label_bboxes.append(bbox)
+            placed_per_level[level_index] = placed_per_level.get(level_index, 0) + 1
 
         if not label_bboxes:
             return

{kaxe-1.5.5.dev0 → kaxe-1.5.6/src/kaxe.egg-info}/PKG-INFO

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