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

prefig/core/circle.py

@@ -47,9 +47,12 @@ def circle(element, diagram, parent, outline_status):
         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')
     else:
-        element.set('stroke', element.get('stroke', 'none'))
+        element.set('stroke', element.get('stroke', 'black'))
         element.set('fill', element.get('fill', 'none'))
     element.set('thickness', element.get('thickness', '2'))
     util.add_attr(circle, util.get_2d_attr(element))
@@ -120,7 +123,10 @@ def ellipse(element, diagram, parent, outline_status):
         if element.get('stroke') is not None:
             element.set('stroke', 'black')
         if element.get('fill') is not None:
-            element.set('fill', 'lightgray')
+            if elementl.get('fill').strip().lower() != 'none':
+                element.set('fill', 'lightgray')
+            else:
+                element.set('fill', 'none')
     else:
         element.set('stroke', element.get('stroke', 'none'))
         element.set('fill', element.get('fill', 'none'))
@@ -283,7 +289,10 @@ def angle(element, diagram, parent, outline_status):
     element.set('stroke', element.get('stroke', 'black'))
     if diagram.output_format() == 'tactile':
         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')
     else:
         element.set('fill', element.get('fill', 'none'))
     element.set('thickness', element.get('thickness','2'))

prefig/core/clip.py

@@ -18,7 +18,7 @@ def clip(element, diagram, parent, outline_status):
 
     clip = ET.Element('clipPath')
     clip.append(shape)
-    clip_id = 'clip-'+shape_ref
+    clip_id = shape_ref + '-clip'
     clip.set('id', clip_id)
 
     diagram.add_reusable(clip)

prefig/core/coordinates.py

@@ -27,6 +27,7 @@ def coordinates(element, diagram, root, outline_status):
     dest_dy *= -1
 
     bbox = un.valid_eval(element.get('bbox'))
+
     if element.get('aspect-ratio', None) is not None:
         ratio = un.valid_eval(element.get('aspect-ratio'))
         if element.get('preserve-y-range', 'no') == 'yes':
@@ -58,15 +59,41 @@ def coordinates(element, diagram, root, outline_status):
     clip_box.set('height', util.float2str(height))
     diagram.push_clippath(clippath)
 
+    scales = element.get('scales', 'linear')
+    if scales == 'linear':
+        scales = ['linear', 'linear']
+    elif scales == 'semilogx':
+        scales = ['log', 'linear']
+    elif scales == 'semilogy':
+        scales = ['linear', 'log']
+    elif scales == 'loglog':
+        scales = ['log', 'log']
+    else:
+        scales = ['linear', 'linear']
+
     ctm = ctm.copy()
+    diagram.push_scales(scales)
+    scaled_bbox = bbox.copy()
+    if scales[0] == 'log':
+        scaled_bbox[0] = np.log10(scaled_bbox[0])
+        scaled_bbox[2] = np.log10(scaled_bbox[2])
+        ctm.set_log_x()
+    if scales[1] == 'log':
+        scaled_bbox[1] = np.log10(scaled_bbox[1])
+        scaled_bbox[3] = np.log10(scaled_bbox[3])
+        ctm.set_log_y()
+
     ctm.translate(destination[0], destination[1])
-    ctm.scale( (destination[2]-destination[0])/float(bbox[2]-bbox[0]),
-               (destination[3]-destination[1])/float(bbox[3]-bbox[1]) )
-    ctm.translate(-bbox[0], -bbox[1])
-    bbox_str = '['+','.join([str(b) for b in bbox])+']'
+    ctm.scale( (destination[2]-destination[0]) /
+               float(scaled_bbox[2]-scaled_bbox[0]),
+               (destination[3]-destination[1]) /
+               float(scaled_bbox[3]-scaled_bbox[1]) )
+    ctm.translate(-scaled_bbox[0], -scaled_bbox[1])
+    bbox_str = '['+','.join([str(b) for b in scaled_bbox])+']'
     un.valid_eval(bbox_str, 'bbox')
 
     diagram.push_ctm([ctm, bbox])
     diagram.parse(element, root, outline_status)
     diagram.pop_ctm()
     diagram.pop_clippath()
+    diagram.pop_scales()

prefig/core/diagram.py

@@ -3,14 +3,21 @@ import lxml.etree as ET
 import numpy as np
 import logging
 import copy
+import re
 from . import tags
 from . import user_namespace as un
 from . import utilities as util
 from . import CTM
 from . import label
+from . import math_utilities as math_util
+from . import annotations
+from . import repeat
 
 log = logging.getLogger('prefigure')
 
+# regular expression to check if id is EPUB compliant
+epub_id_check = re.compile('^[A-Za-z0-9_-]+$')
+
 class Diagram:
     def __init__(self,
                  diagram_element,
@@ -30,6 +37,18 @@ class Diagram:
         self.environment = environment
         self.caption = ""
 
+        self.add_default_annotations = True
+        if (self.environment == 'pyodide' and
+            len(self.diagram_element.xpath('.//annotations')) == 0
+            ):
+            diagram_annotations = annotations.diagram_to_speech(diagram_element)
+            annotations_tree = ET.SubElement(self.diagram_element,
+                                             'annotations')
+            annotations_tree.append(diagram_annotations)
+            self.add_default_annotations = False
+
+        math_util.set_diagram(self)
+
         label.init(self.format, self.environment)
 
         # create the XML tree for the svg output
@@ -41,7 +60,7 @@ class Diagram:
         self.root = ET.Element("svg", nsmap = nsmap)
 
         self.id_suffix = ['']
-        self.add_id(self.root, diagram_element.get('id', 'diagram'))
+        self.add_id(self.root, diagram_element.get('id', 'pf__figure'))
 
         # prepare the XML tree for annotations, if there are any
         self.annotations_root = None
@@ -60,6 +79,9 @@ class Diagram:
         # a dictionary for holding shapes
         self.shape_dict = {}
 
+        # dictionary for saving graphical data
+        self.saved_data = {}
+
         # each SVG element will have an id, we'll store a count of ids here
         self.ids = {}
 
@@ -72,6 +94,9 @@ class Diagram:
         # stack for managing bounding boxes and clipping
         self.clippaths = []
 
+        # stack for managing scales of coordinate systems
+        self.scale_stack = []
+
         # list for legends
         self.legends = []
 
@@ -86,6 +111,9 @@ class Diagram:
         if publication is not None:
             for subelement in publication:
                 if subelement.tag == 'external-root':
+                    log.warning('<external-root> in publication file is deprecated')
+                    log.warning('Use <directories> instead')
+                    log.warning('See "Working with data" in the PreFigure documentation"')
                     external = subelement.get('name', None)
                     if external is not None:
                         self.external = external
@@ -93,10 +121,42 @@ class Diagram:
                         log.warning('<external-root> in publication file needs a @name')
                     continue
                 self.defaults[subelement.tag] = subelement
+            directories = publication.xpath('.//directories')
+            if len(directories) > 0:
+                directories = directories[0]
+                data_directory = directories.get('data', None)
+                if data_directory is not None:
+                    self.external = data_directory
+
+        templates = self.diagram_element.xpath('.//templates')
+        if len(templates) > 0:
+            templates_element = templates[0]
+            for template in templates:
+                templates_parent = template.getparent()
+                templates_parent.remove(template)
+            for child in templates_element:
+                self.defaults[child.tag] = child
+
+        author_annotations = self.diagram_element.xpath('.//annotations')
+        self.author_annotations_present = len(author_annotations) > 0
+        if self.author_annotations_present:
+            self.check_annotation_ref(author_annotations[0])
 
         if self.defaults.get('macros', None) is not None:
             label.add_macros(self.defaults.get('macros').text)
 
+    def check_annotation_ref(self, element):
+        ref = element.get('ref', None)
+        if ref is not None:
+            if not bool(epub_id_check.fullmatch(ref)):
+                log.error(f"@ref {ref} in an annotation has characters disallowed by EPUB")
+                log.error("  We will replace these characters but there may be unexpected behavior")
+                log.error("  Search for EPUB in the PreFigure documentation https://prefigure.org")
+                ref = repeat.epub_clean(ref)
+                element.set('ref', ref)
+        for child in element:
+            self.check_annotation_ref(child)
+
     def add_legend(self, legend):
         self.legends.append(legend)
         
@@ -135,9 +195,12 @@ class Diagram:
         suffix = ''.join(self.id_suffix)
         if id is None:
             self.ids[element.tag] = self.ids.get(element.tag, -1) + 1
-            return element.tag+'-'+str(self.ids[element.tag])+suffix
+            result_id = element.tag+'-'+str(self.ids[element.tag])+suffix
         else:
-            return id + suffix
+            result_id = id + suffix
+        if result_id.startswith('pf__'):
+            return result_id
+        return 'pf__' + result_id
 
     def append_id_suffix(self, element):
         return self.find_id(element, element.get('id', None))
@@ -148,6 +211,9 @@ class Diagram:
     def set_output_format(self, format):
         self.format = format
 
+    def get_environment(self):
+        return self.environment
+
     # get the HTML tree so that we can add text for labels
     def label_html(self):
         return self.label_html_body
@@ -175,6 +241,12 @@ class Diagram:
             log.error(f"Unable to apply inverse coordinate transform to {p}")
             return np.array([0,0])
 
+    def save_data(self, element, data):
+        self.saved_data[element] = data
+
+    def retrieve_data(self, element):
+        return self.saved_data.get(element, None)
+
     def begin_figure(self):
         # set up the dimensions of the diagram in SVG coordinates
         dims = self.diagram_element.get('dimensions')
@@ -238,6 +310,7 @@ class Diagram:
             h = height + margins[1]+margins[3]
             self.root.set("width", str(w))
             self.root.set("height", str(h))
+            self.root.set("viewBox", f"0 0 {w} {h}")
 
             # initialize the CTM and push it onto the CTM stack
             ctm.translate(0, height + margins[1] + margins[3])
@@ -247,6 +320,7 @@ class Diagram:
         bbox = [0,0,width,height]
         un.enter_namespace('bbox', bbox)
         self.ctm_stack = [[ctm, bbox]]
+        self.scale_stack = [['linear', 'linear']]
 
         # initialize the SVG element 'defs' and add the clipping path
         self.defs = ET.SubElement(self.root, 'defs')
@@ -269,6 +343,15 @@ class Diagram:
     def pop_clippath(self):
         self.clippaths.pop(-1)
 
+    def push_scales(self, scales):
+        self.scale_stack.append(scales)
+
+    def pop_scales(self):
+        self.scale_stack.pop(-1)
+
+    def get_scales(self):
+        return self.scale_stack[-1]
+
     def get_clippath(self):
         return self.clippaths[-1]
     
@@ -332,6 +415,18 @@ class Diagram:
             log.error(f"Unable to write SVG at {out+'.svg'}")
             return
 
+        if self.author_annotations_present and self.environment == "pretext":
+            # we will write out a second version of the diagram
+            # without the height and width attributes for diagcess use
+            self.root.attrib.pop("height")
+            self.root.attrib.pop("width")
+            try:
+                with ET.xmlfile(out + '-diagcess.svg', encoding='utf-8') as xf:
+                    xf.write(self.root, pretty_print=True)
+            except:
+                log.error(f"Unable to write SVG at {out+'-diagcess.svg'}")
+                return
+
         if self.annotations_root is not None:
             diagram = ET.Element('diagram')
             diagram.append(self.annotations_root)
@@ -388,6 +483,15 @@ class Diagram:
             # we're publicly using 'at' rather than 'id' for handles
             if child.get('at') is not None:
                 child.set('id', child.get('at'))
+
+            child_id = child.get('id', None)
+            if child_id is not None:
+                if not bool(epub_id_check.fullmatch(child_id)):
+                    log.error(f"The id {child_id} has characters disallowed by EPUB")
+                    log.error("  We will substitute disallowed characters to make the id EPUB compliant")
+                    log.error("  Search for EPUB in the PreFigure documentation at https://prefigure.org")
+                    child.set('id', repeat.epub_clean(child_id))
+
             # see if the publication flie has any defaults
             defaults = self.defaults.get(child.tag, None)
             if defaults is not None:
@@ -459,6 +563,13 @@ class Diagram:
     def get_root(self):
         return self.root
 
+    def apply_defaults(self, tag, element):
+        default = self.defaults.get(tag, None)
+        if default is not None:
+            for attr, value in default.attrib.items():
+                if element.get(attr, None) is None:
+                    element.set(attr, value)
+
     # when a graphical component is outlined, we first add the component's path
     # to <defs> so that it can be reused, then we stroke it with a thick white
     def add_outline(self, element, path, parent, outline_width = None):
@@ -518,7 +629,11 @@ class Diagram:
         # We have to clean up the arrow heads.  The references to the
         # arrow heads are in the reusable so we'll retrieve them and
         # and include them with the use element.
-        reuse_handle = element.get('id')+self.id_suffix[-1]+'-outline'
+        element_id = element.get('id')
+        if element_id.endswith(self.id_suffix[-1]):
+            reuse_handle = element_id + '-outline'
+        else:
+            reuse_handle = element.get('id')+self.id_suffix[-1]+'-outline'
         reusable = self.get_reusable(reuse_handle)
         use.set('href', r'#' + reuse_handle)
         for marker in ['marker-start', 'marker-end', 'marker-mid']:
@@ -534,6 +649,8 @@ class Diagram:
         self.annotations_root = ET.Element('annotations')
 
     def add_default_annotation(self, annotation):
+        if not self.add_default_annotations:
+            return
         self.default_annotations.append(annotation)
 
     def get_default_annotations(self):
@@ -557,10 +674,16 @@ class Diagram:
 
     def add_annotation_to_branch(self, annotation):
         if len(self.annotation_branch_stack) == 0:
-            self.annotation_branches[annotation.get('id')] = annotation
+            id = annotation.get('id')
+            if not id.startswith('pf__'):
+                id = 'pf__' + id
+            self.annotation_branches[id] = annotation
             return
         self.annotation_branch_stack[-1].append(annotation)
-        annotation.set('id', self.append_id_suffix(annotation))
+        id = self.append_id_suffix(annotation)
+        if not id.startswith('pf__'):
+            id = 'pf__' + id
+        annotation.set('id', id)
 
     def get_annotation_branch(self, id):
         return self.annotation_branches.pop(id, None)

prefig/core/graph.py

@@ -1,7 +1,11 @@
 import lxml.etree as ET
 import logging
+import math
+import numpy as np
+from . import math_utilities as math_util
 from . import user_namespace as un
 from . import utilities as util
+from . import arrow
 
 log = logging.getLogger('prefigure')
 
@@ -14,13 +18,35 @@ def graph(element, diagram, parent, outline_status = None):
         finish_outline(element, diagram, parent)
         return
 
+    polar = element.get('coordinates', 'cartesian') == 'polar'
     # by default, the domain is the width of the bounding box
     bbox = diagram.bbox()
     domain = element.get('domain')
     if domain is None:
-        domain = [bbox[0], bbox[2]]
+        if polar:
+            domain = [0, 2*math.pi]
+        else:
+            domain = [bbox[0], bbox[2]]
     else:
         domain = un.valid_eval(domain)
+        if domain[0] == -np.inf:
+            domain[0] = bbox[0]
+        if domain[1] == np.inf:
+            domain[1] = bbox[2]
+
+    # if there are arrows, we need to pull the domain in by two pixels
+    # so that the arrows don't go outside the domain
+    arrows = int(element.get('arrows', '0'))
+    if arrows > 0 and not polar:
+        end = diagram.transform((domain[1], 0))
+        end[0] -= 2
+        new_domain = diagram.inverse_transform(end)
+        domain[1] = new_domain[0]
+    if arrows == 2 and not polar:
+        begin = diagram.transform((domain[0],0))
+        begin[0] += 2
+        new_domain = diagram.inverse_transform(begin)
+        domain[0] = new_domain[0]
 
     # retrieve the function from the namespace and generate points
     try:
@@ -29,28 +55,11 @@ def graph(element, diagram, parent, outline_status = None):
         log.error(f"Error retrieving function in graph: {str(e)}")
         return
 
-    N = int(element.get('N', 100))
-    dx = (domain[1] - domain[0])/N
-    x = domain[0]
-    cmds = []
-    next_cmd = 'M'
-    upper = 2*bbox[3] - bbox[1]
-    lower = 2*bbox[1] - bbox[3]
-    for _ in range(N+1):
-        try:
-            y = f(x)
-        except:
-            next_cmd = 'M'
-            x += dx
-            continue
-        if y > upper or y < lower:
-            next_cmd = 'M'
-            x += dx
-            continue
-        p = diagram.transform((x, f(x)))
-        cmds += [next_cmd, util.pt2str(p)]
-        next_cmd = 'L'
-        x += dx
+    N = int(element.get('N', '100'))
+    if polar:
+        cmds = polar_path(element, diagram, f, domain, N)
+    else:
+        cmds = cartesian_path(element, diagram, f, domain, N)
 
     # now set up the attributes
     util.set_attr(element, 'thickness', '2')
@@ -66,9 +75,33 @@ def graph(element, diagram, parent, outline_status = None):
             'fill': 'none'
         }
     )
+    if polar and element.get('fill', None) is not None:
+        attrib['fill'] = element.get('fill')
 
     path = ET.Element('path', attrib = attrib)
 
+    arrows = int(element.get('arrows', '0'))
+    forward = 'marker-end'
+    backward = 'marker-start'
+    if element.get('reverse', 'no') == 'yes':
+        forward, backward = backward, forward
+    if arrows > 0:
+        arrow.add_arrowhead_to_path(
+            diagram,
+            forward,
+            path,
+            arrow_width=element.get('arrow-width', None),
+            arrow_angles=element.get('arrow-angles', None)
+        )
+    if arrows > 1:
+        arrow.add_arrowhead_to_path(
+            diagram,
+            backward,
+            path,
+            arrow_width=element.get('arrow-width', None),
+            arrow_angles=element.get('arrow-angles', None)
+        )
+
     # By default, we clip the graph to the bounding box
     if element.get('cliptobbox') is None:
         element.set('cliptobbox', 'yes')
@@ -92,4 +125,184 @@ def finish_outline(element, diagram, parent):
                            element.get('fill', 'none'),
                            parent)
 
+def cartesian_path(element, diagram, f, domain, N):
+    # Sometimes we encounter a divide by zero when building a graph
+    # These are safe to ignore since they return an nan
+    np.seterr(divide="ignore")
+
+    # The graphing routine is relatively straightforward.
+    # We just walk across the horizontal axis and connect points with lines
+    # We try to detect if the function is not defined or if we have passed
+    # a vertical asymptote.  One complication is that we try to get close
+    # to the singularity or vertical asymptote by subdividing the
+    # interval based on the last good point we've seen
+    #
+    # In the vertical direction, we imagine a buffer (lower, upper)
+    # where upper - lower = 3*height and with the viewing box centered inside.
+    # We plot anything in the buffer.
+    #
+    # We maintain a history of sorts using next_cmd, which is either 'M' or 'L'
+    # and last_visible, which tells us whether the last point plotted is
+    # in the viewing window
+
+    scales = diagram.get_scales()
+    if scales[0] == 'log':
+        x_positions = np.logspace(np.log10(domain[0]),
+                                  np.log10(domain[1]),
+                                  N+1)
+    else:
+        x_positions = np.linspace(domain[0], domain[1], N+1)
+
+    bbox = diagram.bbox()
+    dx = (domain[1] - domain[0])/N
+    x = domain[0]
+    cmds = []
+    next_cmd = 'M'
+    if scales[1] == 'log':
+        bottom = np.log10(bbox[1])
+        top = np.log10(bbox[3])
+        lower = 10**(bottom - 3)
+        upper = 10**(top + 3)
+    else:
+        height = (bbox[3] - bbox[1])
+        upper = bbox[3] + height
+        lower = bbox[1] - height
+    last_visible = False
+    for i, x in enumerate(x_positions):
+        if i > 0:
+            dx = x - x_positions[i-1]
+        else:
+            dx = 0
+        try:
+            y = f(x)
+        except:
+            if last_visible:
+                # we plotted the last point so let's find the singularity,
+                # which is in the interval (x-dx, x).  We subdivide 8 times
+                # keeping the last valid value in last_good_x
+                ddx = dx/2
+                xx = x - ddx
+                last_good_x = x - dx
+                for _ in range(8):
+                    ddx /= 2
+                    try:
+                        y = f(xx)
+                    except:
+                        xx -= ddx
+                        continue
+                    last_good_x = xx
+                    xx += ddx
+                p = diagram.transform((last_good_x, f(last_good_x)))
+                cmds += ['L', util.pt2str(p)]
+
+            last_visible = False
+            next_cmd = 'M'
+            x += dx
+            continue
+        if y > upper or y < lower:
+            if last_visible:
+                # the last point was visible so this could be a vertical
+                # asymptote.  We will subdivide until we're in the plotting
+                # range
+                ddx = dx/2
+                xx = x - ddx
+                last_good_x = x - dx
+                for _ in range(8):
+                    ddx /= 2
+                    yy = f(xx)
+                    if yy > upper or yy < lower:
+                        xx -= ddx
+                    else:
+                        last_good_x = xx
+                        xx += ddx
+                p = diagram.transform((last_good_x, f(last_good_x)))
+                cmds += ['L', util.pt2str(p)]
+
+            last_visible = False
+            next_cmd = 'M'
+            x += dx
+            continue
+        if next_cmd == 'M' and x > domain[0]:
+            # let's see if we need to back up a bit to find the asymptote
+            # or edge of the domain
+            ddx = dx/2
+            xx = x - ddx
+            last_good_x = x
+            for _ in range(8):
+                ddx /= 2
+                try:
+                    yy = f(xx)
+                except:
+                    xx += ddx
+                    continue
+                if yy > upper or yy < lower:
+                    xx += ddx
+                    continue
+                last_good_x = xx
+                xx -= ddx
+
+            if last_good_x < x:
+                p = diagram.transform((last_good_x, f(last_good_x)))
+                cmds += ['M', util.pt2str(p)]
+                next_cmd = 'L'
+
+        p = diagram.transform((x, y))
+        cmds += [next_cmd, util.pt2str(p)]
+        next_cmd = 'L'
+        x += dx
+        if y < bbox[3] and y > bbox[1]:
+            last_visible = True
+        else:
+            last_visible = False
+
+    return cmds
+
+def log_path(element, diagram, f, domain, N):
+    log_y = diagram.get_scales()[1] == 'log'
+    x0 = np.log10(domain[0])
+    x1 = np.log10(domain[1])
+    x_values = np.logspace(x0, x1, N+1)
+    cmds = []
+    next_cmd = 'M'
+    for x in x_values:
+        y = f(x)
+        if y < 0 and log_y:
+            next_cmd = 'M'
+            continue
+        p = diagram.transform((x, f(x)))
+        cmds += [next_cmd, util.pt2str(p)]
+        next_cmd = 'L'
+    return cmds
+
+def polar_path(element, diagram, f, domain, N):
+    bbox = diagram.bbox()
+    center = math_util.midpoint(bbox[:2], bbox[2:])
+    R = math_util.distance(center, bbox[2:])
+    
+    if element.get('domain-degrees', 'no') == 'yes':
+        domain = [math.radians(d) for d in domain]
+    t = domain[0]
+    dt = (domain[1] - domain[0])/N
+    polar_cmds = []
+    next_cmd = 'M'
+    for _ in range(N+1):
+        try:
+            r = f(t)
+        except:
+            next_cmd = 'M'
+            t += dt
+            continue
+
+        p = (r*math.cos(t), r*math.sin(t))
+        if math_util.distance(p, center) > 2*R:
+            next_cmd = 'M'
+            t += dt
+            continue
+        polar_cmds.append(next_cmd)
+        polar_cmds.append(util.pt2str(diagram.transform(p)))
+        next_cmd = 'L'
+        t += dt
+    if element.get('closed', 'no') == 'yes':
+        polar_cmds.append('Z')
 
+    return polar_cmds