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

prefig/core/grid_axes.py

@@ -3,12 +3,15 @@ import math
 import re
 import logging
 import numpy as np
+import copy
+from . import math_utilities as math_util
 from . import utilities as util
 from . import user_namespace as un
 from . import label
 from . import line
 from . import arrow
 from . import CTM
+from . import axes
 
 log = logging.getLogger('prefigure')
 
@@ -47,7 +50,66 @@ def find_gridspacing(coordinate_range, pi_format=False):
         x1 = dx * math.floor(coordinate_range[1]/dx+1e-10)
     if pi_format:
         return (x0*math.pi, dx*math.pi, x1*math.pi)
-    return (x0, dx, x1)
+    return [x0, dx, x1]
+
+def find_log_positions(r):
+    # argument r could have
+    #   three arguments if user supplied
+    #   two arguments if not
+    # each range 10^j -> 10^j+1 could have 1, 2, 5, 10, or 1/n lines
+    x0 = np.log10(r[0])
+    x1 = np.log10(r[-1])
+    if len(r) == 3:
+        if r[1] < 1:
+            spacing = r[1]
+        elif r[1] < 2:
+            spacing = 1
+        elif r[1] < 4:
+            spacing = 2
+        elif r[1] < 7:
+            spacing = 5
+        else:
+            spacing = 10
+    else:
+        width = abs(x1 - x0)
+        if width < 1.5:
+            spacing = 10
+        elif width < 3:
+            spacing = 5
+        elif width < 5:
+            spacing = 2
+        elif width <= 10:
+            spacing = 1
+        else:
+            spacing = 10/width
+
+    x0 = math.floor(x0)
+    x1 = math.ceil(x1)
+    positions = []
+    if spacing <= 1:
+        gap = round(1/spacing)
+        x = x0
+        while x <= x1:
+            positions.append(10**x)
+            x += gap
+    else:
+        if spacing == 2:
+            intermediate = [1,5]
+        elif spacing == 5:
+            intermediate = [1,2,4,6,8]
+        elif spacing == 10:
+            intermediate = [1,2,3,4,5,6,7,8,9]
+        else:
+            intermediate = [1]
+        x = x0
+        while x <= x1:
+            positions += [10**x*c for c in intermediate]
+            x += 1
+    return positions
+
+def find_linear_positions(r):
+    N = round((r[2] - r[0]) / r[1])
+    return np.linspace(r[0], r[2], N+1)
 
 # Add a graphical element for a grid.  All the grid lines sit inside a group
 def grid(element, diagram, parent, outline_status):
@@ -58,9 +120,14 @@ def grid(element, diagram, parent, outline_status):
 
     thickness = element.get('thickness', '1')
     stroke = element.get('stroke', r'#ccc')
+    id = element.get('id')
+    if id is None:
+        id = 'pf__grid'
+    if not id.startswith('pf__'):
+        id = 'pf__' + id
     grid = ET.SubElement(parent, 'g',
                          attrib={
-                             'id': element.get('id', 'grid'),
+                             'id': id,
                              'stroke': stroke,
                              'stroke-width': thickness
                          }
@@ -73,490 +140,131 @@ def grid(element, diagram, parent, outline_status):
     h_pi_format = element.get('h-pi-format', 'no') == 'yes'
     v_pi_format = element.get('v-pi-format', 'no') == 'yes'
     
+    coordinates = element.get('coordinates', 'cartesian')
+    scales = diagram.get_scales()
+    hspacings_set = False
     if spacings is not None:
         try:
             rx, ry = un.valid_eval(spacings)
+            if scales[0] == 'log':
+                x_positions = find_log_positions(rx)
+            else:
+                x_positions = find_linear_positions(rx)
+            if scales[1] == 'log':
+                y_positions = find_log_positions(ry)
+            else:
+                y_positions = find_linear_positions(ry)
+
+            hspacings_set = True
         except:
             log.error(f"Error in <grid> parsing spacings={element.get('spacings')}")
             return
     else:
         rx = element.get('hspacing')
         if rx is None:
-            rx = find_gridspacing((bbox[0], bbox[2]), h_pi_format) 
+            if scales[0] == 'log':
+                x_positions = find_log_positions((bbox[0], bbox[2]))
+            else:
+                rx = find_gridspacing((bbox[0], bbox[2]), h_pi_format)
+                x_positions = find_linear_positions(rx)
         else:
             rx = un.valid_eval(rx)
+            if scales[0] == 'log':
+                x_positions = find_log_positions(rx)
+            else:
+                x_positions = find_linear_positions(rx)
+            hspacings_set = True
 
-        ry = element.get('vspacing')
-        if ry is None:
-            ry = find_gridspacing((bbox[1], bbox[3]), v_pi_format)
+        if coordinates == 'polar':
+            ry = [0, math.pi/6, 2*math.pi]
         else:
-            ry = un.valid_eval(ry)
+            ry = element.get('vspacing')
+            if ry is None:
+                if scales[1] == 'log':
+                    y_positions = find_log_positions((bbox[1], bbox[3]))
+                else:
+                    ry = find_gridspacing((bbox[1], bbox[3]), v_pi_format)
+                    y_positions = find_linear_positions(ry)
+            else:
+                ry = un.valid_eval(ry)
+                if scales[1] == 'log':
+                    y_positions = find_log_positions(ry)
+                else:
+                    y_positions = find_linear_positions(ry)
+
+    if coordinates == 'polar':
+        id = diagram.get_clippath()
+        grid.set('clip-path', r'url(#{})'.format(id))
+        
+        bbox = list(diagram.bbox())
+        endpoints = []
+        for _ in range(4):
+            endpoints.append(bbox[:2])
+            bbox = bbox[1:] + [bbox[0]]
+        R = max([math_util.length(p) for p in endpoints])
+        if hspacings_set:
+            R = rx[2]
+        r = rx[1]
+        N = 100
+        dt = 2*math.pi/N
+        while r <= R:
+            circle = ET.SubElement(grid, 'path')
+            t = 0
+            cmds = ['M']
+            point = diagram.transform([r*math.cos(t), r*math.sin(t)])
+            cmds.append(util.pt2str(point))
+            for _ in range(N):
+                t += dt
+                cmds.append('L')
+                point = diagram.transform([r*math.cos(t), r*math.sin(t)])
+                cmds.append(util.pt2str(point))
+            cmds.append('Z')
+            circle.set('d', ' '.join(cmds))
+            circle.set('fill', 'none')
+            r += rx[1]
+
+        if element.get('spacing-degrees', 'no') == 'yes':
+            ry = [math.radians(t) for t in ry]
+        t = ry[0]
+        while t <= ry[2]:
+            direction = np.array([math.cos(t), math.sin(t)])
+            intersection_times = []
+            vert, horiz =  np.isclose(direction, np.array([0,0]))
+            if not vert:
+                intersection_times.append(bbox[0]/direction[0])
+                intersection_times.append(bbox[2]/direction[0])
+            if not horiz:
+                intersection_times.append(bbox[1]/direction[1])
+                intersection_times.append(bbox[3]/direction[1])
+            intersection_time = max(intersection_times)
+            if hspacings_set:
+                intersection_time = R
+            if intersection_time > 0:
+                line_el = ET.SubElement(grid, 'line')
+                start = diagram.transform((0,0))
+                end = diagram.transform(intersection_time*direction)
+                line_el.set('x1', util.float2str(start[0]))
+                line_el.set('y1', util.float2str(start[1]))
+                line_el.set('x2', util.float2str(end[0]))
+                line_el.set('y2', util.float2str(end[1]))
+
+            t += ry[1]
+        return
 
-    x = rx[0]
-    while x <= rx[2]:
+    # now we'll just build a plain rectangular grid
+    for x in x_positions:
+        if x < bbox[0] or x > bbox[2]:
+            continue
         line_el = line.mk_line((x,bbox[1]), (x,bbox[3]), diagram)
-#        line_el.set('type', 'vertical grid')
+        line_el.attrib.pop('id')
         grid.append(line_el)
-        x += rx[1]
 
-    y = ry[0]
-    while y <= ry[2]:
+    for y in y_positions:
+        if y < bbox[1] or y > bbox[3]:
+            continue
         line_el = line.mk_line((bbox[0], y), (bbox[2], y), diagram)
-#        line_el.set('type', 'horizontal grid')
+        line_el.attrib.pop('id')
         grid.append(line_el)
-        y += ry[1]
-
-# Automate finding the positions where ticks and labels go
-label_delta = {2: 0.2, 3: 0.5, 4: 0.5, 5: 1,
-               6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1,
-               12: 2, 13: 2, 14: 2, 15: 2, 16: 2, 17: 2,
-               18: 2, 19: 2, 20: 2}
-
-def find_label_positions(coordinate_range, pi_format = False):
-    if pi_format:
-        coordinate_range = [c/math.pi for c in coordinate_range]
-    dx = 1
-    distance = abs(coordinate_range[1]-coordinate_range[0])
-    while distance > 10:
-        distance /= 10
-        dx *= 10
-    while distance <= 1:
-        distance *= 10
-        dx /= 10
-    if dx > 1:
-        dx *= label_delta[round(2*distance)]
-        dx = int(dx)
-    else:
-        dx *= label_delta[round(2*distance)]
-    if coordinate_range[1] < coordinate_range[0]:
-        dx *= -1
-        x0 = dx * math.floor(coordinate_range[0]/dx+1e-10)
-        x1 = dx * math.ceil(coordinate_range[1]/dx-1e-10)
-    else:
-        x0 = dx * math.ceil(coordinate_range[0]/dx-1e-10)
-        x1 = dx * math.floor(coordinate_range[1]/dx+1e-10)
-    return (x0, dx, x1)
-
-# find a string representation of x*pi
-def get_pi_text(x):
-    if abs(abs(x) - 1) < 1e-10:
-        if x < 0:
-            return r'-\pi'
-        return r'\pi'
-
-    if abs(x - round(x)) < 1e-10:
-        return str(round(x))+r'\pi'
-    if abs(4*x - round(4*x)) < 1e-10:
-        num = round(4*x)
-        if num == -1:
-            return r'-\pi/4'
-        if num == 1:
-            return r'\pi/4'
-        if num % 2 == 1:
-            return str(num)+r'\pi/4'
-    if abs(2*x - round(2*x)) < 1e-10:
-        num = round(2*x)
-        if num == -1:
-            return r'-\pi/2'
-        if num == 1:
-            return r'\pi/2'
-        return str(num)+r'\pi/2'
-    if abs(3*x - round(3*x)) < 1e-10:
-        num = round(3*x)
-        if num == -1:
-            return r'-\pi/3'
-        if num == 1:
-            return r'\pi/3'
-        return str(num)+r'\pi/3'
-    return r'{0:g}\pi'.format(x)
-    
-
-# Add a graphical element for axes.  All the axes sit inside a group
-# There are a number of options to add: labels, tick marks, etc
-position_tolerance = 1e-10
-def axes(element, diagram, parent, outline_status):
-    stroke = element.get('stroke', 'black')
-    thickness = element.get('thickness', '2')
-    clear_background = element.get('clear-background', 'no') == 'yes'
-
-    axes = ET.SubElement(parent, 'g',
-                         attrib={
-                             'id': element.get('id', 'axes'),
-                             'stroke': stroke,
-                             'stroke-width': thickness
-                             }
-    )
-
-    util.cliptobbox(axes, element, diagram)
-    ctm, bbox = diagram.ctm_bbox()
-
-    top_labels = False
-    y_axis_location = 0
-    y_axis_offsets = (0,0)
-    h_zero_include = False
-    if bbox[1] * bbox[3] >= 0:
-        if bbox[3] <= 0:
-            top_labels = True
-            y_axis_location = bbox[3]
-            if bbox[3] < 0:
-                y_axis_offsets = (0,-5)
-        else:
-            if abs(bbox[1]) > 1e-10:
-                y_axis_location = bbox[1]
-                y_axis_offsets = (5,0)
-
-    h_frame = element.get('h-frame', None)
-    if h_frame == 'bottom':
-        y_axis_location = bbox[1]
-        y_axis_offsets = (0,0)
-        h_zero_include = True
-    if h_frame == 'top':
-        y_axis_location = bbox[3]
-        y_axis_offsets = (0,0)
-        h_zero_include = True
-        top_labels = True
-
-    y_axis_offsets = np.array(y_axis_offsets)
-
-    right_labels = False
-    x_axis_location = 0
-    x_axis_offsets = (0,0)
-    v_zero_include = False
-    if bbox[0] * bbox[2] >= 0:
-        if bbox[2] <= 0:
-            right_labels = True
-            x_axis_location = bbox[2]
-            if bbox[2] < 0:
-                x_axis_offsets = (0,-10)
-        else:
-            if abs(bbox[0]) > 1e-10:
-                x_axis_location = bbox[0]
-                x_axis_offsets = (10,0)
-
-    v_frame = element.get('v-frame', None)
-    if v_frame == 'left':
-        x_axis_location = bbox[0]
-        x_axis_offsets = (0,0)
-        v_zero_include = True
-    if v_frame == 'right':
-        x_axis_location = bbox[2]
-        x_axis_offsets = (0,0)
-        v_zero_include = True
-        right_labels = True
-
-    x_axis_offsets = np.array(x_axis_offsets)
-    
-    try:
-        arrows = int(element.get('arrows', '0'))
-    except:
-        log.error(f"Error in <axes> parsing arrows={element.get('arrows')}")
-        arrows = 0
-
-    # process xlabel and ylabel
-    for child in element:
-        if child.tag == "xlabel":
-            child.tag = "label"
-            child.set("user-coords", "no")
-            anchor = diagram.transform((bbox[2], y_axis_location))
-            child.set("anchor", util.pt2str(anchor, spacer=","))
-            if child.get("alignment", None) is None:
-                child.set("alignment", "east")
-                if child.get("offset", None) is None:
-                    if arrows > 0:
-                        child.set("offset", "(2,0)")
-                    else:
-                        child.set("offset", "(1,0)")
-            if clear_background:
-                child.set('clear-background', 'yes')
-            label.label(child, diagram, parent)
-            continue
-        if child.tag == "ylabel":
-            child.tag = "label"
-            child.set("user-coords", "no")
-            anchor = diagram.transform((x_axis_location, bbox[3]))
-            child.set("anchor", util.pt2str(anchor, spacer=","))
-            if child.get("alignment", None) is None:
-                child.set("alignment", "north")
-                if child.get("offset", None) is None:
-                    if arrows > 0:
-                        child.set("offset", "(0,2)")
-                    else:
-                        child.set("offset", "(0,1)")
-            if clear_background:
-                child.set('clear-background', 'yes')
-            label.label(child, diagram, parent)
-            continue
-        log.info(f"{child.tag} element is not allowed inside a <label>")
-        continue
-
-    decorations = element.get('decorations', 'yes')
-
-    left_axis = diagram.transform((bbox[0], y_axis_location))
-    right_axis = diagram.transform((bbox[2], y_axis_location))
-
-    h_line_el = line.mk_line(left_axis,
-                             right_axis,
-                             diagram,
-                             endpoint_offsets = x_axis_offsets,
-                             user_coords = False)
-    h_line_el.set('stroke', stroke)
-#    h_line_el.set('type', 'horizontal axis')
-    h_line_el.set('stroke-width', thickness)
-    if element.get('axes', 'yes') == 'yes':
-        axes.append(h_line_el)
-
-    bottom_axis = diagram.transform((x_axis_location, bbox[1]))
-    top_axis = diagram.transform((x_axis_location, bbox[3]))
-
-    v_line_el = line.mk_line(bottom_axis,
-                             top_axis,
-                             diagram,
-                             endpoint_offsets = y_axis_offsets,
-                             user_coords = False)
-    v_line_el.set('stroke', stroke)
-#    v_line_el.set('type', 'vertical axis')
-    v_line_el.set('stroke-width', thickness)
-    if element.get('axes', 'yes') == 'yes':
-        axes.append(v_line_el)
-
-    if arrows > 0:
-        arrow.add_arrowhead_to_path(diagram, 'marker-end', h_line_el)
-        arrow.add_arrowhead_to_path(diagram, 'marker-end', v_line_el)
-    if arrows > 1:
-        arrow.add_arrowhead_to_path(diagram, 'marker-start', h_line_el)
-        arrow.add_arrowhead_to_path(diagram, 'marker-start', v_line_el)
-
-    if element.get('labels', 'yes') == 'no':
-        return
-
-    hticks = element.get('hticks', None)
-    vticks = element.get('vticks', None)
-
-    h_pi_format = element.get('h-pi-format', 'no') == 'yes'
-    v_pi_format = element.get('v-pi-format', 'no') == 'yes'
-    
-    hlabels = element.get('hlabels')
-    if hlabels is None:
-        hlabels = find_label_positions((bbox[0], bbox[2]),
-                                       pi_format = h_pi_format)
-    else:
-        try:
-            hlabels = un.valid_eval(hlabels)
-        except:
-            log.error(f"Error in <axes> parsing hlabels={hlabels}")
-            return
-        if h_pi_format:
-            hlabels = 1/math.pi * hlabels
-
-    g_hticks = ET.SubElement(axes, 'g',
-                             attrib={
-#                                 'type': 'horizontal ticks'
-                             }
-                             )
-    diagram.add_id(g_hticks)
-
-    h_exclude = [bbox[0], bbox[2]]
-    if not h_zero_include:
-        h_exclude.append(0)
-
-    if diagram.output_format() == 'tactile':
-        ticksize = (18, 0)
-    else:
-        ticksize = (3, 3)
-    if hticks is not None:
-        try:
-            hticks = un.valid_eval(hticks)
-        except:
-            log.error(f"Error in <axes> parsing hticks={hticks}")
-            return
-        x = hticks[0]
-        tick_direction = 1
-        if top_labels:
-            tick_direction = -1
-        while x <= hticks[2]:
-            if any([abs(x-p) < position_tolerance for p in [bbox[0], bbox[2]]]):
-                x += hticks[1]
-                continue
-            p = diagram.transform((x,y_axis_location))
-            line_el = line.mk_line((p[0], p[1]+tick_direction*ticksize[0]),
-                                   (p[0], p[1]-tick_direction*ticksize[1]),
-                                   diagram,
-                                   user_coords=False)
-#            line_el.set('type', 'tick on horizontal axis')
-            g_hticks.append(line_el)
-            x += hticks[1]
-
-    h_scale = 1
-    if h_pi_format:
-        h_scale = math.pi
-    if decorations == 'yes' or element.get('hlabels', None) is not None:
-        x = hlabels[0]
-        tick_direction = 1
-        if top_labels:
-            tick_direction = -1
-        while x <= hlabels[2]:
-            if any([abs(x*h_scale-p) < position_tolerance for p in h_exclude]):
-                x += hlabels[1]
-                continue
-
-            xlabel = ET.Element('label')
-            math_element = ET.SubElement(xlabel, 'm')
-            math_element.text = r'\text{'+'{0:g}'.format(x)+'}'
-            if h_pi_format:
-                math_element.text = get_pi_text(x)
-
-            xlabel.set('p', '({},{})'.format(x*h_scale, y_axis_location))
-            if diagram.output_format() == 'tactile':
-                if top_labels:
-                    xlabel.set('alignment', 'hat')
-                    xlabel.set('offset', '(0,0)')
-                else:
-                    xlabel.set('alignment', 'ha')
-                    xlabel.set('offset', '(0,0)')
-            else:
-                if top_labels:
-                    xlabel.set('alignment', 'north')
-                    xlabel.set('offset', '(0,7)')
-                else:
-                    xlabel.set('alignment', 'south')
-                    xlabel.set('offset', '(0,-7)')
-#            xlabel.set('clear-background', 'no')
-            if clear_background:
-                xlabel.set('clear-background', 'yes')
-            label.label(xlabel, diagram, parent, outline_status)
-
-            p = diagram.transform((x*h_scale,y_axis_location))
-            line_el = line.mk_line((p[0], p[1]+tick_direction*ticksize[0]),
-                                   (p[0], p[1]-tick_direction*ticksize[1]),
-                                   diagram,
-                                   user_coords=False)
-#            line_el.set('type', 'tick on horizontal axis')
-            g_hticks.append(line_el)
-
-            x += hlabels[1]
-
-    vlabels = element.get('vlabels')
-    if vlabels is None:
-        vlabels = find_label_positions((bbox[1], bbox[3]),
-                                       pi_format = v_pi_format)
-    else:
-        try:
-            vlabels = un.valid_eval(vlabels)
-        except:
-            log.error(f"Error in <axes> parsing vlabels={vlabels}")
-            return
-        if v_pi_format:
-            vlabels = 1/math.pi * vlabels
-            
-#    g_vticks = ET.SubElement(axes, 'g', attrib={
-#                              'type': 'vertical ticks'
-#                              }
-#    )
-    g_vticks = ET.SubElement(axes, 'g')
-    diagram.add_id(g_vticks)
-
-    v_exclude = [bbox[1], bbox[3]]
-    if not v_zero_include:
-        v_exclude.append(0)
-
-    if vticks is not None:
-        try:
-            vticks = un.valid_eval(vticks)
-        except:
-            log.error(f"Error in <axes> parsing vticks={vticks}")
-            return
-        y = vticks[0]
-        tick_direction = 1
-        if right_labels:
-            tick_direction = -1
-        while y <= vticks[2]:
-            if any([abs(y-p) < position_tolerance for p in [bbox[1], bbox[3]]]):
-                y += vticks[1]
-                continue
-            p = diagram.transform((x_axis_location, y))
-            line_el = line.mk_line((p[0]-tick_direction*ticksize[0], p[1]),
-                                   (p[0]+tick_direction*ticksize[1], p[1]),
-                                   diagram,
-                                   user_coords=False)
-#            line_el.set('type', 'tick on vertical axis')
-            g_vticks.append(line_el)
-            y += vticks[1]
-
-    v_scale = 1
-    if v_pi_format:
-        v_scale = math.pi
-    if decorations == 'yes' or element.get('vlabels', None) is not None:
-        y = vlabels[0]
-        tick_direction = 1
-        if right_labels:
-            tick_direction = -1
-        while y <= vlabels[2]:
-            if any([abs(y*v_scale-p) < position_tolerance for p in v_exclude]):
-                y += vlabels[1]
-                continue
-
-            ylabel = ET.Element('label')
-            math_element = ET.SubElement(ylabel, 'm')
-            math_element.text = r'\text{'+'{0:g}'.format(y)+'}'
-            if v_pi_format:
-                math_element.text = get_pi_text(y)
-            # process as a math number
-            ylabel.set('p', '({},{})'.format(x_axis_location, y*v_scale))
-
-            if diagram.output_format() == 'tactile':
-                if right_labels:
-                    ylabel.set('alignment', 'east')
-                    ylabel.set('offset', '(25, 0)')
-                else:
-                    ylabel.set('alignment', 'va')
-                    ylabel.set('offset', '(-25, 0)')
-            else:
-                if right_labels:
-                    ylabel.set('alignment', 'east')
-                    ylabel.set('offset', '(7,0)')
-                else:
-                    ylabel.set('alignment', 'west')
-                    ylabel.set('offset', '(-7,0)')
-
-#            ylabel.set('clear-background', 'no')
-            if clear_background:
-                ylabel.set('clear-background', 'yes')
-            label.label(ylabel, diagram, parent, outline_status)
-            p = diagram.transform((x_axis_location, y*v_scale))
-            line_el = line.mk_line((p[0]-tick_direction*ticksize[0], p[1]),
-                                   (p[0]+tick_direction*ticksize[1], p[1]),
-                                   diagram,
-                                   user_coords=False)
-#            line_el.set('type', 'tick on vertical axis')
-            g_vticks.append(line_el)
-            y += vlabels[1]
-
-    xlabel = element.get('xlabel')
-    if xlabel is not None:
-        el = ET.Element('label')
-        math_element = ET.SubElement(el, 'm')
-        math_element.text = xlabel
-        el.set('clear-background', 'no')
-        el.set('p', '({},{})'.format(bbox[2], y_axis_location))
-        el.set('alignment', 'xl')
-        if arrows > 0:
-            if diagram.output_format() == 'tactile':
-                el.set('offset', '(-6,6)')
-            else:
-                el.set('offset', '(-2,2)')
-        label.label(el, diagram, parent, outline_status)
-
-    ylabel = element.get('ylabel')
-    if ylabel is not None:
-        el = ET.Element('label')
-        math_element = ET.SubElement(el, 'm')
-        math_element.text = ylabel
-        el.set('clear-background', 'no')
-        el.set('p', '({},{})'.format(x_axis_location, bbox[3]))
-        el.set('alignment', 'se')
-        if arrows > 0:
-            el.set('offset', '(2,-2)')
-        label.label(el, diagram, parent, outline_status)
 
 
 # Adds both a grid and axes with spacings found automatically
@@ -565,49 +273,27 @@ def grid_axes(element, diagram, parent, outline_status):
     group = ET.SubElement(parent, 'g',
                           attrib=
                           {
-                              'id': 'grid-axes'
+                              'id': 'pf__grid-axes'
                           }
     )
 
     group_annotation = ET.Element('annotation')
-    group_annotation.set('ref', 'grid-axes')
+    group_annotation.set('ref', 'pf__grid-axes')
     group_annotation.set('text', 'The coordinate grid and axes')
     diagram. add_default_annotation(group_annotation)
 
     grid(element, diagram, group, outline_status)
 
     annotation = ET.Element('annotation')
-    annotation.set('ref', 'grid')
+    annotation.set('ref', 'pf__grid')
     annotation.set('text', 'The coordinate grid')
     group_annotation.append(annotation)
 
-    el = ET.Element('axes')
-    el.set('id', 'axes')
-    if element.get('xlabel') is not None:
-        el.set('xlabel', element.get('xlabel'))
-    if element.get('ylabel') is not None:
-        el.set('ylabel', element.get('ylabel'))
-    if element.get('decorations') is not None:
-        el.set('decorations', element.get('decorations'))
-    if element.get('hlabels') is not None:
-        el.set('hlabels', element.get('hlabels'))
-    if element.get('vlabels') is not None:
-        el.set('vlabels', element.get('vlabels'))
-    if element.get('h-pi-format') is not None:
-        el.set('h-pi-format', element.get('h-pi-format'))
-    if element.get('v-pi-format') is not None:
-        el.set('v-pi-format', element.get('v-pi-format'))
-    if element.get('h-frame') is not None:
-        el.set('h-frame', element.get('h-frame'))
-    if element.get('v-frame') is not None:
-        el.set('v-frame', element.get('v-frame'))
-    for child in element:
-        el.append(child)
-        
-    axes(el, diagram, group, outline_status)
+    element.set('id', 'pf__axes')
+    axes.axes(element, diagram, group, outline_status)
 
     annotation = ET.Element('annotation')
-    annotation.set('ref', 'axes')
+    annotation.set('ref', 'pf__axes')
     annotation.set('text', 'The coordinate axes')
     group_annotation.append(annotation)