load symbols and tests

mmatera · mmatera · commit 8ea2c48e936c · 2026-03-10T08:24:59.000-03:00
diff --git a/Makefile b/Makefile
@@ -9,6 +9,8 @@ PYTHON ?= python3
 PIP ?= pip3
 RM  ?= rm
 LANG = en
+PYTEST_OPTIONS ?=
+
 
 .PHONY: all build \
    check clean \
@@ -52,7 +54,7 @@ doctest:
 	MATHICS_CHARACTER_ENCODING="ASCII" $(PYTHON) -m mathics.docpipeline -l pymathics.vectorizedplot -c 'Mathics3 vectorizedplot Module' $o
 #: Run py.test tests. Use environment variable "o" for pytest options
 pytest:
-	MATHICS_CHARACTER_ENCODING="ASCII" py.test test $o
+	MATHICS_CHARACTER_ENCODING="ASCII" py.test test $(PYTEST_OPTIONS)
 
 
 
diff --git a/pymathics/vectorizedplot/__init__.py b/pymathics/vectorizedplot/__init__.py
@@ -23,12 +23,16 @@
 """
 
 
-# from pymathics.vectorizedplot.plot_plot3d.py import SphericalPlot3D
+from pymathics.vectorizedplot.plot_plot3d import ContourPlot3D, ParametricPlot3D, SphericalPlot3D
 from pymathics.vectorizedplot.version import __version__
 
-__all__ = ("__version__",
-           #"SphericalPlot3D",
-           "pymathics_version_data")
+__all__ = (
+    "ContourPlot3D",
+    "ParametricPlot3D",
+    "SphericalPlot3D",
+    "__version__",
+    "pymathics_version_data"
+)
 
 # To be recognized as an external mathics module, the following variable
 # is required:
diff --git a/pymathics/vectorizedplot/eval/colors.py b/pymathics/vectorizedplot/eval/colors.py
@@ -0,0 +1,191 @@
+"""
+Color functions
+
+"""
+
+from typing import Optional
+
+import palettable
+
+from mathics.core.atoms import Integer0, Integer1, MachineReal, String
+from mathics.core.convert.expression import to_expression
+from mathics.core.element import BaseElement
+from mathics.core.evaluation import Evaluation
+from mathics.core.expression import Expression
+from mathics.core.list import ListExpression
+from mathics.core.symbols import Symbol
+from mathics.core.systemsymbols import (
+    SymbolBlend,
+    SymbolColorData,
+    SymbolFunction,
+    SymbolMap,
+    SymbolRGBColor,
+    SymbolSlot,
+)
+
+SymbolColorDataFunction = Symbol("ColorDataFunction")
+
+
+class _GradientColorScheme:
+    def colors(self) -> list:
+        """return the list of colors"""
+        raise NotImplementedError
+
+    def color_data_function(self, name: str) -> Expression:
+        """Return a function that compute the colors"""
+        colors = ListExpression(
+            *[
+                to_expression(
+                    SymbolRGBColor, *color, elements_conversion_fn=MachineReal
+                )
+                for color in self.colors()
+            ]
+        )
+        blend = Expression(
+            SymbolFunction,
+            Expression(SymbolBlend, colors, Expression(SymbolSlot, Integer1)),
+        )
+        arguments = [
+            String(name),
+            String("Gradients"),
+            ListExpression(Integer0, Integer1),
+            blend,
+        ]
+        return Expression(SymbolColorDataFunction, *arguments)
+
+
+class _PalettableGradient(_GradientColorScheme):
+    def __init__(self, palette, is_reversed: bool):
+        self.palette = palette
+        self.reversed = is_reversed
+
+    def colors(self) -> list:
+        colors = self.palette.mpl_colors
+        if self.reversed:
+            colors = list(reversed(colors))
+        return colors
+
+
+class _PredefinedGradient(_GradientColorScheme):
+    _colors: list
+
+    def __init__(self, colors: list):
+        self._colors = colors
+
+    def colors(self) -> list:
+        return self._colors
+
+
+COLOR_PALETTES = {
+    "LakeColors": _PredefinedGradient(
+        [
+            (0.293416, 0.0574044, 0.529412),
+            (0.563821, 0.527565, 0.909499),
+            (0.762631, 0.846998, 0.914031),
+            (0.941176, 0.906538, 0.834043),
+        ]
+    ),
+    "Pastel": _PalettableGradient(palettable.colorbrewer.qualitative.Pastel1_9, False),
+    "Rainbow": _PalettableGradient(palettable.colorbrewer.diverging.Spectral_9, True),
+    "RedBlueTones": _PalettableGradient(
+        palettable.colorbrewer.diverging.RdBu_11, False
+    ),
+    "GreenPinkTones": _PalettableGradient(
+        palettable.colorbrewer.diverging.PiYG_9, False
+    ),
+    "GrayTones": _PalettableGradient(palettable.colorbrewer.sequential.Greys_9, False),
+    "SolarColors": _PalettableGradient(palettable.colorbrewer.sequential.OrRd_9, True),
+    "CherryTones": _PalettableGradient(palettable.colorbrewer.sequential.Reds_9, True),
+    "FuchsiaTones": _PalettableGradient(palettable.colorbrewer.sequential.RdPu_9, True),
+    "SiennaTones": _PalettableGradient(
+        palettable.colorbrewer.sequential.Oranges_9, True
+    ),
+    # specific to Mathics
+    "Paired": _PalettableGradient(palettable.colorbrewer.qualitative.Paired_9, False),
+    "Accent": _PalettableGradient(palettable.colorbrewer.qualitative.Accent_8, False),
+    "Aquatic": _PalettableGradient(palettable.wesanderson.Aquatic1_5, False),
+    "Zissou": _PalettableGradient(palettable.wesanderson.Zissou_5, False),
+    "Tableau": _PalettableGradient(palettable.tableau.Tableau_20, False),
+    "TrafficLight": _PalettableGradient(palettable.tableau.TrafficLight_9, False),
+    "Moonrise1": _PalettableGradient(palettable.wesanderson.Moonrise1_5, False),
+}
+
+
+def get_color_palette(name, evaluation):
+    palette = COLOR_PALETTES.get(name, None)
+    if palette is None:
+        evaluation.message("ColorData", "notent", name)
+        return None
+    return palette.colors()
+
+
+def gradient_palette(
+    color_function: BaseElement, n: int, evaluation: Evaluation
+) -> Optional[list]:  # always returns RGB values
+    """Return a list of rgb color components"""
+    if isinstance(color_function, String):
+        color_data = Expression(SymbolColorData, color_function).evaluate(evaluation)
+        if not color_data.has_form("ColorDataFunction", 4):
+            return None
+        _, kind, interval, blend = color_data.elements
+        if not isinstance(kind, String) or kind.get_string_value() != "Gradients":
+            return None
+        if not interval.has_form("List", 2):
+            return None
+        x0, x1 = (x.round_to_float() for x in interval.elements)
+    else:
+        blend = color_function
+        x0 = 0.0
+        x1 = 1.0
+
+    xd = x1 - x0
+    offsets = [MachineReal(x0 + float(xd * i) / float(n - 1)) for i in range(n)]
+    colors = Expression(SymbolMap, blend, ListExpression(*offsets)).evaluate(evaluation)
+    if len(colors.elements) != n:
+        return None
+
+    from mathics.builtin.colors.color_directives import ColorError, expression_to_color
+
+    try:
+        objects = [expression_to_color(x) for x in colors.elements]
+        if any(x is None for x in objects):
+            return None
+        return [x.to_rgba()[:3] for x in objects]
+    except ColorError:
+        return None
+
+
+# color-blind friendly palette from https://davidmathlogic.com/colorblind
+# palette3 is for 3d plots, i.e. surfaces
+palette3 = [
+    (255, 176, 0),  # orange
+    (100, 143, 255),  # blue
+    (220, 38, 127),  # red
+    (50, 150, 140),  # green
+    (120, 94, 240),  # purple
+    (254, 97, 0),  # dark orange
+    (0, 114, 178),  # dark blue
+]
+
+
+# palette 2 is for 2d plots, i.e. lines
+# same colors as palette3 but in a little different order
+palette2 = [
+    (100, 143, 255),  # blue
+    (255, 176, 0),  # orange
+    (50, 150, 140),  # green
+    (220, 38, 127),  # red
+    (120, 94, 240),  # purple
+    (254, 97, 0),  # dark orange
+    (0, 114, 178),  # dark blue
+]
+
+
+def palette_color_directive(palette, i, opacity=None):
+    """returns a directive in a form suitable for GraphicsGenerator.add_directives"""
+    """ for setting the color of an entire entity such as a line or surface """
+    rgb = palette[i % len(palette)]
+    rgb = [c / 255.0 for c in rgb]
+    if opacity is not None:
+        rgb.append(opacity)
+    return [SymbolRGBColor, *rgb]
diff --git a/pymathics/vectorizedplot/eval/plot3d_vectorized.py b/pymathics/vectorizedplot/eval/plot3d_vectorized.py
@@ -10,9 +10,10 @@
 from mathics.builtin.colors.color_internals import convert_color
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
-from mathics.core.symbols import strip_context
+from mathics.core.symbols import strip_context, Symbol
 from mathics.core.systemsymbols import (
-    SymbolAbsoluteThickness,
+    # TODO: uncomment me after adding this symbol to mathics.core.systemsymbols
+    #    SymbolAbsoluteThickness,
     SymbolEqual,
     SymbolFull,
     SymbolNone,
@@ -25,6 +26,10 @@
 from .util import GraphicsGenerator, compile_exprs
 
 
+# TODO: remove me after adding this symbol to mathics.core.systemsymbols
+SymbolAbsoluteThickness= Symbol("System`AbsoluteThickness")
+
+
 def make_surfaces(
     plot_options, evaluation: Evaluation, dim: int, is_complex: bool, emit
 ):
diff --git a/pymathics/vectorizedplot/eval/util.py b/pymathics/vectorizedplot/eval/util.py
@@ -0,0 +1,114 @@
+"""
+Common utilities for plotting
+"""
+
+from typing import Sequence
+
+from mathics.core.atoms import NumericArray
+from mathics.core.convert.expression import to_expression, to_mathics_list
+from mathics.core.convert.lambdify import lambdify_compile
+from mathics.core.evaluation import Evaluation
+from mathics.core.expression import Expression
+from mathics.core.list import ListExpression
+from mathics.core.symbols import Symbol
+from mathics.core.systemsymbols import (
+    SymbolGraphics,
+    SymbolGraphics3D,
+    SymbolGraphicsComplex,
+    SymbolLine,
+    SymbolPolygon,
+    SymbolRGBColor,
+    SymbolRule,
+    SymbolVertexColors,
+)
+
+
+class GraphicsGenerator:
+    """
+    Support for generating Graphics and Graphics3D expressions
+    """
+
+    # TODO: more precise typing?
+    graphics: list
+
+    # 2 or 3
+    dim: int
+
+    def __init__(self, dim: int):
+        self.dim = dim
+        self.graphics = []
+
+    # add polygons and lines, optionally with vertex colors
+    def add_thing(self, thing_symbol, things, colors):
+        arg = tuple(to_mathics_list(*thing) for thing in things)
+        arg = ListExpression(*arg) if len(arg) > 1 else arg[0]
+        if colors:
+            color_arg = tuple(to_mathics_list(*color) for color in colors)
+            color_arg = (
+                ListExpression(*color_arg) if len(color_arg) > 1 else color_arg[0]
+            )
+            color_rule = Expression(SymbolRule, SymbolVertexColors, color_arg)
+            self.graphics.append(Expression(thing_symbol, arg, color_rule))
+        else:
+            self.graphics.append(Expression(thing_symbol, arg))
+
+    def add_polyxyzs(self, poly_xyzs, colors=None):
+        """Add polygons specified by explicit xy[z] coordinates"""
+        self.add_thing(SymbolPolygon, poly_xyzs, colors)
+
+    def add_linexyzs(self, line_xyzs, colors=None):
+        """Add lines specified by explicit xy[z] coordinates"""
+        self.add_thing(SymbolLine, line_xyzs, colors)
+
+    def add_color(self, symbol, components):
+        expr = to_expression(symbol, *components)
+        self.graphics.append(expr)
+
+    def add_directives(self, *ds):
+        def cvt(d):
+            if isinstance(d, list) and len(d) > 0 and isinstance(d[0], Symbol):
+                expr = to_expression(d[0], *(cvt(dd) for dd in d[1:]))
+                return expr
+            else:
+                return d
+
+        for d in ds:
+            expr = cvt(d)
+            self.graphics.append(expr)
+
+    def add_complex(self, xyzs, lines=None, polys=None, colors=None):
+        complex = [NumericArray(xyzs)]
+        if polys is not None:
+            polys_expr = Expression(SymbolPolygon, NumericArray(polys))
+            complex.append(polys_expr)
+        if lines is not None:
+            lines_expr = Expression(SymbolLine, NumericArray(lines))
+            complex.append(lines_expr)
+        if colors is not None:
+            colors_expr = Expression(SymbolRGBColor, NumericArray(colors))
+            rule_expr = Expression(SymbolRule, SymbolVertexColors, colors_expr)
+            complex.append(rule_expr)
+        gc_expr = Expression(SymbolGraphicsComplex, *complex)
+        self.graphics.append(gc_expr)
+
+    def generate(self, options):
+        """
+        Generates Graphics[3D] expression from supplied lines, polygons (etc.)
+        """
+        graphics_expr = Expression(
+            SymbolGraphics3D if self.dim == 3 else SymbolGraphics,
+            ListExpression(*self.graphics),
+            *options,
+        )
+
+        return graphics_expr
+
+
+def compile_exprs(
+    evaluation: Evaluation, expr_or_list: Expression | Sequence, names: Sequence[str]
+):
+    """Traverse a nested list structure and compile the functions at the leaves"""
+    if isinstance(expr_or_list, (list, tuple)):
+        return [compile_exprs(evaluation, e, names) for e in expr_or_list]
+    else:
+        return lambdify_compile(evaluation, expr_or_list, names)
diff --git a/pymathics/vectorizedplot/plot.py b/pymathics/vectorizedplot/plot.py
@@ -33,7 +33,8 @@
     SymbolStyle,
 )
 from mathics.eval.drawing.colors import COLOR_PALETTES, get_color_palette
-from pymathics.vectorizedplot.eval.drawing.plot import get_plot_range
+from pymathics.vectorizedplot.eval.plot import get_plot_range
+import pymathics.vectorizedplot.eval.plot3d_vectorized as plot_module
 from mathics.eval.nevaluator import eval_N
 
 # The vectorized plot function generates GraphicsComplex using NumericArray,
@@ -51,7 +52,6 @@
 # depending on whether vectorized plot functions are enabled
 def get_plot_eval_function(cls):
     function_name = "eval_" + cls.__name__
-    plot_module = pymathics.vectorizedplot.eval.drawing.plot3d_vectorized
     fun = getattr(plot_module, function_name)
     return fun
 
diff --git a/pymathics/vectorizedplot/plot_plot3d.py b/pymathics/vectorizedplot/plot_plot3d.py
diff --git a/test/test_plot_detail.py b/test/test_plot_detail.py
