def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
text for subtitle (str).
"""
if retrieve_query_parameter(request, "dot_counts"):
display_numbers_text = "with dot counts"
else:
display_numbers_text = "without dot counts"
if retrieve_query_parameter(request, "black_back"):
black_back_text = "with black back"
else:
black_back_text = "without black back"
text = "{} bits - {} - {} - {}".format(
retrieve_query_parameter(request, "number_bits"),
display_numbers_text,
black_back_text,
retrieve_query_parameter(request, "paper_size")
)
return text
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
text for subtitle (str).
"""
number_of_bits = retrieve_query_parameter(request, "number_bits")
value_type = retrieve_query_parameter(request, "value_type")
dot_counts = retrieve_query_parameter(request, "dot_counts")
if dot_counts:
count_text = "with dot counts"
else:
count_text = "without dot counts"
TEMPLATE = "{num_bits} bits - {value} - {counts}"
text = TEMPLATE.format(num_bits=number_of_bits,
value=value_type,
counts=count_text)
return text
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
text for subtitle (str).
"""
number_cards = retrieve_query_parameter(request, "number_cards")
max_number = retrieve_query_parameter(request, "max_number")
help_sheet = retrieve_query_parameter(request, "help_sheet")
paper_size = retrieve_query_parameter(request, "paper_size")
if max_number == "blank":
range_text = "blank"
elif max_number == "cards":
range_text = "0 to {}".format(number_cards)
else:
range_text = "0 to {}".format(max_number)
if help_sheet:
help_text = "with helper sheet"
else:
help_text = "without helper sheet"
return "{} cards - {} - {} - {}".format(number_cards, range_text,
help_text, paper_size)
def resource(request, resource):
"""Create a image for Binary Cards resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionary or list of dictionaries for each resource page.
"""
BASE_IMAGE_PATH = "static/img/resources/binary-cards/"
IMAGE_SIZE_X = 2480
IMAGE_SIZE_Y = 3508
IMAGE_DATA = [
("binary-cards-1-dot.png", 1),
("binary-cards-2-dots.png", 2),
("binary-cards-4-dots.png", 4),
("binary-cards-8-dots.png", 8),
("binary-cards-16-dots.png", 16),
("binary-cards-32-dots.png", 32),
("binary-cards-64-dots.png", 64),
("binary-cards-128-dots.png", 128),
]
# Retrieve parameters
parameter_options = valid_options()
display_numbers = retrieve_query_parameter(
request, "display_numbers", parameter_options["display_numbers"])
black_back = retrieve_query_parameter(request, "black_back",
parameter_options["black_back"])
if display_numbers:
font_path = "static/fonts/PatrickHand-Regular.ttf"
font = ImageFont.truetype(font_path, 600)
BASE_COORD_X = IMAGE_SIZE_X / 2
BASE_COORD_Y = IMAGE_SIZE_Y - 100
IMAGE_SIZE_Y = IMAGE_SIZE_Y + 300
pages = []
for (image_path, number) in IMAGE_DATA:
image = Image.open(os.path.join(BASE_IMAGE_PATH, image_path))
if display_numbers:
background = Image.new("RGB", (IMAGE_SIZE_X, IMAGE_SIZE_Y), "#FFF")
background.paste(image, mask=image)
draw = ImageDraw.Draw(background)
text = str(number)
text_width, text_height = draw.textsize(text, font=font)
coord_x = BASE_COORD_X - (text_width / 2)
coord_y = BASE_COORD_Y - (text_height / 2)
draw.text((coord_x, coord_y), text, font=font, fill="#000")
image = background
pages.append({"type": "image", "data": image})
if black_back:
black_card = Image.new("1", (IMAGE_SIZE_X, IMAGE_SIZE_Y))
pages.append({"type": "image", "data": black_card})
return pages
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (QueryDict).
resource: Object of resource data (Resource).
Returns:
Text for subtitle (str).
"""
return "{} tracks - {}".format(
retrieve_query_parameter(request, "tracks"),
retrieve_query_parameter(request, "paper_size"))
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
text for subtitle (str).
"""
return "{} - {}".format(
retrieve_query_parameter(request, "type").replace("_", " "),
retrieve_query_parameter(request, "paper_size"))
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (QueryDict).
resource: Object of resource data (Resource).
Returns:
Text for subtitle (str).
"""
barcode_length = retrieve_query_parameter(request, "barcode_length")
paper_size = retrieve_query_parameter(request, "paper_size")
return "{} digits - {}".format(barcode_length, paper_size)
def resource(request, resource):
"""Create a image for Parity Cards resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionaries for each resource page.
"""
CARDS_COLUMNS = 4
CARDS_ROWS = 5
CARD_SIZE = 500
IMAGE_SIZE_X = CARD_SIZE * CARDS_COLUMNS
IMAGE_SIZE_Y = CARD_SIZE * CARDS_ROWS
LINE_COLOUR = "#000000"
LINE_WIDTH = 3
front_page = Image.new("RGB", (IMAGE_SIZE_X, IMAGE_SIZE_Y), "#fff")
draw = ImageDraw.Draw(front_page)
for x_coord in range(0, IMAGE_SIZE_X, CARD_SIZE):
draw.line([(x_coord, 0), (x_coord, IMAGE_SIZE_Y)],
fill=LINE_COLOUR,
width=LINE_WIDTH)
draw.line([(IMAGE_SIZE_X - 1, 0), (IMAGE_SIZE_X - 1, IMAGE_SIZE_Y)],
fill=LINE_COLOUR,
width=LINE_WIDTH)
for y_coord in range(0, IMAGE_SIZE_Y, CARD_SIZE):
draw.line([(0, y_coord), (IMAGE_SIZE_X, y_coord)],
fill=LINE_COLOUR,
width=LINE_WIDTH)
draw.line([(0, IMAGE_SIZE_Y - 1), (IMAGE_SIZE_X, IMAGE_SIZE_Y - 1)],
fill=LINE_COLOUR,
width=LINE_WIDTH)
# Retrieve parameters
parameter_options = valid_options()
back_colour = retrieve_query_parameter(request, "back_colour",
parameter_options["back_colour"])
if back_colour == "black":
back_colour_hex = "#000000"
elif back_colour == "blue":
back_colour_hex = "#3366ff"
elif back_colour == "green":
back_colour_hex = "#279f2d"
elif back_colour == "purple":
back_colour_hex = "#6e3896"
else:
back_colour_hex = "#cc0423"
pages = [{
"type": "image",
"data": front_page
}, {
"type":
"image",
"data":
Image.new("RGB", (IMAGE_SIZE_X, IMAGE_SIZE_Y), back_colour_hex)
}]
return pages
def number_range(request):
"""Return number range tuple for resource.
Args:
request: HTTP request object (HttpRequest).
Returns:
Tuple of (range_min, range_max, font_size).
"""
parameter_options = valid_options()
prefilled_values = retrieve_query_parameter(
request, "prefilled_values", parameter_options["prefilled_values"])
range_min = 0
range_max = 0
font_size = 150
if prefilled_values == "easy":
range_min = 1
range_max = 10
elif prefilled_values == "medium":
range_min = 10
range_max = 100
font_size = 120
elif prefilled_values == "hard":
range_min = 100
range_max = 1000
font_size = 90
return (range_min, range_max, font_size)
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (Request).
resource: Object of resource data (Resource).
Returns:
text for subtitle (str)
"""
return "{} highlight - {}".format(
bool_to_yes_no(retrieve_query_parameter(request, "highlight")),
retrieve_query_parameter(request, "paper_size"))
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
Text for subtitle (str).
"""
text = "{} - {}".format(
retrieve_query_parameter(request, "worksheet_version"),
retrieve_query_parameter(request, "paper_size"))
return text
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
Text for subtitle (str).
"""
modulo_number = retrieve_query_parameter(request, "modulo_number")
if modulo_number == "1":
modulo_text = "blank"
else:
modulo_text = modulo_number
return "{} - {}".format(modulo_text,
retrieve_query_parameter(request, "paper_size"))
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
text for subtitle (str).
"""
prefilled_values = retrieve_query_parameter(request, "prefilled_values")
if prefilled_values == "blank":
range_text = "blank"
else:
SUBTITLE_TEMPLATE = "{} to {}"
range_min, range_max, font_size = number_range(request)
range_text = SUBTITLE_TEMPLATE.format(range_min, range_max - 1)
return "{} - {}".format(range_text,
retrieve_query_parameter(request, "paper_size"))
def resource(request, resource):
"""Create a image for Binary Windows resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionary or list of dictionaries for each resource page.
"""
BASE_IMAGE_PATH = "static/img/resources/binary-windows/"
FONT_PATH = "static/fonts/PatrickHand-Regular.ttf"
FONT = ImageFont.truetype(FONT_PATH, 300)
SMALL_FONT = ImageFont.truetype(FONT_PATH, 180)
# Retrieve parameters
parameter_options = valid_options()
number_of_bits = retrieve_query_parameter(request, "number_bits",
parameter_options["number_bits"])
value_type = retrieve_query_parameter(request, "value_type",
parameter_options["value_type"])
dot_counts = retrieve_query_parameter(request, "dot_counts",
parameter_options["dot_counts"])
pages = []
page_sets = [("binary-windows-1-to-8.png", 8)]
if number_of_bits == "8":
page_sets.append(("binary-windows-16-to-128.png", 128))
for (filename, dot_count_start) in page_sets:
image = Image.open(os.path.join(BASE_IMAGE_PATH, filename))
image = add_digit_values(image, value_type, True, 660, 724, 1700, FONT)
if dot_counts:
image = add_dot_counts(image, dot_count_start, SMALL_FONT)
image = image.rotate(90, expand=True)
pages.append({"type": "image", "data": image})
pages.append(back_page(BASE_IMAGE_PATH, FONT, value_type))
return pages
def subtitle(request, resource):
"""Return the subtitle string of the resource.
Used after the resource name in the filename, and
also on the resource image.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
text for subtitle (str)
"""
prefilled_values = retrieve_query_parameter(request, "prefilled_values")
art_style = retrieve_query_parameter(request, "art")
instructions = retrieve_query_parameter(request, "instructions")
paper_size = retrieve_query_parameter(request, "paper_size")
if prefilled_values == "blank":
range_text = "blank"
else:
SUBTITLE_TEMPLATE = "{} - {} to {}"
number_order_text = retrieve_query_parameter(request, "number_order").title()
range_min, range_max, font_size = number_range(request)
range_text = SUBTITLE_TEMPLATE.format(number_order_text, range_min, range_max - 1)
if art_style == "colour":
art_style_text = "full colour"
else:
art_style_text = "black and white"
if instructions:
instructions_text = "with instructions"
else:
instructions_text = "without instructions"
return "{} - {} - {} - {}".format(range_text, art_style_text, instructions_text, paper_size)
def resource(request, resource):
"""Create a image for Barcode Checksum Poster resource.
Args:
request: HTTP request object (QueryDict).
resource: Object of resource data (Resource).
Returns:
A dictionary for the resource page.
"""
# Retrieve parameters
parameter_options = valid_options()
barcode_length = retrieve_query_parameter(
request, "barcode_length", parameter_options["barcode_length"])
image_path = "static/img/resources/barcode-checksum-poster/{}-digits.png"
image = Image.open(image_path.format(barcode_length))
return {"type": "image", "data": image}
def resource(request, resource):
"""Create a image for Train Stations resource.
Args:
request: HTTP request object (QueryDict).
resource: Object of resource data (Resource).
Returns:
A dictionary for the resource page.
"""
image_path = "static/img/resources/train-stations/train-stations-tracks-{}.png"
parameter_options = valid_options()
track_type = retrieve_query_parameter(request, "tracks",
parameter_options["tracks"])
image = Image.open(image_path.format(track_type))
image = image.rotate(90, expand=True)
return {"type": "image", "data": image}
def resource(request, resource):
"""Create a image for Binary Cards resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionary for the resource page.
"""
image_path = "static/img/resources/modulo-clock/modulo-clock-{}.png"
parameter_options = valid_options()
modulo_number = int(
retrieve_query_parameter(request, "modulo_number",
parameter_options["modulo_number"]))
image = Image.open(image_path.format(modulo_number))
draw = ImageDraw.Draw(image)
font_size = 150
font_path = "static/fonts/PatrickHand-Regular.ttf"
font = ImageFont.truetype(font_path, font_size)
radius = 750
x_center = image.width / 2
y_center = image.height / 2
# Count from the '12 oclock position'
start_angle = pi * 1.5
angle_between_numbers = (2 * pi) / modulo_number
for number in range(0, modulo_number):
text = str(number)
angle = start_angle + (angle_between_numbers * number)
x_coord = radius * cos(angle) + x_center
y_coord = radius * sin(angle) + y_center
text_width, text_height = draw.textsize(text, font=font)
text_coord_x = x_coord - (text_width / 2)
text_coord_y = y_coord - (text_height / 2)
draw.text((text_coord_x, text_coord_y), text, font=font, fill="#000")
return {"type": "image", "data": image}
def resource(request, resource):
"""Create a image for Sorting Network resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionary for the resource page.
"""
image_path = "static/img/resources/resource-sorting-network-colour.png"
image = Image.open(image_path)
draw = ImageDraw.Draw(image)
(range_min, range_max, font_size) = number_range(request)
font_path = "static/fonts/PatrickHand-Regular.ttf"
# Add numbers to text if needed
parameter_options = valid_options()
prefilled_values = retrieve_query_parameter(
request, "prefilled_values", parameter_options["prefilled_values"])
if prefilled_values != "blank":
font = ImageFont.truetype(font_path, font_size)
numbers = sample(range(range_min, range_max), 6)
base_coord_x = 70
base_coord_y = 2560
coord_x_increment = 204
for number in numbers:
text = str(number)
text_width, text_height = draw.textsize(text, font=font)
coord_x = base_coord_x - (text_width / 2)
coord_y = base_coord_y - (text_height / 2)
draw.text((coord_x, coord_y), text, font=font, fill="#000")
base_coord_x += coord_x_increment
return {"type": "image", "data": image}
def resource(request, resource):
"""Create a copy of the Searching Cards resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A list of dictionaries for each resource page.
"""
pages = []
IMAGE_PATH = "static/img/resources/searching-cards/{}-cards-{}.png"
X_BASE_COORD = 1803
X_COORD_DECREMENT = 516
Y_COORD = 240
FONT_PATH = "static/fonts/PatrickHand-Regular.ttf"
FONT = ImageFont.truetype(FONT_PATH, 200)
parameter_options = valid_options()
number_cards = int(
retrieve_query_parameter(request, "number_cards",
parameter_options["number_cards"]))
max_number = retrieve_query_parameter(request, "max_number",
parameter_options["max_number"])
help_sheet = retrieve_query_parameter(request, "help_sheet",
parameter_options["help_sheet"])
if max_number == "cards":
numbers = list(range(1, number_cards + 1))
shuffle(numbers)
range_text = "1 to {}".format(number_cards)
elif max_number != "blank":
numbers = sample(range(1, int(max_number) + 1), number_cards)
range_text = "1 to {}".format(max_number)
else:
numbers = []
range_text = "Add list of numbers below:"
if help_sheet:
pages.append({
"type": "html",
"data": create_help_sheet(numbers, range_text)
})
number_of_pages = range(ceil(number_cards / 4))
for page in number_of_pages:
if page == number_of_pages[-1]:
image_path = IMAGE_PATH.format(3, 1)
else:
image_path = IMAGE_PATH.format(4, page + 1)
image = Image.open(image_path)
if max_number != "blank":
draw = ImageDraw.Draw(image)
page_numbers = numbers[:4]
numbers = numbers[4:]
coord_x = X_BASE_COORD
for number in page_numbers:
text = str(number)
text_width, text_height = draw.textsize(text, font=FONT)
draw.text(
(coord_x - (text_width / 2), Y_COORD - (text_height / 2)),
text,
font=FONT,
fill="#000")
coord_x -= X_COORD_DECREMENT
image = image.rotate(90, expand=True)
pages.append({"type": "image", "data": image})
return pages
def resource(request, resource):
"""Create a image for Sorting Network Cards resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A list of dictionaries for each resource page.
"""
IMAGE_SIZE_X = 2000
IMAGE_SIZE_Y = 2800
LINE_COLOUR = "#000000"
LINE_WIDTH = 3
font_path = "static/fonts/PatrickHand-Regular.ttf"
# Retrieve parameters
parameter_options = valid_options()
card_type = retrieve_query_parameter(request, "type",
parameter_options["type"])
# Create card outlines
card_outlines = Image.new("RGB", (IMAGE_SIZE_X, IMAGE_SIZE_Y), "#fff")
draw = ImageDraw.Draw(card_outlines)
for x_coord in range(0, IMAGE_SIZE_X, IMAGE_SIZE_X - LINE_WIDTH):
draw.line([(x_coord, 0), (x_coord, IMAGE_SIZE_Y)],
fill=LINE_COLOUR,
width=LINE_WIDTH)
for y_coord in range(0, IMAGE_SIZE_Y, int(IMAGE_SIZE_Y / 2 - LINE_WIDTH)):
draw.line([(0, y_coord), (IMAGE_SIZE_X, y_coord)],
fill=LINE_COLOUR,
width=LINE_WIDTH)
# Prepare text data
card_data_type = "text"
if card_type == "small_numbers":
font_size = 800
text = ["1", "2", "3", "4", "5", "6"]
elif card_type == "large_numbers":
font_size = 500
text = []
numbers = sample(range(1700000, 2100000), 6)
for number in numbers:
text.append("{:,}".format(number))
elif card_type == "fractions":
font_size = 900
font_path = "static/fonts/NotoSans-Regular.ttf"
text = [
u"\u00bd", u"\u2153", u"\u2154", u"\u215c", u"\u00be", u"\u215d"
]
elif card_type == "maori_numbers":
font_size = 300
text = [
"tahi", "rua", "toru", "whā", "rima", "ono", "whitu", "waru",
"iwa", "tekau", "tekau mā tahi", "tekau mā waru", "tekau mā toru",
"tekau mā whā", "rua tekau", "rua tekau mā ono"
]
elif card_type == "words":
font_size = 500
text = ["crocodile", "crochet", "kiwi", "weka", "kiwi", "kiwano"]
elif card_type == "letters":
font_size = 800
text = ["L", "O", "N", "K", "E", "D", "S", "P", "G", "B", "I", "Y"]
elif card_type == "maori_colours":
font_size = 500
text = [
"whero", "kākāriki", "kiwikiwi", "karaka", "kōwhai", "pango",
"māwhero", "mā"
]
elif card_type == "riding_hood":
card_data_type = "image"
images = [
"little-red-riding-hood-1.png",
"little-red-riding-hood-2.png",
"little-red-riding-hood-3.png",
"little-red-riding-hood-4.png",
"little-red-riding-hood-5.png",
"little-red-riding-hood-6.png",
]
elif card_type == "butterfly":
card_data_type = "image"
images = [
"butterfly-story-leaf.png",
"butterfly-story-baby-caterpillar.png",
"butterfly-story-caterpillar.png",
"butterfly-story-young-pupa.png",
"butterfly-story-mature-pupa.png",
"butterfly-story-butterfly.png",
]
card_centers = [
(IMAGE_SIZE_X / 2, IMAGE_SIZE_Y / 4),
(IMAGE_SIZE_X / 2, (IMAGE_SIZE_Y / 4) * 3),
]
# Add text to cards
pages = []
if card_data_type == "image":
IMAGE_PADDING = 20
MAX_IMAGE_X = IMAGE_SIZE_X - IMAGE_PADDING * 2
MAX_IMAGE_Y = IMAGE_SIZE_Y / 2 - IMAGE_PADDING * 2
BASE_PATH = "static/img/resources/sorting-network-cards/"
for (image_number, filename) in enumerate(images):
image = Image.open(os.path.join(BASE_PATH, filename))
(width, height) = image.size
if height > MAX_IMAGE_Y or width > MAX_IMAGE_X:
height_ratio = MAX_IMAGE_Y / height
width_ratio = MAX_IMAGE_X / width
ratio = min(height_ratio, width_ratio)
width *= ratio
height *= ratio
image = image.resize((int(width), int(height)),
Image.ANTIALIAS)
if image_number % 2 == 0:
page = card_outlines.copy()
draw = ImageDraw.Draw(page)
(x, y) = card_centers[0]
else:
(x, y) = card_centers[1]
coords = (int(x - (width / 2)), int(y - (height / 2)))
page.paste(image, box=coords, mask=image)
# If image on second card but not last page
if image_number % 2 == 1 and image_number != len(images) - 1:
pages.append({"type": "image", "data": page})
else:
font = ImageFont.truetype(font_path, font_size)
for (text_number, text_string) in enumerate(text):
if text_number % 2 == 0:
page = card_outlines.copy()
draw = ImageDraw.Draw(page)
(x, y) = card_centers[0]
else:
(x, y) = card_centers[1]
text_width, text_height = draw.textsize(text_string, font=font)
coord_x = x - (text_width / 2)
coord_y = y - (text_height / 1.5)
draw.text((coord_x, coord_y), text_string, font=font, fill="#000")
# If text on second card but not last page
if text_number % 2 == 1 and text_number != len(text) - 1:
pages.append({"type": "image", "data": page})
pages.append({"type": "image", "data": page})
return pages
def resource(request, resource):
"""Create a image for Binary to Alphabet resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionary for the resource page.
"""
# Retrieve relevant image
parameter_options = valid_options()
worksheet_version = retrieve_query_parameter(
request, "worksheet_version", parameter_options["worksheet_version"])
if worksheet_version == "student":
image_path = "static/img/resources/binary-to-alphabet/table.png"
else:
image_path = "static/img/resources/binary-to-alphabet/table-teacher.png"
image = Image.open(image_path)
draw = ImageDraw.Draw(image)
font_size = 30
font_path = "static/fonts/PatrickHand-Regular.ttf"
font = ImageFont.truetype(font_path, font_size)
# Draw headings
column_headings = ["Base 10", "Binary", "Letter"]
heading_coord_x = 18
heading_coord_y = 6
i = 0
while i < 9: # 9 = number of columns
if i % 3 == 0:
text = str(column_headings[0])
elif i % 3 == 1:
text = str(column_headings[1])
else:
text = str(column_headings[2])
draw.text((heading_coord_x, heading_coord_y),
text,
font=font,
fill="#000")
heading_coord_x += 113
i += 1
# Draw numbers
# Column data: (min number, max number), x coord
columns_data = [((0, 9), 58), ((9, 18), 397), ((18, 27), 736)]
for column_set in columns_data:
start, end = column_set[0]
base_coord_x = column_set[1]
base_coord_y = 75
for number in range(start, end):
text = str(number)
text_width, text_height = draw.textsize(text, font=font)
coord_x = base_coord_x - (text_width / 2)
coord_y = base_coord_y - (text_height / 2)
draw.text((coord_x, coord_y), text, font=font, fill="#000")
base_coord_y += 54
image = image.rotate(90, expand=True)
return {"type": "image", "data": image}
def resource(request, resource):
"""Create a image for Binary Cards (Small) resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionary or list of dictionaries for each resource page.
"""
BASE_IMAGE_PATH = "static/img/resources/binary-cards-small/"
IMAGE_SIZE_X = 2480
IMAGE_SIZE_Y = 3044
IMAGE_DATA = [
("binary-cards-small-1.png", 4),
("binary-cards-small-2.png", 8),
("binary-cards-small-3.png", 12),
]
# Retrieve parameters
parameter_options = valid_options()
requested_bits = retrieve_query_parameter(request, "number_bits", parameter_options["number_bits"])
dot_counts = retrieve_query_parameter(request, "dot_counts", parameter_options["dot_counts"])
black_back = retrieve_query_parameter(request, "black_back", parameter_options["black_back"])
if dot_counts:
font_path = "static/fonts/PatrickHand-Regular.ttf"
font = ImageFont.truetype(font_path, 200)
TEXT_COORDS = [
(525, 1341),
(1589, 1341),
(525, 2889),
(1589, 2889),
]
pages = []
for (image_path, image_bits) in IMAGE_DATA:
requested_bits = int(requested_bits)
if image_bits <= requested_bits:
image = Image.open(os.path.join(BASE_IMAGE_PATH, image_path))
if dot_counts:
draw = ImageDraw.Draw(image)
for number in range(image_bits - 4, image_bits):
text = str(pow(2, number))
text_width, text_height = draw.textsize(text, font=font)
coord_x = TEXT_COORDS[number % 4][0] - (text_width / 2)
coord_y = TEXT_COORDS[number % 4][1] - (text_height / 2)
draw.text(
(coord_x, coord_y),
text,
font=font,
fill="#000"
)
pages.append({"type": "image", "data": image})
if black_back:
black_card = Image.new("1", (IMAGE_SIZE_X, IMAGE_SIZE_Y))
pages.append({"type": "image", "data": black_card})
return pages
def resource(request, resource):
"""Create a image for Treasure Hunt resource.
Args:
request: HTTP request object (HttpRequest).
resource: Object of resource data (Resource).
Returns:
A dictionary for the resource page.
"""
pages = []
IMAGE_PATH = "static/img/resources/treasure-hunt/{}.png"
font_path = "static/fonts/PatrickHand-Regular.ttf"
parameter_options = valid_options()
prefilled_values = retrieve_query_parameter(request, "prefilled_values", parameter_options["prefilled_values"])
number_order = retrieve_query_parameter(request, "number_order", parameter_options["number_order"])
instructions = retrieve_query_parameter(request, "instructions", parameter_options["instructions"])
art_style = retrieve_query_parameter(request, "art", parameter_options["art"])
if instructions:
image = Image.open(IMAGE_PATH.format("instructions"))
ImageDraw.Draw(image)
pages.append({"type": "image", "data": image})
image = Image.open(IMAGE_PATH.format(art_style))
draw = ImageDraw.Draw(image)
# Add numbers to image if required
if prefilled_values != "blank":
(range_min, range_max, font_size) = number_range(request)
font = ImageFont.truetype(font_path, font_size)
total_numbers = 26
numbers = sample(range(range_min, range_max), total_numbers)
if number_order == "sorted":
numbers.sort()
base_coord_y = 506
coord_y_increment = 199
base_coords_x = [390, 700]
for i in range(0, total_numbers):
text = str(numbers[i])
text_width, text_height = draw.textsize(text, font=font)
coord_x = base_coords_x[i % 2] - (text_width / 2)
coord_y = base_coord_y - (text_height / 2)
if i % 2 == 1:
coord_y -= 10
base_coord_y += coord_y_increment
draw.text(
(coord_x, coord_y),
text,
font=font,
fill="#000"
)
text = "{} - {} to {}".format(number_order.title(), range_min, range_max - 1)
font = ImageFont.truetype(font_path, 75)
text_width, text_height = draw.textsize(text, font=font)
coord_x = 1220 - (text_width / 2)
coord_y = 520 - (text_height / 2)
draw.text(
(coord_x, coord_y),
text,
font=font,
fill="#000",
)
pages.append({"type": "image", "data": image})
return pages
def resource(request, resource):
"""Create a image for Piano Keys resource.
Args:
request: HTTP request object (Request).
resource: Object of resource data (Resource).
Returns:
A dictionary for the resource page.
"""
KEY_DATA = {
"A": {
"colour":
"hsl(356, 95%, 85%)",
"areas": [
((1002, 21), (1005, 711), (1200, 716), (1193, 15)),
((2392, 15), (2356, 720), (2541, 720), (2552, 17)),
],
},
"B": {
"colour":
"hsl(21, 90%, 85%)",
"areas": [
((1193, 15), (1200, 716), (1369, 719), (1400, 15)),
((2552, 17), (2541, 720), (2713, 720), (2756, 20)),
],
},
"C": {
"colour":
"hsl(52, 100%, 85%)",
"areas": [
((15, 15), (51, 711), (255, 715), (186, 21)),
((1395, 24), (1371, 720), (1566, 717), (1590, 18)),
],
},
"D": {
"colour":
"hsl(140, 87%, 85%)",
"areas": [
((186, 21), (255, 715), (408, 714), (390, 15)),
((1590, 18), (1566, 717), (1760, 718), (1794, 12)),
],
},
"E": {
"colour":
"hsl(205, 85%, 85%)",
"areas": [
((390, 15), (408, 714), (603, 717), (585, 12)),
((1794, 12), (1760, 718), (1979, 720), (2004, 19)),
],
},
"F": {
"colour":
"hsl(293, 45%, 85%)",
"areas": [
((585, 12), (603, 717), (828, 720), (717, 15)),
((2004, 19), (1979, 720), (2163, 720), (2192, 15)),
],
},
"G": {
"colour":
"hsl(238, 51%, 85%)",
"areas": [
((717, 15), (828, 720), (1005, 711), (1002, 21)),
((2192, 15), (2163, 720), (2356, 720), (2392, 15)),
],
},
}
parameter_options = valid_options()
highlight = retrieve_query_parameter(request, "highlight",
parameter_options["highlight"])
image_path = "static/img/resources/piano-keys/keyboard.png"
image = Image.open(image_path)
page = Image.new("RGB", image.size, "#FFF")
if highlight:
highlight_key_areas(page, KEY_DATA.get(highlight))
# Add piano keys overlay
page.paste(image, mask=image)
page = page.rotate(90, expand=True)
return {"type": "image", "data": page}
