from pytamaro import (
    Color, Graphic,
    black, white, red, green, blue, rgb_color, hsv_color, hsl_color, transparent,
    graphic_width,
    ellipse, rectangle, empty_graphic,
    rotate, compose, pin, 
    top_left, top_center, top_right,
    center_left, center, center_right,
    bottom_left, bottom_center, bottom_right,
    show_graphic, show_animation
)
from typing import Callable
from collections.abc import Iterable
from math import sin, cos, tan, radians, degrees, pi, sqrt, isnan


# internal functions
def _place(origin_pin, area_dot_pin, area, dot):
    placed = compose(
        pin(area_dot_pin, dot),
        pin(area_dot_pin, area)
    )
    return pin(origin_pin, placed)

def _cartesian_dot(dot_diameter: float, dot_color: Color, x: float, y: float) -> Graphic:
    dot = ellipse(dot_diameter, dot_diameter, dot_color)
    dot_radius = dot_diameter / 2
    strut_width = abs(x) + dot_radius
    strut_height = abs(y) + dot_radius
    straddles_x0 = abs(x) < dot_radius
    straddles_y0 = abs(y) < dot_radius
    area_width = strut_width * (2 if straddles_x0 else 1)
    area_height = strut_height * (2 if straddles_y0 else 1)
    area = rectangle(area_width, area_height, transparent)
    if x >= 0 and y >= 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = bottom_center
        elif straddles_y0:
            origin_pin = center_left
        else:
            origin_pin = bottom_left
        return _place(origin_pin, top_right, area, dot)
    elif x < 0 and y >= 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = bottom_center
        elif straddles_y0:
            origin_pin = center_right
        else:
            origin_pin = bottom_right
        return _place(origin_pin, top_left, area, dot)
    elif x < 0 and y < 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = top_center
        elif straddles_y0:
            origin_pin = center_right
        else:
            origin_pin = top_right
        return _place(origin_pin, bottom_left, area, dot)
    else: # x >= 0 and y < 0:
        if straddles_x0 and straddles_y0:
            origin_pin = center
        elif straddles_x0:
            origin_pin = top_center
        elif straddles_y0:
            origin_pin = center_left
        else:
            origin_pin = top_left
        return _place(origin_pin, bottom_right, area, dot)


# export:
def compose_multiple(graphics: list[Graphic]) -> Graphic:
    result = empty_graphic()
    for graphic in graphics:
        result = compose(result, graphic)
    return result

def float_range(start: float, stop: float, step: float) -> Iterable[float]:
    value = start
    while value < stop:
        yield value
        value += step


def parametric_color_thickness_plot(
    p_to_x: Callable[[float],float], 
    p_to_y: Callable[[float],float], 
    ps: Iterable[float],
    p_to_color: Callable[[float],Color] = lambda p: black, 
    p_to_thickness: Callable[[float],float] = lambda p: 10, 
    scale: float = 1.0,
) -> Graphic:
    """
    Create a parametric plot,
    where x and y are defined as functions of p,
    and ps defines the values of p for which to plot a point.
    Optionally specify the dot color as a function of p (default: black)
    and the dot diameter as a function of p (default: 10).
    """
    x_min = 0
    x_max = 0
    y_min = 0
    y_max = 0
    thickness_max = 0
    dots = empty_graphic()
    for p in ps:
        x = p_to_x(p) * scale
        y = p_to_y(p) * scale
        #print(f"{x=} {y=}")
        color = p_to_color(p)
        thickness = p_to_thickness(p) * scale
        if isnan(x) or isnan(y) or isnan(thickness):
            continue
        thickness_max = max(thickness_max, thickness)
        x_max = max(x_max, x)
        x_min = min(x_min, x)
        y_max = max(y_max, y)
        y_min = min(y_min, y)
        dot = _cartesian_dot(thickness, color, x, y)
        dots = compose(dot, dots)
    # print(f"{x_min=}")
    # print(f"{x_max=}")
    # print(f"{y_min=}")
    # print(f"{y_max=}")
    x_max += thickness_max
    x_min -= thickness_max
    y_max += thickness_max
    y_min -= thickness_max
    # X/Y Axes
    grey = rgb_color(200, 200, 200)
    x_axis_neg = pin(center_right, rectangle(-x_min, 1, grey))
    x_axis_pos = pin(center_left, rectangle(x_max, 1, grey))
    y_axis_neg = pin(top_center, rectangle(1, -y_min, grey))
    y_axis_pos = pin(bottom_center, rectangle(1, y_max, grey))
    grid = compose_multiple([
        x_axis_neg,
        x_axis_pos,
        y_axis_neg,
        y_axis_pos,
    ])
    # Background
    q1 = pin(bottom_left, rectangle(x_max, y_max, white))
    q2 = pin(bottom_right, rectangle(-x_min, y_max, white))
    q3 = pin(top_right, rectangle(-x_min, -y_min, white))
    q4 = pin(top_left, rectangle(x_max, -y_min, white))
    bg = compose_multiple([q1, q2, q3, q4])
    result = compose_multiple([
        dots,
        grid,
        bg
    ])
    return result

def parametric_plot(
    p_to_x: Callable[[float],float], 
    p_to_y: Callable[[float],float], 
    ps: Iterable[float],
    dot_color: Color = black,
    dot_width: float = 10,
    scale: float = 1.0,
) -> Graphic:
    """
    Create a plot where x and y are defined as functions of p, 
    and ps defines the values of p for which to plot a point.
    Optionally specify the color (default: black) and diameter (default: 10) of the dots.
    """
    return parametric_color_thickness_plot(
        p_to_x, 
        p_to_y, 
        ps,
        lambda p: dot_color,
        lambda p: dot_width,
        scale
    )

def cartesian_plot(
    x_to_y: Callable[[float],float], 
    xs: Iterable[float], 
    dot_color: Color = black,
    dot_width: float = 10,
    scale: float = 1.0,
) -> Graphic:
    """
    Create a Cartesian plot where y is defined as function of x, 
    and xs defines the values of x for which to plot a point.
    Optionally specify the color (default: black) and diameter (default: 10) of the dots.
    """
    return parametric_color_thickness_plot(
        lambda p: p,
        lambda p: x_to_y(p),
        xs,
        lambda p: dot_color,
        lambda p: dot_width,
        scale
    )

def polar_plot(
    angle_rad_to_radius: Callable[[float],float], 
    angles_rad: Iterable[float], 
    dot_color: Color = black,
    dot_width: float = 10,
    scale: float = 1.0,
) -> Graphic:
    """
    Create a polar plot where the radius is defined as function of the angle (in radians), 
    and angles defines the values of angles (in radians) for which to plot a point.
    Optionally specify the color (default: black) and diameter (default: 10) of the dots.
    """
    def angle_rad_to_x(a):
        r = angle_rad_to_radius(a)
        return cos(a) * r
    def angle_rad_to_y(a):
        r = angle_rad_to_radius(a)
        return sin(a) * r
    return parametric_color_thickness_plot(
        lambda a: angle_rad_to_x(a),
        lambda a: angle_rad_to_y(a),
        angles_rad,
        lambda a: dot_color,
        lambda a: dot_width,
        scale
    )

parametric-plot

Author & License

Concepts

Languages

Uses