Plot structure tests (#1514)

This is the first of a series of PRs aiming to improve plotting
performance for Plot3D (initially):

* This PR improves Plot3D testing to look at the structure of the
resulting Graphics3D expression, improving confidence that nothing is
broken by subsequent refactoring.
* Refactor eval_Plot3D to separate the option processing stuff from the
generation of the Graphics3D output in preparation for the subsequent
step. This should cause no functional change, and the improved testing
introduced by the previous PR will increase confidence that that is the
case.
* Introduce optional (for now) generation of Graphics3D output using
GraphicsComplex and NumericArray in Plot3D. This should provide greatly
improved plotting performance for consumers who enable the option and
are prepared to consume GraphicsComplex.
* Subsequent PRs may extend this to other types of plots, update
internal (core) consumers of Graphics3D to understand GraphicsComplex,
etc.

Author: bdlucas1

mathics/core/util.py

@@ -9,6 +9,8 @@
 from platform import python_implementation
 from typing import Optional
 
+from mathics.core.symbols import Symbol
+
 IS_PYPY = python_implementation() == "PyPy"
 
 
@@ -113,3 +115,29 @@ def subranges(
                 items[start : start + length],
                 (items[:start], items[start + length :]),
             )
+
+
+def print_expression_tree(expr, indent="", marker=lambda expr: ""):
+    """
+    Print a Mathics Expression as an indented tree.
+    Caller may supply a marker function that computes a marker
+    to be displayed in the tree for the given node.
+    """
+    if isinstance(expr, Symbol):
+        print(f"{indent}{marker(expr)}{expr}")
+    elif not hasattr(expr, "elements"):
+        print(f"{indent}{marker(expr)}{expr.get_head()} {expr}")
+    else:
+        print(f"{indent}{marker(expr)}{expr.head}")
+        for elt in expr.elements:
+            print_expression_tree(elt, indent + "  ", marker=marker)
+
+
+def print_sympy_tree(expr, indent=""):
+    """Print a SymPy Expression as an indented tree"""
+    if expr.args:
+        print(f"{indent}{expr.func.__name__}")
+        for i, arg in enumerate(expr.args):
+            print_sympy_tree(arg, indent + "    ")
+    else:
+        print(f"{indent}{expr.func.__name__}({str(expr)})")

test/builtin/drawing/test_plot.py

@@ -3,10 +3,12 @@
 Unit tests from mathics.builtin.drawing.plot
 """
 
-from test.helper import check_evaluation
+from test.helper import check_evaluation, session
 
 import pytest
 
+from mathics.core.util import print_expression_tree
+
 
 def test__listplot():
     """tests for module builtin.drawing.plot._ListPlot"""
@@ -201,3 +203,125 @@ def test_plot(str_expr, msgs, str_expected, fail_msg):
         failure_message=fail_msg,
         expected_messages=msgs,
     )
+
+
+#
+# Call plotting functions and examine the structure of the output
+# In case of error trees are printed with an embedded >>> marker showing location of error
+#
+
+
+def print_expression_tree_with_marker(expr):
+    print_expression_tree(expr, marker=lambda expr: getattr(expr, "_marker", ""))
+
+
+def check_structure(result, expected):
+    """Check that expected is a prefix of result at every node"""
+
+    def error(msg):
+        result._marker = "RESULT >>> "
+        expected._marker = "EXPECTED >>> "
+        raise AssertionError(msg)
+
+    # do the heads match?
+    if result.get_head() != expected.get_head():
+        error("heads don't match")
+
+    # does the structure match?
+    if hasattr(expected, "elements"):
+        if not hasattr(result, "elements"):
+            error("expected elements but result has none")
+        for i, e in enumerate(expected.elements):
+            if len(result.elements) <= i:
+                error("result has too few elements")
+            check_structure(result.elements[i], e)
+    else:
+        if str(result) != str(expected):
+            error("leaves don't match")
+
+
+def eval_and_check_structure(str_expr, str_expected):
+    expr = session.parse(str_expr)
+    result = expr.evaluate(session.evaluation)
+    expected = session.parse(str_expected)
+    try:
+        check_structure(result, expected)
+    except AssertionError as oops:
+        print(f"\nERROR: {oops} (error is marked with >>> below)")
+        print("=== result:")
+        print_expression_tree_with_marker(result)
+        print("=== expected:")
+        print_expression_tree_with_marker(expected)
+        raise
+
+
+def test_plot3d_default():
+    eval_and_check_structure(
+        """
+        Plot3D[
+            x+y,
+            {x,0,1}, {y,0,1},
+            PlotPoints->{2,2},
+            MaxRecursion->0
+        ]
+        """,
+        """
+        Graphics3D[
+            {
+                Polygon[{{0.0,0.0,0.0}, {0.0,0.5,0.5}, {0.5,0.0,0.5}}],
+                Polygon[{{}}]
+            },
+            AspectRatio -> 1,
+            Axes -> True,
+            AxesStyle -> {},
+            Background -> Automatic,
+            BoxRatios -> {1, 1, 0.4},
+            ImageSize -> Automatic,
+            LabelStyle -> {},
+            PlotRange -> Automatic,
+            PlotRangePadding -> Automatic,
+            TicksStyle -> {}
+        ]
+        """,
+    )
+
+
+def test_plot3d_nondefault():
+    eval_and_check_structure(
+        """
+        Plot3D[
+            x+y,
+            {x,0,1}, {y,0,1},
+            PlotPoints->{2,2},
+            MaxRecursion->0
+            AspectRatio -> 0.5,
+            Axes -> False,
+            AxesStyle -> {Red,Blue},
+            Background -> Green,
+            BoxRatios -> {10, 10, 1},
+            ImageSize -> {200,200},
+            LabelStyle -> Red,
+            PlotRange -> {0,1},
+            PlotRangePadding -> {1,2},
+            TicksStyle -> {Purple,White}
+        ]
+        """,
+        """
+        Graphics3D[
+            {
+                Polygon[{{0.0,0.0,0.0}, {0.0,0.5,0.5}, {0.5,0.0,0.5}}],
+                Polygon[{{}}]
+            },
+            AspectRatio -> 1, (* TODO: is not passed through apparently - or is my misunderstanding? *)
+            Axes -> False,
+            AxesStyle -> {RGBColor[1,0,0],RGBColor[0,0,1]},
+            Background -> RGBColor[0,1,0],
+            BoxRatios -> {10, 10, 1},
+            ImageSize -> {200,200},
+            LabelStyle -> RGBColor[1,0,0],
+            PlotRange -> {0,1},
+            PlotRangePadding -> {1,2},
+            TicksStyle -> {RGBColor[0.5,0,0.5],GrayLevel[1]}
+        ]
+        """,
+    )