Graphics overhault rebase1

mathics/builtin/drawing/graphics3d.py

@@ -764,8 +764,6 @@ def total_extent_3d(extents):
 
 
 class Graphics3DElements(_GraphicsElements):
-    coords = Coords3D
-
     def __init__(self, content, evaluation, neg_y=False):
         super(Graphics3DElements, self).__init__(content, evaluation)
         self.neg_y = neg_y
@@ -774,6 +772,10 @@ def __init__(self, content, evaluation, neg_y=False):
         ) = (
             self.pixel_width
         ) = self.pixel_height = self.extent_width = self.extent_height = None
+        self.local_to_screen = None
+
+    def make_coords(self, points):
+        return [Coords3D(self, p) for p in points]
 
     def extent(self, completely_visible_only=False):
         return total_extent_3d([element.extent() for element in self.elements])
@@ -835,7 +837,11 @@ def to_asy(self):
 
         return "".join(
             "path3 g={0}--cycle;dot(g, {1});".format(
-                "--".join("(%.5g,%.5g,%.5g)" % coords.pos()[0] for coords in line), pen
+                "--".join(
+                    "(%.5g,%.5g,%.5g)" % tuple(float(x) for x in coords.pos()[0])
+                    for coords in line
+                ),
+                pen,
             )
             for line in self.lines
         )

mathics/builtin/drawing/image.py

@@ -25,6 +25,7 @@
     convert as convert_color,
     colorspaces as known_colorspaces,
 )
+from mathics.layout.client import WebEngineError
 
 import base64
 import functools
@@ -2561,3 +2562,48 @@ def color_func(
 
         image = wc.to_image()
         return Image(numpy.array(image), "RGB")
+
+
+class Rasterize(Builtin):
+    requires = _image_requires
+
+    options = {
+        "RasterSize": "300",
+    }
+
+    def apply(self, expr, evaluation, options):
+        "Rasterize[expr_, OptionsPattern[%(name)s]]"
+
+        raster_size = self.get_option(options, "RasterSize", evaluation)
+        if isinstance(raster_size, Integer):
+            s = raster_size.get_int_value()
+            py_raster_size = (s, s)
+        elif raster_size.has_form("List", 2) and all(
+            isinstance(s, Integer) for s in raster_size.leaves
+        ):
+            py_raster_size = tuple(s.get_int_value for s in raster_size.leaves)
+        else:
+            return
+
+        mathml = evaluation.format_output(expr, "xml")
+        try:
+            svg = evaluation.output.mathml_to_svg(mathml)
+            png = evaluation.output.rasterize(svg, py_raster_size)
+
+            stream = BytesIO()
+            stream.write(png)
+            stream.seek(0)
+            im = PIL.Image.open(stream)
+            # note that we need to get these pixels as long as stream is still open,
+            # otherwise PIL will generate an IO error.
+            pixels = numpy.array(im)
+            stream.close()
+
+            return Image(pixels, "RGB")
+        except WebEngineError as e:
+            evaluation.message(
+                "General",
+                "nowebeng",
+                "Rasterize[] did not succeed: " + str(e),
+                once=True,
+            )

mathics/builtin/drawing/plot.py

@@ -40,6 +40,7 @@
 except ImportError:
     has_compile = False
 
+
 def gradient_palette(color_function, n, evaluation):  # always returns RGB values
     if isinstance(color_function, String):
         color_data = Expression("ColorData", color_function).evaluate(evaluation)
@@ -696,6 +697,15 @@ def find_excl(excl):
                     Expression("Point", Expression(SymbolList, *meshpoints))
                 )
 
+        # We need the PrecomputeTransformations option here. To understand why, try Plot[1+x*0.000001, {x, 0, 1}]
+        # without it. in Graphics[], we set up a transformation that scales a very tiny area to a very large area.
+        # unfortunately, most browsers seem to have problems with scaling stroke width properly. since we scale a
+        # very tiny area, we specify a very small stroke width (e.g. 1e-6) which is then scaled. but most browsers
+        # simply round this stroke width to 0 before scaling, so we end up with an empty plot. in order to fix this,
+        # Transformation -> Precomputed simply gets rid of the SVG transformations and passes the scaled coordinates
+        # into the SVG. this also has the advantage that we can precompute with arbitrary precision using mpmath.
+        options["System`Transformation"] = String("Precomputed")
+
         return Expression(
             "Graphics", Expression(SymbolList, *graphics), *options_to_rules(options)
         )