Add python scripts and pdf folder
Mara Karagianni
2 years ago
parent
267248b2e1
commit
57bd412e96
@ -0,0 +1,116 @@
|
||||
import json
|
||||
import sys
|
||||
import random
|
||||
from tree_maker import Tree
|
||||
from fpdf import FPDF
|
||||
# ref https://pyfpdf.readthedocs.io/en/latest/
|
||||
|
||||
# declare input data
|
||||
inputfile = (
|
||||
"/home/mara/webdev/sortingtree/cleaned_data/year_name_fam_subset.json"
|
||||
)
|
||||
in_data = open(inputfile, "r")
|
||||
data = in_data.read()
|
||||
in_data.close()
|
||||
data_json = json.loads(data)
|
||||
|
||||
reddit_file = open(
|
||||
"/home/mara/webdev/sortingtree/cleaned_data/fam_reddit_subset.json"
|
||||
)
|
||||
reddit_data = reddit_file.read()
|
||||
reddit_file.close()
|
||||
reddit_json = json.loads(reddit_data)
|
||||
|
||||
|
||||
# declare pdf format and margins
|
||||
margin = 15
|
||||
|
||||
zine = FPDF(orientation="L", unit="mm", format="A4")
|
||||
|
||||
# set font for all text
|
||||
# zine.add_font(
|
||||
# 'CasaleNBP', '', r"./fonts/CasaletwoNbp-Bp4V.ttf", uni=True)
|
||||
# tree_font = 'CasaleNBP'
|
||||
|
||||
zine.add_font(
|
||||
'Kp', '', r"./fonts/KpProgrammerAlternatesNbp-Zg1q.ttf", uni=True)
|
||||
tree_font = 'Kp'
|
||||
font_size = 15
|
||||
zine.set_font(tree_font, '', font_size)
|
||||
|
||||
zine.set_margins(margin, margin, margin)
|
||||
zine.add_page()
|
||||
zine.set_xy(zine.w/2+margin, margin)
|
||||
|
||||
tree = Tree(zine)
|
||||
root = tree.keys_sorting(data_json)
|
||||
|
||||
|
||||
def make_bin_tree(output, zine, tree, root):
|
||||
global data_json
|
||||
global margin
|
||||
|
||||
tree.draw_year_name(data_json, root, zine.h, zine.w, margin)
|
||||
zine.output(output)
|
||||
print("PDF saved as {}".format(output))
|
||||
|
||||
|
||||
def make_bin_tree_reddit(output, zine, tree, root, reddit_json):
|
||||
global data_json
|
||||
global margin
|
||||
|
||||
tree.draw_year_name_reddit(
|
||||
data_json, reddit_json, root, zine.h, zine.w, margin)
|
||||
zine.output(output)
|
||||
print("PDF saved as {}".format(output))
|
||||
|
||||
|
||||
def make_bin_tree_position_nodes(output, zine, tree, root):
|
||||
global data_json
|
||||
global margin
|
||||
|
||||
tree.preorder_position_nodes(data_json, root, zine.h, zine.w, margin)
|
||||
print("PDF saved as {}".format(output))
|
||||
|
||||
|
||||
def make_bin_tree_weird_position_nodes(output, zine, tree, root):
|
||||
global data_json
|
||||
global margin
|
||||
|
||||
tree.weird_position_nodes(data_json, root, zine.h, zine.w, margin)
|
||||
print("PDF saved as {}".format(output))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
# input text and output pdf
|
||||
if len(sys.argv) > 1:
|
||||
if len(sys.argv) == 4:
|
||||
output = sys.argv[3]
|
||||
inputfile = sys.argv[2]
|
||||
version = sys.argv[1]
|
||||
else:
|
||||
version = sys.argv[1]
|
||||
output = "./trees/test_%d.pdf" % int(version)
|
||||
|
||||
else:
|
||||
version = random.randint(1, 100)
|
||||
inputfile = "./trees/array.txt"
|
||||
output = "./trees/test_%d.pdf" % int(version)
|
||||
|
||||
# make_bin_tree(output, zine, tree, root)
|
||||
# make_bin_tree_reddit(output, zine, tree, root, reddit_json)
|
||||
# make_bin_tree_position_nodes(output, zine, tree, root)
|
||||
make_bin_tree_weird_position_nodes(output, zine, tree, root)
|
||||
|
||||
# TODO: add functions of the following tree methods
|
||||
# tree.draw_year(json_data, root, x, y, zine.h, zine.w, margin, steps=30)
|
||||
# tree.print_nodes(root)
|
||||
# tree.draw_year_name_reddit(
|
||||
# treejson_data, root, x, y, max_height, margin, width)
|
||||
# tree.print_bin_tree(root, x, y, max_height, margin, width, steps=max_height/3)
|
||||
# tree.print_tree_terminal(root)
|
||||
# tree.design_tree(json_data, font_size, margin, steps=10)
|
||||
# root = zine.tree_sorting([4, 8, 7, 9, 10, 1, 20, 5, 15, 11])
|
||||
# root = zine.tree_sorting(["BIN", "ARY", "IS", "FOR", "SORTING", "TREES"])
|
||||
# sentence = "BIN ARY IS FOR SORTING TREES"
|
||||
# root = tree.tree_sorting(sentence.split())
|
||||
@ -0,0 +1,585 @@
|
||||
#!/bin/python
|
||||
"""
|
||||
A module for generating tree sorting layout
|
||||
based on pyFPDF.
|
||||
GPL3 License, Mara Karayanni December 2022
|
||||
"""
|
||||
import glob
|
||||
import json
|
||||
import random
|
||||
import re
|
||||
import subprocess
|
||||
|
||||
|
||||
class Tree:
|
||||
def __init__(self, zine):
|
||||
self.zine = zine
|
||||
|
||||
def design_tree(self, title, size, margin, steps):
|
||||
""" Simple layout of branching with black color"""
|
||||
initial_steps = steps
|
||||
for letter in title:
|
||||
|
||||
if self.zine.y + size > self.zine.page_break_trigger: # self.zine.h:
|
||||
print(self.zine.h)
|
||||
print(self.zine.get_y())
|
||||
self.zine.add_page()
|
||||
center_x = self.zine.w/2 + margin
|
||||
self.zine.set_xy(center_x, margin)
|
||||
steps = initial_steps
|
||||
|
||||
point_a = self.zine.get_x()
|
||||
point_b = self.zine.get_y()
|
||||
print(point_a, point_b)
|
||||
self.zine.cell(size, size, letter) # letter here is sorted by the tree
|
||||
node_right = self.zine.get_x() + steps / 2
|
||||
node_left = point_a - steps / 2
|
||||
point_bb = point_b + steps
|
||||
self.zine.line(point_a, point_b, node_left, point_bb)
|
||||
self.zine.line(point_a, point_b, node_right, point_bb)
|
||||
self.zine.set_xy(node_left, point_bb)
|
||||
steps *= 2
|
||||
|
||||
def keys_sorting(self, data):
|
||||
""" Make a list of sorted keys using Python's sorted function"""
|
||||
global res
|
||||
if type(data) is dict:
|
||||
for key in sorted(data.keys()):
|
||||
res.append(key)
|
||||
else:
|
||||
for key in sorted(data):
|
||||
res.append()
|
||||
return res
|
||||
|
||||
def tree_sorting(self, data):
|
||||
""" Make a list of keys, which are first sorted
|
||||
by the insert_node function
|
||||
"""
|
||||
global node
|
||||
if type(data) is dict:
|
||||
for key in data.keys():
|
||||
node = self.insert_node(node, key)
|
||||
else:
|
||||
for key in data:
|
||||
node = self.insert_node(node, key)
|
||||
return node
|
||||
|
||||
def insert_node(self, node, key):
|
||||
""" Sorting key elements by recursive call of the function
|
||||
and the use of the class Node, which has left and right keys
|
||||
"""
|
||||
|
||||
if node is None:
|
||||
node = Node(key)
|
||||
return node
|
||||
if (key < node.key):
|
||||
|
||||
# recurse
|
||||
node.left = self.insert_node(node.left, key)
|
||||
|
||||
elif (key > node.key):
|
||||
# recurse
|
||||
node.right = self.insert_node(node.right, key)
|
||||
|
||||
return node
|
||||
|
||||
def print_nodes(self, node):
|
||||
""" Print left and right keys of an instance of the class Node,
|
||||
mostly for debugging purposes
|
||||
"""
|
||||
global res
|
||||
if (node is not None):
|
||||
self.print_nodes(node.left)
|
||||
print("LEFT SORTED KEY IS", node.key, end="\n")
|
||||
res.append(node.key)
|
||||
self.print_nodes(node.right)
|
||||
print("RIGHT SORTED KEY IS", node.key, end="\n")
|
||||
return res
|
||||
|
||||
def draw_year(self, data, root, x, y,
|
||||
page_height, width, margin, steps=30):
|
||||
""" Tree method draw_year layout:
|
||||
Simple year stamps in vertical position and progressively
|
||||
horizontally to the left side
|
||||
"""
|
||||
letter_size = 8
|
||||
right_margin = margin
|
||||
parent_x = x
|
||||
parent_y = y
|
||||
|
||||
if root is not None:
|
||||
sorted_root = self.keys_sorting(data)
|
||||
print("SORTED ROOT", sorted_root)
|
||||
for key in sorted_root:
|
||||
|
||||
if parent_y >= page_height-margin*2:
|
||||
self.zine.add_page()
|
||||
self.zine.set_xy(width/2, margin)
|
||||
print("NEW PAGE", "Y", self.zine.get_y())
|
||||
if parent_x >= width or parent_x <= margin:
|
||||
self.zine.set_xy(width/2, parent_y)
|
||||
|
||||
parent_x = self.zine.get_x()
|
||||
parent_y = self.zine.get_y()
|
||||
|
||||
# draw the year
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # draw the root
|
||||
print("YEAR", key, "YEAR X Y", parent_x, parent_y)
|
||||
|
||||
parent_x -= steps/5
|
||||
parent_y += steps
|
||||
self.zine.set_xy(parent_x, parent_y)
|
||||
|
||||
def draw_year_name(self, data, root, page_height, margin, steps=30):
|
||||
""" Tree method draw_year_name layout:
|
||||
Simple year and name/letters stamps in vertical position
|
||||
and progressively horizontally to the left side
|
||||
"""
|
||||
letter_size = 8
|
||||
width = self.zine.w
|
||||
parent_x = self.zine.get_x()
|
||||
parent_y = self.zine.get_y()
|
||||
|
||||
if root is not None:
|
||||
sorted_root = self.keys_sorting(data)
|
||||
print("SORTED ROOT", sorted_root)
|
||||
for key in sorted_root:
|
||||
|
||||
if parent_y >= page_height-margin*2:
|
||||
self.zine.add_page()
|
||||
self.zine.set_xy(width/2, margin)
|
||||
print("NEW PAGE", "Y", self.zine.get_y())
|
||||
if parent_x >= width or parent_x <= margin:
|
||||
self.zine.set_xy(width/2, parent_y)
|
||||
|
||||
parent_x = self.zine.get_x()
|
||||
parent_y = self.zine.get_y()
|
||||
|
||||
# draw the year
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # draw the root
|
||||
print("YEAR", key, "YEAR X Y", parent_x, parent_y)
|
||||
|
||||
# draw the tree names
|
||||
val = data[key]["scientificName"]
|
||||
child_x = parent_x - steps
|
||||
child_y = parent_y + letter_size
|
||||
if child_x <= margin:
|
||||
print("CHILD OFFSET X", "PARENT X Y", parent_x, parent_y, "STEPS", steps)
|
||||
if child_y >= page_height:
|
||||
print("CHILD OFFSET Y", "PARENT X Y", parent_x, parent_y, "STEPS", steps)
|
||||
if type(val) is list:
|
||||
for v in val:
|
||||
self.zine.set_draw_color(r=255, g=128, b=0)
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(v)) # draw child
|
||||
child_y +=5
|
||||
child_x += self.zine.get_x() + 5
|
||||
else:
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(val)) # draw child
|
||||
child_x += self.zine.get_x() + 5
|
||||
|
||||
previous_x = parent_x
|
||||
previous_y = parent_y
|
||||
parent_x -= steps/5
|
||||
parent_y += steps
|
||||
self.zine.set_xy(parent_x, parent_y)
|
||||
self.zine.set_draw_color(r=128, g=255, b=0)
|
||||
self.zine.line(
|
||||
previous_x, previous_y,
|
||||
self.zine.get_x(), self.zine.get_y()
|
||||
)
|
||||
|
||||
def draw_year_name_reddit(self, tree_json, reddit_json, root, page_height,
|
||||
width, margin, steps=30):
|
||||
""" Tree method draw_year_name_reddit layout:
|
||||
Branching sorted year followed by trees named that year on the
|
||||
left side and reddit blog titles related to those trees
|
||||
on the right side"""
|
||||
|
||||
letter_size = 8
|
||||
right_margin = margin
|
||||
parent_x = self.zine.get_x()
|
||||
parent_y = self.zine.get_y()
|
||||
|
||||
if root is not None:
|
||||
sorted_root = self.keys_sorting(tree_json)
|
||||
print("SORTED ROOT", sorted_root)
|
||||
for key in sorted_root:
|
||||
|
||||
if parent_y >= page_height-margin*2:
|
||||
self.zine.add_page()
|
||||
self.zine.set_xy(width/2, margin)
|
||||
print("NEW PAGE", "Y", self.zine.get_y())
|
||||
if parent_x >= width or parent_x <= margin:
|
||||
self.zine.set_xy(width/2, parent_y)
|
||||
|
||||
parent_x = self.zine.get_x()
|
||||
parent_y = self.zine.get_y()
|
||||
|
||||
# draw the year
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # draw the root
|
||||
print("YEAR", key, "YEAR X Y", parent_x, parent_y)
|
||||
|
||||
# draw the tree names
|
||||
val = tree_json[key]["scientificName"]
|
||||
family = tree_json[key]["family"]
|
||||
child_x = parent_x - steps
|
||||
child_y = parent_y + letter_size
|
||||
if type(val) is list:
|
||||
for v in val:
|
||||
self.zine.set_draw_color(r=255, g=0, b=0)
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(v)) # draw child
|
||||
|
||||
# draw reddit
|
||||
self.zine.set_draw_color(r=0, g=0, b=255)
|
||||
for r in reddit_json.keys():
|
||||
if r in family:
|
||||
reddit_list = reddit_json[r]
|
||||
print("REDIT", reddit_list)
|
||||
reddit_x = width -2*margin - child_x
|
||||
reddit_y = child_y
|
||||
for reddit in reddit_list:
|
||||
reddit_y += steps/5
|
||||
self.zine.set_xy(reddit_x, reddit_y)
|
||||
self.zine.cell(letter_size, letter_size, str(reddit)) # draw child
|
||||
self.zine.line(child_x, child_y, reddit_x, reddit_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
|
||||
child_y +=5
|
||||
child_x += self.zine.get_x() + 5
|
||||
else:
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(val)) # draw child
|
||||
child_x += self.zine.get_x() + 5
|
||||
|
||||
previous_x = parent_x
|
||||
previous_y = parent_y
|
||||
parent_x -= steps/5
|
||||
parent_y += steps
|
||||
self.zine.set_xy(parent_x, parent_y)
|
||||
self.zine.set_draw_color(r=128, g=255, b=0)
|
||||
self.zine.line(previous_x, previous_y, self.zine.get_x(), self.zine.get_y())
|
||||
|
||||
def preorder_position_nodes(self, data, root, page_height,
|
||||
width, margin, steps=30):
|
||||
letter_size = 5
|
||||
right_margin = margin
|
||||
parent_x = self.zine.get_x()
|
||||
parent_y = self.zine.get_y()
|
||||
|
||||
if root is not None:
|
||||
sorted_root = self.keys_sorting(data)
|
||||
print("SORTED ROOT", sorted_root)
|
||||
for key in sorted_root:
|
||||
|
||||
if parent_y >= page_height:
|
||||
self.zine.add_page()
|
||||
self.zine.set_xy(width/2, margin)
|
||||
print("NEW PAGE", "Y", self.zine.get_y())
|
||||
if parent_x >= width or parent_x <= margin:
|
||||
self.zine.set_xy(width/2, parent_y)
|
||||
|
||||
parent_x = self.zine.get_x()
|
||||
parent_y = self.zine.get_y()
|
||||
|
||||
# draw the year
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # draw the root
|
||||
print("YEAR", key, "YEAR X Y", parent_x, parent_y)
|
||||
|
||||
# draw the tree names
|
||||
val = data[key]["scientificName"]
|
||||
child_x = parent_x - steps
|
||||
child_y = parent_y + letter_size
|
||||
if child_x >= right_margin:
|
||||
print("CHILD OFFSET", "PARENT X Y", parent_x, parent_y, "STEPS", steps)
|
||||
print("VALUE", val, "X", child_x, "Y", child_y)
|
||||
if type(val) is list:
|
||||
for v in val:
|
||||
self.zine.set_draw_color(r=255, g=128, b=0)
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(v)) # draw child
|
||||
child_y +=5
|
||||
child_x += self.zine.get_x() + 5
|
||||
else:
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(val)) # draw child
|
||||
child_x += self.zine.get_x() + 5
|
||||
|
||||
# parent_x -= steps/5
|
||||
# parent_y += steps*2
|
||||
# self.zine.set_draw_color(r=128, g=255, b=0)
|
||||
# self.zine.line(self.zine.get_x(), self.zine.get_y(), parent_x, parent_y)
|
||||
|
||||
|
||||
def weird_position_nodes(self, data, root, page_height, width, margin, steps=30):
|
||||
letter_size = 5
|
||||
right_margin = margin
|
||||
|
||||
x = self.zine.get_x()
|
||||
y = self.zine.get_y()
|
||||
|
||||
|
||||
if root is None:
|
||||
root = self.keys_sorting(data)
|
||||
print("SORTED ROOT", root)
|
||||
for key in root:
|
||||
parent_x = x
|
||||
parent_y = y
|
||||
|
||||
# draw the year
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # draw the root
|
||||
print("YEAR", key, "YEAR X Y", parent_x, parent_y)
|
||||
|
||||
# draw the tree names
|
||||
val = data[key]["scientificName"]
|
||||
child_x = parent_x - steps
|
||||
child_y = parent_y + letter_size
|
||||
if child_x >= right_margin:
|
||||
print("CHILD OFFSET", "PARENT X Y", parent_x, parent_y, "STEPS", steps)
|
||||
print("VALUE", val, "X", child_x, "Y", child_y)
|
||||
if type(val) is list:
|
||||
for v in val:
|
||||
self.zine.set_draw_color(r=255, g=128, b=0)
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(v)) # draw child
|
||||
child_y +=5
|
||||
child_x += self.zine.get_x() + 5
|
||||
else:
|
||||
self.zine.line(parent_x, parent_y, child_x, child_y)
|
||||
self.zine.set_xy(child_x, child_y)
|
||||
self.zine.cell(letter_size, letter_size, str(val)) # draw child
|
||||
child_x += self.zine.get_x() + 5
|
||||
|
||||
x -= steps/5
|
||||
y += steps
|
||||
self.zine.set_draw_color(r=128, g=255, b=0)
|
||||
self.zine.line(parent_x, parent_y, x, y)
|
||||
# self.zine.set_xy(x, y)
|
||||
|
||||
if y >= page_height:
|
||||
print("NEW PAGE")
|
||||
self.zine.add_page()
|
||||
self.zine.set_xy(x, margin)
|
||||
print("Y", self.zine.get_y())
|
||||
if x >= width or x <= margin:
|
||||
self.zine.set_xy(width/2, y)
|
||||
# else:
|
||||
# self.zine.set_xy(x, y)
|
||||
|
||||
# self.wrap_page(x, y, page_height, width, margin)
|
||||
|
||||
def position_nodes(self, root, x, y, page_height, margin, steps=26):
|
||||
letter_size = 10
|
||||
if self.zine.get_y() >= page_height:
|
||||
self.zine.add_page()
|
||||
self.zine.set_xy(margin, margin)
|
||||
x = self.zine.get_x()
|
||||
y = self.zine.get_y()
|
||||
else:
|
||||
self.zine.set_xy(x, y)
|
||||
root_x = x
|
||||
root_y = y
|
||||
|
||||
if root is not None:
|
||||
# if root.left: # left display node name
|
||||
|
||||
# draw left branch
|
||||
self.zine.set_draw_color(r=255, g=128, b=0)
|
||||
node_left_x = root_x - steps / 2
|
||||
node_left_y = root_y + steps
|
||||
self.zine.cell(letter_size, letter_size, str(root.key)) # letter is sorted
|
||||
self.zine.line(root_x, root_y, node_left_x, node_left_y)
|
||||
print("LEFT NODE", root.key, node_left_x, node_left_y)
|
||||
|
||||
# is there more nodes at left side?
|
||||
steps *= 2
|
||||
self.zine.set_xy(node_left_x, node_left_y)
|
||||
self.position_nodes(root.left, node_left_x, node_left_y, page_height, margin)
|
||||
|
||||
# if root.right: # right display node name
|
||||
|
||||
# draw right branch
|
||||
self.zine.set_draw_color(r=128, g=255, b=0)
|
||||
node_right_x = root_x + steps / 2
|
||||
node_right_y = root_y + steps
|
||||
self.zine.cell(letter_size, letter_size, str(root.key)) # letter is sorted
|
||||
self.zine.line(root_x, root_y, node_right_x, node_right_y)
|
||||
print("RIGHT NODE", root.key, node_right_x, node_right_y)
|
||||
|
||||
# is there more nodes at right side?
|
||||
steps *= 2
|
||||
self.zine.set_xy(node_right_x, node_right_y)
|
||||
self.position_nodes(root.right, node_right_x, node_right_y, page_height, margin)
|
||||
|
||||
def print_2d_tree(self, root, space=0, LEVEL_SPACE = 5):
|
||||
if (root == None): return
|
||||
space += LEVEL_SPACE
|
||||
self.print_2d_tree(root.right, space)
|
||||
# print() # neighbor space
|
||||
for i in range(LEVEL_SPACE, space): print(end = " ")
|
||||
print("|" + str(root.key) + "|<")
|
||||
self.print_2d_tree(root.left, space)
|
||||
|
||||
def draw_tree(self, node, level=0, res=[]):
|
||||
if level < len(res):
|
||||
if node:
|
||||
res[level].append(node.key)
|
||||
else:
|
||||
res[level].append(" ")
|
||||
else:
|
||||
if node:
|
||||
res.append([node.key])
|
||||
else:
|
||||
res.append([" "])
|
||||
if not node:
|
||||
return
|
||||
self.draw_tree(node.left, level+1, res)
|
||||
self.draw_tree(node.right, level+1, res)
|
||||
print("RES from draw tree is", res)
|
||||
return res
|
||||
|
||||
def print_tree(self, node, x, y, width, margin, page_height, steps=5):
|
||||
letter_size = 20
|
||||
|
||||
tree_array = self.draw_tree(node)
|
||||
h = len(tree_array)
|
||||
white_spaces = (2**h)-1
|
||||
|
||||
def print_spaces(n, x, i):
|
||||
for i in range(n):
|
||||
if i % 2 == 0:
|
||||
x += float(steps/2)
|
||||
else:
|
||||
x -= float(steps/2)
|
||||
self.zine.set_xy(x, y)
|
||||
|
||||
prev_x = None
|
||||
prev_y = None
|
||||
for level in tree_array:
|
||||
print("LEVEL is", level, "AND OF TYPE", type(level))
|
||||
for i, key in enumerate(level):
|
||||
if i==0 and len(level) == 1:
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # letter is sorted
|
||||
print("FIRST NODE", key, "POSITION OF KEY", x, y, "i is", i)
|
||||
prev_x = x
|
||||
prev_y = y
|
||||
self.zine.set_draw_color(r=0, g=255, b=0)
|
||||
print_spaces(1+2*white_spaces, i, x)
|
||||
# self.zine.line(prev_x, prev_y, self.zine.get_x(), self.zine.get_y())
|
||||
print("NEW xy after first node", self.zine.get_x(), self.zine.get_y())
|
||||
else:
|
||||
if key == " ":
|
||||
pass
|
||||
else:
|
||||
print("POSITION OF KEY", key, self.zine.get_x(), self.zine.get_y(), "i is", i)
|
||||
self.zine.line(prev_x, prev_y, self.zine.get_x(), self.zine.get_y())
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # letter is sorted
|
||||
print_spaces(1+2*white_spaces, i, x)
|
||||
y += steps/2
|
||||
if i % 2 == 0:
|
||||
x += float(steps)
|
||||
else:
|
||||
x -= float(steps)
|
||||
self.zine.set_xy(x, y)
|
||||
print()
|
||||
|
||||
def print_bin_tree(self, node, x, y, width, margin, page_height, steps=5):
|
||||
letter_size = 20
|
||||
|
||||
tree_array = self.draw_tree(node)
|
||||
h = len(tree_array)
|
||||
white_spaces = (2**h)-1
|
||||
|
||||
def print_spaces(n, x, i):
|
||||
for i in range(n):
|
||||
if i % 2 == 0:
|
||||
x += float(steps/2)
|
||||
else:
|
||||
x -= float(steps/2)
|
||||
self.zine.set_xy(x, y)
|
||||
|
||||
prev_x = None
|
||||
prev_y = None
|
||||
count = 0
|
||||
pos_level = {}
|
||||
for level in tree_array:
|
||||
# TODO: count the levels and revisit them, keep a dict of level and
|
||||
# x,y
|
||||
count += 1
|
||||
pos_level[count] = (x, y)
|
||||
print("LEVEL is", level, "AND OF TYPE", type(level))
|
||||
for i, key in enumerate(level):
|
||||
if i==0 and len(level) == 1:
|
||||
prev_x = x
|
||||
prev_y = y
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # letter is sorted
|
||||
print("FIRST NODE", key, "POSITION OF KEY", x, y, "i is", i)
|
||||
print_spaces(1+2*white_spaces, i, x)
|
||||
print("NEW xy after first node", self.zine.get_x(), self.zine.get_y())
|
||||
else:
|
||||
if key == " ":
|
||||
pass
|
||||
else:
|
||||
print("POSITION OF KEY", key, self.zine.get_x(), self.zine.get_y(), "i is", i)
|
||||
self.zine.cell(letter_size, letter_size, str(key)) # letter is sorted
|
||||
print_spaces(1+2*white_spaces, i, x)
|
||||
y += steps/2
|
||||
if i % 2 == 0:
|
||||
x += float(steps)
|
||||
else:
|
||||
x -= float(steps)
|
||||
self.zine.set_xy(x, y)
|
||||
print("LEVELS ARE", pos_level)
|
||||
for count, coord in pos_level.items():
|
||||
self.zine.set_draw_color(r=0, g=255, b=0)
|
||||
try:
|
||||
self.zine.line(coord[0], coord[1], pos_level[count+1][0], pos_level[count+1][1])
|
||||
except Exception as e:
|
||||
print(e)
|
||||
|
||||
def print_tree_terminal(self, node):
|
||||
|
||||
tree_array = self.draw_tree(node)
|
||||
h = len(tree_array)
|
||||
white_spaces = (2**h)-1
|
||||
|
||||
def print_spaces(n):
|
||||
for i in range(n):
|
||||
print(" ",end="")
|
||||
|
||||
for level in tree_array:
|
||||
white_spaces = white_spaces//2
|
||||
for i, key in enumerate(level):
|
||||
if i==0:
|
||||
print_spaces(white_spaces)
|
||||
print(key, end="")
|
||||
print_spaces(1+2*white_spaces)
|
||||
print()
|
||||
|
||||
def wrap_page(self, x, y, page_height, page_width, margin):
|
||||
right_margin = page_width/2
|
||||
if y >= page_height:
|
||||
self.zine.add_page()
|
||||
self.zine.set_xy(right_margin, margin)
|
||||
elif x >= page_width:
|
||||
self.zine.set_xy(right_margin, y)
|
||||
else:
|
||||
self.zine.set_xy(x, y)
|
||||
|
||||
class Node:
|
||||
|
||||
def __init__(self, item = 0):
|
||||
self.key = item
|
||||
self.left, self.right = None, None
|
||||
|
||||
root = None
|
||||
res = []
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Loading…
Reference in New Issue