kaxe 1.5.6.dev0__tar.gz → 1.5.7.dev0__tar.gz

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

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

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

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

@@ -45,30 +45,46 @@ def vlen(v):
     return math.sqrt(sum([i**2 for i in v]))
 
 
-def contour_label_angle(polyline, index):
-    """Readable tangent angle in degrees for text placed on a contour polyline."""
-    n = len(polyline)
-    if n < 2:
+def contour_label_angle(func, parent, px, py, polyline=None, tangent_window=40):
+    """Readable tangent angle in degrees for ``Text.rotate`` at pixel (px, py).
+
+    Uses the function gradient mapped into pixel space (matplotlib clabel style:
+    arctan2 of the tangent vector in kaxe y-up coordinates, then keep text
+    right-side up). The returned value is passed directly to ``Text.rotate`` /
+    ``PIL.Image.rotate`` (SVG export negates internally to match).
+    """
+    del polyline, tangent_window
+
+    x, y = parent.inversepixel(px, py)
+    if x is None or y is None:
         return 0
 
-    if index <= 0:
-        p0, p1 = polyline[0], polyline[1]
-    elif index >= n - 1:
-        p0, p1 = polyline[-2], polyline[-1]
-    else:
-        p0, p1 = polyline[index - 1], polyline[index + 1]
+    scale = max(abs(x), abs(y), 1.0)
+    h = 1e-4 * scale
+
+    try:
+        fx = (func(x + h, y) - func(x - h, y)) / (2 * h)
+        fy = (func(x, y + h) - func(x, y - h)) / (2 * h)
+    except (TypeError, ValueError, ZeroDivisionError):
+        return 0
+
+    tx, ty = -fy, fx
+    if tx == 0 and ty == 0:
+        return 0
+
+    px0, py0 = parent.pixel(x, y)
+    px1, py1 = parent.pixel(x + tx, y + ty)
+    if px0 is None or py0 is None or px1 is None or py1 is None:
+        return 0
 
-    dx = p1[0] - p0[0]
-    dy = p1[1] - p0[1]
+    dx = px1 - px0
+    dy = py1 - py0
     if dx == 0 and dy == 0:
         return 0
 
-    angle = math.degrees(math.atan2(-dy, dx))
-    if angle > 90:
-        angle -= 180
-    elif angle < -90:
-        angle += 180
-    return angle
+    rotation = math.degrees(math.atan2(dy, dx))
+    rotation = (rotation + 90) % 180 - 90
+    return rotation
 
 
 def bbox_overlaps(a, b, padding=0):

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

@@ -58,7 +58,7 @@ def _closest_polyline_index(polyline, point):
     return best_index
 
 
-def _label_candidates(polyline, spacing):
+def _label_candidates(polyline, spacing, max_candidates=None):
     polyline = _simplify_polyline(polyline)
     if len(polyline) < 2:
         return []
@@ -76,6 +76,15 @@ def _label_candidates(polyline, 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
 
 
@@ -110,7 +119,7 @@ class Contour:
     label : bool, optional
         Draw inline level labels on contour lines (default is True).
     labelSpacing : int, optional
-        Minimum pixel spacing between label candidates along a contour (default is 100).
+        Minimum pixel spacing between label candidates along a contour (default is 80).
     labelCollisionPadding : int, optional
         Extra pixel gap required between placed label bounding boxes (default is 4).
     labelMinArc : int, optional
@@ -118,7 +127,7 @@ class Contour:
     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).
+        Maximum labels per contour level (default is 8).
     labelColor : tuple, optional
         Color of inline contour labels (default is black).
         
@@ -141,11 +150,11 @@ class Contour:
         lineThickness: int = 2,
         computePadding: int = 50,
         label: bool = True,
-        labelSpacing: int = 100,
+        labelSpacing: int = 80,
         labelCollisionPadding: int = 4,
         labelMinArc: Optional[int] = None,
         labelMaxBranches: int = 1,
-        labelMaxPerLevel: Optional[int] = None,
+        labelMaxPerLevel: int = 8,
         labelColor=(0, 0, 0, 255),
     ):
         self.batch = shapes.Batch()
@@ -223,7 +232,11 @@ class Contour:
                 simplified = _simplify_polyline(polyline)
                 arc = _polyline_arc_length(simplified)
                 for candidate_index, (point, index, _) in enumerate(
-                    _label_candidates(polyline, self.labelSpacing)
+                    _label_candidates(
+                        polyline,
+                        self.labelSpacing,
+                        max_candidates=self.labelMaxPerLevel,
+                    )
                 ):
                     candidates.append({
                         "z": z,
@@ -244,31 +257,36 @@ class Contour:
 
     def __finalizeLabels__(self, parent):
         fontSize = parent.getAttr('fontSize')
+        collision_padding = max(self.labelCollisionPadding, fontSize // 2)
         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
+            if placed_per_level.get(level_index, 0) >= self.labelMaxPerLevel:
+                continue
 
-            angle = contour_label_angle(candidate["polyline"], candidate["index"])
+            px, py = candidate["point"]
+            angle = contour_label_angle(self.func, parent, px, py)
             text = Text(
                 candidate["label_text"],
-                int(candidate["point"][0]),
-                int(candidate["point"][1]),
+                int(px),
+                int(py),
                 fontSize=fontSize,
                 color=self.labelColor,
-                rotate=int(angle),
+                rotate=round(angle),
                 anchor_x='center',
                 anchor_y='center',
             )
             bbox = text.getBoundingBox()
+            label_padding = max(
+                collision_padding,
+                int(max(bbox[2], bbox[3]) * 0.15),
+            )
 
             if any(
-                bbox_overlaps(bbox, placed_bbox, self.labelCollisionPadding)
+                bbox_overlaps(bbox, placed_bbox, label_padding)
                 for placed_bbox in placed_bboxes
             ):
                 continue

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.5.6.dev0
+Version: 1.5.7.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/tests/test_4.py

@@ -0,0 +1,29 @@
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from sympy import *
+import kaxe
+null = lambda *a, **b: 0
+
+x_1, x_2 = symbols("x_1 x_2")
+
+f = (x_1 + 1)**2 + (1 - x_2)**2
+
+# min f(x) when 
+
+g_1 = x_1 + 0.5 * x_2 - 2 # <= 0
+g_2 = -x_1 + 1 # <= 0
+
+
+f_lambda = lambdify([x_1, x_2], f)
+g_1_lambda = lambdify([x_1, x_2], g_1)
+g_2_lambda = lambdify([x_1, x_2], g_2)
+
+plt = kaxe.Plot()
+plt.add(kaxe.Contour(f_lambda))
+#plt.add(kaxe.Inequality(g_1_lambda, null))
+# plt.add(kaxe.Inequality(g_2_lambda, null))
+plt.show()

kaxe-1.5.6.dev0/tests/test_4.py

@@ -1,11 +0,0 @@
-
-import sys
-
-sys.path.append('./src')
-
-import kaxe
-import math
-
-plt = kaxe.Plot()
-plt.add(kaxe.HeatMap.fromFunction(lambda x,y: math.sin(x) * math.cos(y), numSamples=100, domain=(-10, 10, -10, 10)))
-plt.show()