114 lines
3.1 KiB
Python
114 lines
3.1 KiB
Python
# What needs to be taught?
|
|
# - return values
|
|
# - unpacking multiple return values
|
|
# - list comprehensions
|
|
# - named function arguments
|
|
# - after positional
|
|
# - like dictionaries
|
|
# -
|
|
# - modules
|
|
|
|
# Parameters:
|
|
# - the actual drawing will be
|
|
|
|
from turtle import *
|
|
from math import floor, ceil, log
|
|
import constants
|
|
from movement import flyto
|
|
from superturtle.movement import no_delay
|
|
from generate_data import generate_data
|
|
|
|
def draw_scatterplot(data, size=5, color="black"):
|
|
"Draws a scatter plot, showing the data"
|
|
prepare_screen()
|
|
draw_axes(data)
|
|
draw_points(data, color, size)
|
|
|
|
def prepare_screen():
|
|
"""Sets up the
|
|
"""
|
|
screensize(400, 400)
|
|
setworldcoordinates(-20, -20, 420, 420)
|
|
|
|
def draw_axes(data):
|
|
"""Draws the scatter plot's axes.
|
|
"""
|
|
flyto(0, 0)
|
|
goto(0, constants.PLOT_HEIGHT)
|
|
flyto(0, 0)
|
|
goto(constants.PLOT_WIDTH, 0)
|
|
|
|
y_values = get_y_values(data)
|
|
ymin, ymax = get_bounds(y_values)
|
|
draw_y_tick(0, ymin)
|
|
draw_y_tick(constants.PLOT_HEIGHT, ymax)
|
|
for tick in get_tick_range(y_values):
|
|
position = scale(tick, ymin, ymax, 0, constants.PLOT_HEIGHT)
|
|
draw_y_tick(position, tick)
|
|
|
|
x_values = get_x_values(data)
|
|
xmin, xmax = get_bounds(x_values)
|
|
draw_x_tick(0, xmin)
|
|
draw_x_tick(constants.PLOT_WIDTH, xmax)
|
|
for tick in get_tick_range(x_values):
|
|
position = scale(tick, xmin, xmax, 0, constants.PLOT_WIDTH)
|
|
draw_x_tick(position, tick)
|
|
|
|
def get_tick_range(values):
|
|
"Returns a range of positions for ticks"
|
|
vmin, vmax = get_bounds(values)
|
|
tick_interval = get_tick_interval(values)
|
|
first_tick = ceil(vmin / tick_interval) * tick_interval
|
|
print(tick_interval)
|
|
print(first_tick)
|
|
print(vmax)
|
|
return range(first_tick, vmax, tick_interval)
|
|
|
|
def get_tick_interval(values):
|
|
""
|
|
vmin, vmax = get_bounds(values)
|
|
log_span = log(vmax - vmin, 10)
|
|
return 10 ** floor(log_span)
|
|
|
|
def draw_points(data, color, size):
|
|
xmin, xmax = get_bounds(get_x_values(data))
|
|
ymin, ymax = get_bounds(get_y_values(data))
|
|
for x, y in data:
|
|
sx = scale(x, xmin, xmax, 0, constants.PLOT_WIDTH)
|
|
sy = scale(y, ymin, ymax, 0, constants.PLOT_HEIGHT)
|
|
draw_point(sx, sy, color, size)
|
|
|
|
def draw_point(x, y, color, size):
|
|
flyto(x, y)
|
|
dot(size, color)
|
|
|
|
def get_bounds(data):
|
|
return min(data), max(data)
|
|
|
|
def get_x_values(data):
|
|
return [x for x, y, in data]
|
|
|
|
def get_y_values(data):
|
|
return [y for x, y in data]
|
|
|
|
def draw_y_tick(position, label):
|
|
flyto(0, position)
|
|
goto(-constants.TICK_LENGTH, position)
|
|
write(label, align='right')
|
|
|
|
def draw_x_tick(position, label):
|
|
flyto(position, 0)
|
|
goto(position, -constants.TICK_LENGTH)
|
|
flyto(position, -constants.TICK_LENGTH - 10)
|
|
write(label, align='center')
|
|
|
|
def scale(value, domain_min, domain_max, range_min, range_max):
|
|
ratio = (value - domain_min) / (domain_max - domain_min)
|
|
return range_min + ratio * (range_max - range_min)
|
|
|
|
with no_delay():
|
|
data = generate_data(50, 10, 500, 5, 400, 1000)
|
|
draw_scatterplot(data, size=5, color="blue")
|
|
hideturtle()
|
|
input()
|