prefig 0.2.15.dev20250514053750__py3-none-any.whl → 0.5.6.dev20260130060411__py3-none-any.whl

prefig/core/image.py

@@ -0,0 +1,127 @@
+import lxml.etree as ET
+import logging
+import numpy as np
+import base64
+import lxml.etree as ET
+from . import user_namespace as un
+from . import group
+from . import utilities as util
+from . import CTM
+
+log = logging.getLogger('prefigure')
+
+type_dict = {'jpg':'jpeg',
+             'jpeg':'jpeg',
+             'png':'png',
+             'gif':'gif',
+             'svg':'svg'}
+
+# Allows a block of XML to repeat with a changing parameter
+
+def image(element, diagram, parent, outline_status):
+    if len(element) == 0:
+        log.error("An <image> must contain content to replace the image in a tactile build")
+        return;
+    
+    if diagram.output_format() == 'tactile':
+        element.tag = 'group'
+        group.group(element, diagram, parent, outline_status)
+        return
+        
+    source = element.get('source', None)
+    if source is None:
+        log.error("An <image> needs a @source attribute")
+        return
+    try:
+        ll = un.valid_eval(element.get('lower-left', '(0,0)'))
+        dims = un.valid_eval(element.get('dimensions', '(1,1)'))
+        center = element.get('center', None)
+        if center is not None:
+            center = un.valid_eval(center)
+            ll = center - 0.5 * dims
+        else:
+            center = ll + 0.5*dims
+        rotation = un.valid_eval(element.get('rotate', '0'))
+        scale = un.valid_eval(element.get('scale', '1'))
+    except:
+        log.error("Error parsing placement data in an <image>")
+        return
+
+    file_type = None
+    if element.get('filetype', None) is not None:
+        file_type = type_dict.get(element.get('filetype'), None)
+    if file_type is None:
+        suffix = source.split('.')[-1]
+        file_type = type_dict.get(suffix, None)
+    if file_type is None:
+        log.error(f"Cannot determine the type of image in {source}")
+        return
+
+    ll_svg = diagram.transform(ll)
+    ur_svg = diagram.transform(ll + dims)
+    center_svg = diagram.transform(center)
+    width, height = ur_svg - ll_svg
+    height = -height
+
+    if diagram.get_environment() == 'pretext':
+        source = 'data/' + source
+    else:
+        assets_dir = diagram.get_external()
+        if assets_dir is not None:
+            assets_dir = assets_dir.strip()
+            if assets_dir[-1] != '/':
+                assets_dir += '/'
+            source = assets_dir + source
+
+    opacity = element.get('opacity', None)
+    if opacity is not None:
+        opacity = un.valid_eval(opacity)
+    if file_type == 'svg':
+        svg_tree = ET.parse(source)
+        svg_root = svg_tree.getroot()
+        svg_width = svg_root.get('width', None)
+        svg_height = svg_root.get('height', None)
+
+        object = ET.SubElement(parent, 'foreignObject')
+        object.set('x', util.float2str(center_svg[0]-width/2))
+        object.set('y', util.float2str(center_svg[1]-height/2))
+        object.set('width', util.float2str(width))
+        object.set('height', util.float2str(height))
+        svg_root.set('width', '100%')
+        svg_root.set('height', '100%')
+        if svg_root.get('viewBox', None) is None:
+            svg_root.set('viewBox', f"0 0 {svg_width} {svg_height}")
+        object.append(svg_root)
+        diagram.add_id(object, element.get('id'))
+        svg_root.attrib.pop('id', None)
+        if opacity is not None:
+            object.set('opacity', util.float2str(opacity))
+        return
+
+    image_el = ET.SubElement(parent, 'image')
+    image_el.set('x', util.float2str(-width/2))
+    image_el.set('y', util.float2str(-height/2))
+    image_el.set('width', util.float2str(width))
+    image_el.set('height', util.float2str(height))
+    if opacity is not None:
+        image_el.set('opacity', util.float2str(opacity))
+    diagram.add_id(image_el, element.get('id'))
+
+    with open(source, "rb") as image_file:
+        encoded_string = base64.b64encode(image_file.read())
+        encoded_string = encoded_string.decode('utf-8')
+    ref = f"data:image/{file_type};base64,{encoded_string}"
+    image_el.set('href', ref)
+
+    transform_pieces = [CTM.translatestr(*center_svg)]
+
+    if isinstance(scale, np.ndarray):
+        transform_pieces.append(CTM.scalestr(*scale))
+    elif scale != '1':
+        transform_pieces.append(f"scale({scale})")
+            
+    if rotation != 0:
+        transform_pieces.append(f"rotate({-rotation})")
+
+    image_el.set('transform', ' '.join(transform_pieces))
+    

prefig/core/label.py

@@ -15,6 +15,8 @@ import tempfile
 
 log = logging.getLogger('prefigure')
 
+allowed_fonts = {'serif','sans-serif','monospace'}
+
 def init(format, environment):
     global math_labels
     global text_measurements
@@ -465,10 +467,18 @@ def position_svg_label(element, diagram, ctm, group):
     # These lists contain: font, size, italics, bold, color
     label_color = element.get("color", None)
 
-    std_font_face = ['sans', 14, False, False, label_color]
-    it_font_face =  ['sans', 14, True, False, label_color]
-    b_font_face  =  ['sans', 14, False, True, label_color]
-    it_b_font_face  =  ['sans', 14, True, True, label_color]
+    diagram.apply_defaults('label', element)
+
+    font_family = element.get('font', 'sans-serif').lower().strip()
+    if font_family not in allowed_fonts:
+        font_family = 'sans-serif'
+
+    font_size = un.valid_eval(element.get('font-size', '14'))
+
+    std_font_face = [font_family, font_size, False, False, label_color]
+    it_font_face =  [font_family, font_size, True, False, label_color]
+    b_font_face  =  [font_family, font_size, False, True, label_color]
+    it_b_font_face  =  [font_family, font_size, True, True, label_color]
 
     label = element
 

prefig/core/legend.py

@@ -64,7 +64,7 @@ class Legend:
             # first we'll create the label
             label_el = copy.deepcopy(li)
             label_el.tag = 'label'
-            label_el.set('id', f"legend-label-{num}")
+            label_el.set('id', f"pf__legend-label-{num}")
             label_el.set('alignment', 'se')
             label_el.set('anchor', element.get('anchor', anchor_str))
             label_el.set('abs-offset', '(0,0)')
@@ -87,7 +87,7 @@ class Legend:
                 key = copy.deepcopy(key)
                 key.set('p', anchor_str)
                 key.set('size', '4')
-                key.set('id', f"legend-point-{num}")
+                key.set('id', f"pf__legend-point-{num}")
                 key_width = max(key_width, point_width)
             else:
                 fill =  key.get('fill')
@@ -219,11 +219,11 @@ class Legend:
             id = group.get('id', 'none')
             if id == 'background-group':
                 for rectangle in group:
-                    if rectangle.get('id', 'none').startswith('legend-label'):
+                    if rectangle.get('id', 'none').startswith('pf__legend-label'):
                         group.remove(rectangle)
             if id == 'braille-group':
                 for label in group:
-                    if label.get('id','none').startswith('legend-label'):
+                    if label.get('id','none').startswith('pf__legend-label'):
                         label_groups.append(label)
                         group.remove(label)
 

prefig/core/line.py

@@ -5,7 +5,11 @@ import logging
 from . import utilities as util
 from . import math_utilities as math_util
 from . import user_namespace as un
+import copy
 from . import arrow
+from . import group
+from . import label
+from . import CTM
 
 log = logging.getLogger('prefigure')
 
@@ -50,12 +54,24 @@ def line(element, diagram, parent, outline_status):
 
     line = mk_line(p1, p2, diagram, element.get('id', None), 
                    endpoint_offsets=endpoint_offsets)
+
+    # we need to hold on to the endpoints in case the line is labelled
+    # these are endpoints in SVG coordinates
+    x1 = float(line.get('x1'))
+    x2 = float(line.get('x2'))
+    y1 = float(line.get('y1'))
+    y2 = float(line.get('y2'))
+
+    q1 = np.array((x1, y1))
+    q2 = np.array((x2, y2))
+    diagram.save_data(element, {'q1': q1, 'q2': q2})
+
+    # now add the graphical attributes
     util.set_attr(element, 'stroke', 'black')
     util.set_attr(element, 'thickness', '2')
     if diagram.output_format() == 'tactile':
         element.set('stroke', 'black')
     util.add_attr(line, util.get_1d_attr(element))
-#    line.set('type', 'line')
 
     arrows = int(element.get('arrows', '0'))
     forward = 'marker-end'
@@ -113,15 +129,38 @@ def line(element, diagram, parent, outline_status):
         diagram.add_outline(element, line, parent)
         finish_outline(element, diagram, parent)
     else:
+        original_parent = parent
+        parent = add_label(element, diagram, parent)
         parent.append(line)
 
+        # if no label has been added, then we're done
+        if original_parent == parent:
+            return
+
+        # if there is a label, then the id is on the outer <g> element
+        # so we need to remove it from the children
+        remove_id(parent)
+
 def finish_outline(element, diagram, parent):
+    original_parent = parent
+    parent = add_label(element, diagram, parent)
+
+    # if we've added a label, remove the id's from element under the parent <g>
+    if original_parent != parent:
+        remove_id(parent)
+
     diagram.finish_outline(element,
                            element.get('stroke'),
                            element.get('thickness'),
                            element.get('fill', 'none'),
                            parent)
 
+def remove_id(el):
+    for child in el:
+        if child.get('id', None) is not None:
+            child.attrib.pop('id')
+        remove_id(child)
+
 # We'll be adding lines in other places so we'll use this more widely
 def mk_line(p0, p1, diagram, id = None, endpoint_offsets = None, user_coords = True):
     line = ET.Element('line')
@@ -176,3 +215,55 @@ def infinite_line(p0, p1, diagram, slope = None):
     if t_min > t_max:
         return None, None
     return [p + t * v for t in [t_min, t_max]]
+
+def add_label(element, diagram, parent):
+    # Is there a label associated with point?
+    text = element.text
+
+    # is there a label here?
+    has_text = text is not None and len(text.strip()) > 0
+    all_comments = all([subel.tag is ET.Comment for subel in element])
+    if has_text or not all_comments:
+        # If there's a label, we'll bundle the label and point in a group
+        parent_group = ET.SubElement(parent, 'g')
+        diagram.add_id(parent_group, element.get('id'))
+
+        # Now we'll create a new XML element describing the label
+        el = copy.deepcopy(element)
+        el.tag = 'label'
+
+        data = diagram.retrieve_data(element)
+        q1 = data['q1']
+        q2 = data['q2']
+
+        label_location = un.valid_eval(element.get("label-location", "0.5"))
+        if label_location < 0:
+            label_location = -label_location
+            q1, q2 = q2, q1
+
+        el.set('user-coords', 'no')
+        diff = q2 - q1
+        d = math_util.length(diff)
+        angle = math.degrees(math.atan2(diff[1], diff[0]))
+        if diagram.output_format() == "tactile":
+            anchor = q1 + label_location * diff
+            el.set("anchor", f"({anchor[0]}, {anchor[1]})")
+            direction = (diff[1], diff[0])
+            alignment = label.get_alignment_from_direction(direction)
+            el.set("alignment", alignment)
+            label.label(el, diagram, parent_group)
+        else:
+            tform = CTM.translatestr(*q1)
+            tform += ' ' + CTM.rotatestr(-angle)
+            distance = d * label_location
+            g = ET.SubElement(parent_group, "g")
+            g.set("transform", tform)
+            el.set("anchor", f"({distance},0)")
+            el.set("alignment", "north")
+            label.label(el, diagram, g)
+
+        return parent_group
+
+    else:
+        return parent
+

prefig/core/math_utilities.py

@@ -1,16 +1,39 @@
 import numpy as np
 import math
 from . import user_namespace as un
+from . import calculus
 
 import logging
 logger = logging.getLogger('prefigure')
 
+diagram = None
+
+def set_diagram(d):
+    global diagram
+    diagram = d
+
 # introduce some useful mathematical operations
 #   that are meant to be available to authors
 
+def ln(x):
+    return math.log(x)
+
+#Add other three trig functions for convenience
+def sec(x):
+    return 1/math.cos(x)
+
+def csc(x):
+    return 1/math.sin(x)
+
+def cot(x):
+    return 1/math.tan(x)
+
 def dot(u, v):
     return np.dot(np.array(u), np.array(v))
 
+def distance(p, q):
+    return length(np.array(p) - np.array(q))
+
 def length(u):
     return np.linalg.norm(np.array(u))
 
@@ -67,6 +90,20 @@ def rotate(v, theta):
     s = math.sin(theta)
     return np.array([c*v[0]-s*v[1], s*v[0]+c*v[1]])
 
+def deriv(f, a):
+    return calculus.derivative(f, a)
+
+def grad(f, a):
+    a = list(a)
+    grad = []
+    for j in range(len(a)):
+        def f_trace(x):
+            b = a[:]
+            b[j] = x
+            return f(*b)
+        grad.append(calculus.derivative(f_trace, a[j]))
+    return np.array(grad)
+
 def zip_lists(a, b):
     return list(zip(a, b))
 
@@ -116,3 +153,121 @@ def delta(t, a):
 
     return 0
 
+def line_intersection(lines):
+    p1, p2 = [np.array(c) for c in lines[0]]
+    q1, q2 = [np.array(c) for c in lines[1]]
+
+    diff = p2-p1
+    normal = [-diff[1], diff[0]]
+
+    v = q2 - q1
+    denom = dot(normal, v)
+    if abs(denom) < 1e-10:
+        bbox = diagram.bbox()
+        return np.array([(bbox[0]+bbox[2])/2, (bbox[1]+bbox[3])/2])
+    t = dot(normal, q1-p1) / denom
+    return q1 - t*v
+
+# find the intersection of two graphs or the zero of just one
+def intersect(functions, seed=None, interval=None):
+    bbox = diagram.bbox()
+    width = bbox[2] - bbox[0]
+    height = bbox[3] - bbox[1]
+    tolerance = 1e-06 * height
+
+    upper = bbox[3] + height
+    lower = bbox[1] - height
+
+    # we want to allow for some flexibility. We can find the intersection
+    # of
+    # -- two graphs f(x), g(x):  intersect((f,g), seed)
+    # -- zero of f(x):           intersect(f, seed)
+    # -- solve f(x) = y:         intersect((f, y), seed)
+    # -- two lines:              intersect((p1,p2),(q1,q2),seed)
+    if isinstance(functions, np.ndarray):
+        if isinstance(functions[0], np.ndarray):
+            return line_intersection(functions)
+        try:
+            y_value = float(functions[1])
+            f = lambda x: functions[0](x) - y_value
+        except:
+            f = lambda x: functions[0](x) - functions[1](x)
+    else:
+        f = functions
+
+    if interval is None:
+        interval = (bbox[0], bbox[2])
+
+    x0 = seed
+    y0 = f(x0)
+
+    if abs(y0) < tolerance:
+        return x0
+
+    dx = 0.002 * width
+    x = x0
+    x_left = -np.inf
+    while x >= interval[0]:
+        x -= dx
+        try:
+            y = f(x)
+        except:
+            break
+        if y > upper or y < lower:
+            break
+        if abs(y) < tolerance:
+            x_left = x
+            break
+        if y * y0 < 0:
+            x_left = x
+            break
+    if x_left != -np.inf and abs(f(x_left) - f(x_left + dx)) > height:
+        x_left = -np.inf
+
+    x = x0
+    x_right = np.inf
+    while x <= interval[1]:
+        x += dx
+        try:
+            y = f(x)
+        except:
+            break
+        if y > upper or y < lower:
+            break
+        if abs(y) < tolerance:
+            x_right = x
+            break
+        if y * y0 < 0:
+            x_right = x
+            break
+
+    if x_right != np.inf and abs(f(x_right) - f(x_right - dx)) > height:
+        x_right = np.inf
+
+    if x_left < interval[0] and x_right > interval[1]:
+        # we didn't find anything
+        return x0
+
+    if x_left < interval[0]:
+        x2 = x_right
+        x1 = x_right - dx
+
+    if x_right > interval[1]:
+        x2 = x_left + dx
+        x1 = x_left
+
+    if abs(x0 - x_right) < abs(x0 - x_left):
+        x1 = x_right - dx
+        x2 = x_right
+    else:
+        x1 = x_left
+        x2 = x_left + dx
+
+    for _ in range(8):
+        mid = (x1 + x2) / 2
+        if f(mid) * f(x1) < 0:
+            x2 = mid
+        else:
+            x1 = mid
+    return (x1+x2)/2
+

prefig/core/network.py

@@ -65,8 +65,8 @@ def network(element, diagram, parent, outline_status):
     positions = {}
     for node in element.findall('node'):
         handle = node.get('at', None)
-        diagram.add_id(node, handle)
-        handle = node.get('id')
+        # diagram.add_id(node, handle)
+        # handle = node.get('id')
         nodes[handle] = node
 
         # check for the position of this node 

prefig/core/parametric_curve.py

@@ -24,8 +24,9 @@ def parametric_curve(element, diagram, parent, outline_status):
         log.error(f"Error in <parametric-curve> defining domain={element.get('domain')}")
         return
 
-    N = int(element.get('N', '100'))
+    arrows = int(element.get('arrows', '0'))
 
+    N = int(element.get('N', '100'))
     t = domain[0]
     dt = (domain[1]-domain[0])/N
     p = diagram.transform(f(t))
@@ -34,8 +35,21 @@ def parametric_curve(element, diagram, parent, outline_status):
         t += dt
         p = diagram.transform(f(t))
         points.append('L ' + util.pt2str(p))
+
     if element.get('closed', 'no') == 'yes':
         points.append('Z')
+
+    if arrows > 0 and element.get('arrow-location', None) is not None:
+        arrow_location = un.valid_eval(element.get('arrow-location'))
+        num_pts = 5
+        t = arrow_location - num_pts*dt
+        p = diagram.transform(f(t))
+        points.append('M ' + util.pt2str(p))
+        for _ in range(num_pts):
+            t += dt
+            p = diagram.transform(f(t))
+            points.append('L ' + util.pt2str(p))
+
     d = ' '.join(points)
 
     if diagram.output_format() == 'tactile':
@@ -51,12 +65,10 @@ def parametric_curve(element, diagram, parent, outline_status):
     diagram.add_id(path, element.get('id'))
     path.set('d', d)
     util.add_attr(path, util.get_2d_attr(element))
-#    path.set('type', 'parametric curve')
 
     element.set('cliptobbox', element.get('cliptobbox', 'yes'))
     util.cliptobbox(path, element, diagram)
 
-    arrows = int(element.get('arrows', '0'))
     forward = 'marker-end'
     backward = 'marker-start'
     if element.get('reverse', 'no') == 'yes':

prefig/core/path.py

@@ -480,6 +480,31 @@ def decorate(child, diagram, current_point, cmds):
         cmds += ['L', util.pt2str(ctm.transform((x_pos,0)))]
         cmds += ['L', util.pt2str(ctm.transform((length, 0)))]
 
+    if decoration_data[0] == 'ragged':
+        # offset, step
+        try:
+            data = [d.split('=') for d in decoration_data[1:]]
+            data = {k:v for k, v in data}
+        except:
+            log.error("Error in wave decoration data")
+            return
+        try:
+            offset = un.valid_eval(data['offset'])
+            step = un.valid_eval(data['step'])
+        except:
+            log.error("Error in retrieving the step and an offset in a ragged decoration")
+
+        np.random.seed(int(data.get('seed','1')))
+        x_pos = 0
+        y_pos = 0
+        p = ctm.transform((0,0))
+        cmds += ['L', util.pt2str(ctm.transform((0,0)))]
+        while x_pos < length-step:
+            y_pos = 2 * offset * (np.random.random()-0.5)
+            x_pos += (0.5*np.random.random()+0.75)*step
+            cmds += ['L', util.pt2str(ctm.transform((x_pos,y_pos)))]
+        cmds += ['L', util.pt2str(ctm.transform((length, 0)))]
+
     if decoration_data[0] == 'capacitor':
         try:
             data = [d.split('=') for d in decoration_data[1:]]

prefig/core/point.py

@@ -1,5 +1,7 @@
 import lxml.etree as ET
 import logging
+import numpy as np
+import math
 from . import user_namespace as un
 from . import math_utilities as math_util
 from . import utilities as util
@@ -18,13 +20,27 @@ def point(element, diagram, parent, outline_status = None):
 
     # determine the location and size of the point from the XML element
     try:
-        p = diagram.transform(un.valid_eval(element.get('p')))
+        p = un.valid_eval(element.get('p'))
+        if element.get('coordinates', 'cartesian') == 'polar':
+            radial = p[0]
+            angle = p[1]
+            if element.get('degrees', 'no') == 'yes':
+                angle = math.radians(angle)
+            p = radial * np.array([math.cos(angle), math.sin(angle)])
+            element.set('p', util.pt2long_str(p, spacer=','))
+        p = diagram.transform(p)
     except:
         log.error(f"Error in <point> defining p={element.get('p')}")
         return
 
     if diagram.output_format() == 'tactile':
-        element.set('size', element.get('size', '9'))
+        if element.get('size', None) is not None:
+            size = un.valid_eval(element.get('size'))
+            size = max(size, 9)
+            size = str(size)
+        else:
+            size = '9'
+        element.set('size', size)
     else:
         element.set('size', element.get('size', '4'))
     size = util.get_attr(element, 'size', '1')

prefig/core/polygon.py

@@ -53,7 +53,10 @@ def polygon(element, diagram, parent,
         if element.get('stroke') is not None:
             element.set('stroke', 'black')
         if element.get('fill') is not None:
-            element.set('fill', 'lightgray')
+            if element.get('fill').strip().lower() != 'none':
+                element.set('fill', 'lightgray')
+            else:
+                element.set('fill', 'none')
     util.set_attr(element, 'stroke', 'none')
     util.set_attr(element, 'fill', 'none')
     util.set_attr(element, 'thickness', '2')
@@ -188,6 +191,9 @@ def spline(element, diagram, parent, outline_status):
 
     cs = CubicSpline(t_vals, points, bc_type=bc)
 
+    if element.get('name', None) is not None:
+        un.enter_function(element.get('name'), cs)
+
     N = un.valid_eval(element.get('N', '100'))
     domain = element.get('domain', None)
     if domain is not None:

prefig/core/read.py

@@ -13,9 +13,12 @@ def read(element, diagram, parent, outline_status):
         return
     filename = Path(filename)
     external_root = diagram.get_external()
-    if external_root is not None:
-        external_root = Path(external_root)
-        filename = external_root / filename
+    if diagram.get_environment() == "pretext":
+        filename = "data" / filename
+    else:
+        if external_root is not None:
+            external_root = Path(external_root)
+            filename = external_root / filename
 
     name = element.get('name', None)
     if name is None: