Merge pull request #1407 from mathics/svg-formatter-size-adjust

Handle PointSize in PointBox  (roughly)

Author: rocky

mathics/builtin/graphics.py

@@ -1279,7 +1279,6 @@ class Point(Builtin):
         <dd>represents a number of point primitives.
     </dl>
 
-    >> Graphics[Point[{0,0}]]
     = -Graphics-
 
     >> Graphics[Point[Table[{Sin[t], Cos[t]}, {t, 0, 2. Pi, Pi / 15.}]]]
@@ -1292,10 +1291,29 @@ class Point(Builtin):
     pass
 
 
+# FIXME: We model points as line segments which
+# is kind of  wrong.
 class PointBox(_Polyline):
+    """
+    A Bounding box for a list of points.
+    object attributes:
+    edge_color: _Color
+    point_radius: radius of each point
+    """
     def init(self, graphics, style, item=None):
         super(PointBox, self).init(graphics, item, style)
         self.edge_color, self.face_color = style.get_style(_Color, face_element=True)
+
+        # Handle PointSize in a hacky way for now.
+        point_size, _ = style.get_style(PointSize, face_element=False)
+        if point_size is None:
+            point_size = PointSize(self.graphics, value=0.005)
+
+        # FIXME: we don't have graphics options. Until we do, we'll
+        # just assume an image width of 400
+        image_width = 400
+        self.point_radius = (image_width * point_size.value)
+
         if item is not None:
             if len(item.leaves) != 1:
                 raise BoxConstructError
@@ -1307,6 +1325,19 @@ def init(self, graphics, style, item=None):
         else:
             raise BoxConstructError
 
+    def extent(self):
+        """Returns a list of bounding-box coordinates each point in the PointBox"""
+        l = self.point_radius
+        result = []
+        for line in self.lines:
+            for c in line:
+                x, y = c.pos()
+                result.extend(
+                    [(x - l, y - l), (x - l, y + l), (x + l, y - l), (x + l, y + l)]
+                )
+        return result
+
+
 
 class Line(Builtin):
     """
@@ -2382,6 +2413,7 @@ def __init__(self, content, evaluation, neg_y=False):
         self.xmin = self.ymin = self.pixel_width = None
         self.pixel_height = self.extent_width = self.extent_height = None
         self.view_width = None
+        self.content = content
 
     def translate(self, coords):
         if self.pixel_width is not None:
@@ -2512,8 +2544,8 @@ def _get_image_size(self, options, graphics_options, max_width):
     def _prepare_elements(self, leaves, options, neg_y=False, max_width=None):
         if not leaves:
             raise BoxConstructError
-        graphics_options = self.get_option_values(leaves[1:], **options)
-        background = graphics_options["System`Background"]
+        self.graphics_options = self.get_option_values(leaves[1:], **options)
+        background = self.graphics_options["System`Background"]
         if (
             isinstance(background, Symbol)
             and background.get_name() == "System`Automatic"
@@ -2523,10 +2555,10 @@ def _prepare_elements(self, leaves, options, neg_y=False, max_width=None):
             self.background_color = _Color.create(background)
 
         base_width, base_height, size_multiplier, size_aspect = self._get_image_size(
-            options, graphics_options, max_width
+            options, self.graphics_options, max_width
         )
 
-        plot_range = graphics_options["System`PlotRange"].to_python()
+        plot_range = self.graphics_options["System`PlotRange"].to_python()
         if plot_range == "System`Automatic":
             plot_range = ["System`Automatic", "System`Automatic"]
 
@@ -2658,7 +2690,7 @@ def get_range(min, max):
         ymax += h * 0.02
 
         axes.extend(
-            self.create_axes(elements, graphics_options, xmin, xmax, ymin, ymax)
+            self.create_axes(elements, self.graphics_options, xmin, xmax, ymin, ymax)
         )
 
         return elements, calc_dimensions
@@ -2725,6 +2757,7 @@ def boxes_to_mathml(self, leaves=None, **options) -> str:
         elements, calc_dimensions = self._prepare_elements(leaves, options, neg_y=True)
         xmin, xmax, ymin, ymax, w, h, width, height = calc_dimensions()
         data = (elements, xmin, xmax, ymin, ymax, w, h, width, height)
+        elements.view_width = w
 
         # FIXME: SVG is the only thing we can convert MathML into.
         # Handle other graphics formats.

mathics/doc/tex/Makefile

@@ -16,6 +16,11 @@ doc_tex_data.pcl:
 mathics.pdf: mathics.tex documentation.tex logo-text-nodrop.pdf logo-heptatom.pdf doc_tex_data.pcl
 	$(LATEXMK) -f -pdf -pdflatex="$(XETEX) -halt-on-error" mathics
 
+#: Build test PDF
+mathics-test.pdf: mathics-test.tex
+	$(LATEXMK) -f -pdf -pdflatex="$(XETEX) -halt-on-error" mathics-test
+
+
 #: Generate logos used in the titlepage
 logo-heptatom.pdf logo-text-nodrop.pdf:
 	(cd .. && $(BASH) ./images.sh)
@@ -34,3 +39,4 @@ clean:
 	rm -f mathics_*.* || true
 	rm -f mathics-*.* documentation.tex || true
 	rm -f mathics.pdf mathics.dvi data_tex_data.pcl || true
+	rm -f mathics-test.pdf mathics-test.dvi || true

mathics/formatter/svg.py

@@ -33,19 +33,19 @@ def matrix(self, a, b, c, d, e, f):
         # a c e
         # b d f
         # 0 0 1
-        self.transforms.append("matrix(%f, %f, %f, %f, %f, %f)" % (a, b, c, d, e, f))
+        self.transforms.append(f"matrix({a:f}, {b:f}, {c:f}, {d:f}, {e:f}, {e:f})")
 
     def translate(self, x, y):
-        self.transforms.append("translate(%f, %f)" % (x, y))
+        self.transforms.append(f"translate({x:f}, {y:f})")
 
     def scale(self, x, y):
-        self.transforms.append("scale(%f, %f)" % (x, y))
+        self.transforms.append(f"scale({x:f}, {y:f})")
 
     def rotate(self, x):
-        self.transforms.append("rotate(%f)" % x)
+        self.transforms.append(f"rotate({x:f})")
 
     def apply(self, svg):
-        return '<g transform="%s">%s</g>' % (" ".join(self.transforms), svg)
+        return f"""<g transform="{' '.join(self.transforms)}">{svg}</g>"""
 
 
 def create_css(
@@ -57,22 +57,22 @@ def create_css(
     css = []
     if edge_color is not None:
         color, stroke_opacity = edge_color.to_css()
-        css.append("stroke: %s" % color)
-        css.append("stroke-opacity: %s" % stroke_opacity)
+        css.append(f"stroke: {color}")
+        css.append(f"stroke-opacity: {stroke_opacity}")
     else:
         css.append("stroke: none")
     if stroke_width is not None:
-        css.append("stroke-width: %fpx" % stroke_width)
+        css.append(f"stroke-width: {stroke_width:f}px")
     if face_color is not None:
         color, fill_opacity = face_color.to_css()
-        css.append("fill: %s" % color)
-        css.append("fill-opacity: %s" % fill_opacity)
+        css.append(f"fill: {color}")
+        css.append(f"fill-opacity: {fill_opacity}")
     else:
         css.append("fill: none")
     if font_color is not None:
         color, _ = font_color.to_css()
-        css.append("color: %s" % color)
-    css.append("opacity: %s" % opacity)
+        css.append(f"color: {color}")
+    css.append(f"opacity: {opacity}")
     return "; ".join(css)
 
 
@@ -86,7 +86,7 @@ def arrow_box(self, **options):
     def polygon(points):
         yield '<polygon points="'
         yield " ".join("%f,%f" % xy for xy in points)
-        yield '" style="%s" />' % arrow_style
+        yield f'" style="{arrow_style}" />'
 
     extent = self.graphics.view_width or 0
     default_arrow = self._default_arrow(polygon)
@@ -104,7 +104,7 @@ def beziercurvebox(self, **options):
     svg = ""
     for line in self.lines:
         s = " ".join(_svg_bezier((self.spline_degree, [xy.pos() for xy in line])))
-        svg += '<path d="%s" style="%s"/>' % (s, style)
+        svg += f'<path d="{s}" style="{style}"/>'
     # print("XXX bezier", svg)
     return svg
 
@@ -133,6 +133,7 @@ def components():
 add_conversion_fn(FilledCurveBox, filled_curve_box)
 
 def graphics_box(self, leaves=None, **options) -> str:
+
         if not leaves:
             leaves = self._leaves
 
@@ -164,24 +165,20 @@ def graphics_box(self, leaves=None, **options) -> str:
                 svg_body,
             )
 
-        xmin -= 1
-        ymin -= 1
-        w += 2
-        h += 2
-
         if options.get("noheader", False):
             return svg_body
         svg_main = """
-            <svg xmlns:svg="http://www.w3.org/2000/svg"
+<svg xmlns:svg="http://www.w3.org/2000/svg"
                 xmlns="http://www.w3.org/2000/svg"
                 version="1.1"
                 viewBox="%s">
                 %s
-            </svg>
-        """ % (
+</svg>
+""" % (
             " ".join("%f" % t for t in (xmin, ymin, w, h)),
             svg_body,
         )
+        # print("svg_main", svg_main)
         return svg_main  # , width, height
 
 
@@ -200,7 +197,9 @@ def graphics_elements(self, **options)->str:
         else:
             result.append(format_fn(element, **options))
 
-    return "\n".join(result)
+    svg = "\n".join(result)
+    # print("graphics_elements", svg)
+    return svg
 
 
 add_conversion_fn(GraphicsElements, graphics_elements)
@@ -256,7 +255,7 @@ def line_box(self, **options)->str:
             " ".join(["%f,%f" % coords.pos() for coords in line]),
             style,
         )
-    # print("XXX linebox", svg)
+    # print("LineBox", svg)
     return svg
 
 
@@ -275,13 +274,10 @@ def pointbox(self, **options)->str:
     svg = ""
     for line in self.lines:
         for coords in line:
-            svg += '<circle cx="%f" cy="%f" r="%f" style="%s" />' % (
-                coords.pos()[0],
-                coords.pos()[1],
-                size,
-                style,
-            )
-    # print("XXX PointBox", svg)
+            svg += f"""
+  <circle cx="{coords.pos()[0]:f}" cy="{coords.pos()[1]:f}"
+          r="{size:f}" style="{style}"/>"""
+    # print("PointBox", svg)
     return svg
 
 
@@ -312,7 +308,7 @@ def polygonbox(self, **options):
             " ".join("%f,%f" % coords.pos() for coords in line),
             style,
         )
-    # print("XXX PolygonBox", svg)
+    print("XXX PolygonBox", svg)
     return svg
 
 
@@ -331,14 +327,15 @@ def rectanglebox(self, **options):
         x1, x2 = x1 + offset[0], x2 + offset[0]
         y1, y2 = y1 + offset[1], y2 + offset[1]
     style = create_css(self.edge_color, self.face_color, line_width)
-    return '<rect x="%f" y="%f" width="%f" height="%f" style="%s" />' % (
+    svg =  '<rect x="%f" y="%f" width="%f" height="%f" style="%s" />' % (
         xmin,
         ymin,
         w,
         h,
         style,
     )
-    "\n".join(element.to_svg() for element in self.elements)
+    # print("RectangleBox", svg)
+    return svg
 
 
 add_conversion_fn(RectangleBox)
@@ -351,13 +348,15 @@ def _roundbox(self, **options):
     ry = y - ry
     line_width = self.style.get_line_width(face_element=self.face_element)
     style = create_css(self.edge_color, self.face_color, stroke_width=line_width)
-    return '<ellipse cx="%f" cy="%f" rx="%f" ry="%f" style="%s" />' % (
+    svg = '<ellipse cx="%f" cy="%f" rx="%f" ry="%f" style="%s" />' % (
         x,
         y,
         rx,
         ry,
         style,
     )
+    # print("_RoundBox", svg)
+    return svg
 
 
 add_conversion_fn(_RoundBox)

test/test_formatter/test_svg.py

@@ -76,7 +76,7 @@ def test_svg_point():
     # Circles are implemented as ellipses with equal major and minor axes.
     # Check for that.
     print(inner_svg)
-    matches = re.match(r'^<circle cx="(\S+)" cy="(\S+)" r="(\S+)" .*/>', inner_svg)
+    matches = re.match(r'^<circle cx="(\S+)" cy="(\S+)"', inner_svg)
     assert matches
     assert matches.group(1) == matches.group(2)