diff --git a/draw/Iinstruction.py b/draw/Iinstruction.py index 66aae4d..da71008 100644 --- a/draw/Iinstruction.py +++ b/draw/Iinstruction.py @@ -11,9 +11,16 @@ class Iinstruction: self.instruction_text = instruction_text @abstractmethod - def to_image(self, x:float, y:float, x_sz: float, y_sz: float) -> Iterable[float]: + def to_image(self, x:int, y:int, x_sz: int) -> Iterable[float]: pass + @abstractmethod + def getblksize(self) -> float: + return self._getblksize() + + def _getblksize(self) -> float: + return cti.get_text_size(self.instruction_text)[1] + class generic_instruction(Iinstruction): """Any instruction that is not a control structure""" @@ -21,9 +28,8 @@ class generic_instruction(Iinstruction): def __init__(self, instruction_text: str) -> None: Iinstruction.__init__(self, instruction_text) - def to_image(self, x:int, y:int, x_sz: int, y_sz: int) -> Iterable[float]: - new_x, new_y = cti.draw_generic_instruction(self.instruction_text, x, y, x_sz, y_sz) - return new_x, new_y + def to_image(self, x:int, y:int, x_sz: int) -> Iterable[float]: + return cti.draw_generic_instruction(self.instruction_text, x, y, x_sz, self.getblksize()) @@ -38,31 +44,40 @@ class if_instruction(Iinstruction): Iinstruction.__init__(self, instruction_text) self.true_case = true_case self.false_case = false_case - - def to_image(self, x:int, y:int, x_sz: int, y_sz: int) -> Iterable[float]: - true_x, true_y, true_sz_x, true_sz_y, false_x, false_y, false_sz_x, false_sz_y = cti.draw_if_statement( - self.instruction_text, - x, y, x_sz, y_sz) - true_blk_sz = self.draw_true_case(true_x, true_y, true_sz_x, true_sz_y) - false_blk_sz = self.draw_false_case(false_x, false_y, false_sz_x, false_sz_y) - blk_sz = max(true_blk_sz, false_blk_sz) - return x, true_y + blk_sz + def get_truesize(self) -> float: + sz = 0.0 + for inst in self.true_case: + sz += inst.getblksize() + return sz - def draw_true_case(self, x: float, y:float, x_sz:float, y_sz:float) -> float: - start_y = y - y_sz /= len(self.true_case) - for instruction in self.true_case: - x, y = instruction.to_image(x, y, x_sz, y_sz) - return y - start_y - - def draw_false_case(self, x: float, y:float, x_sz:float, y_sz:float) -> float: - start_y = y + def get_falsesize(self) -> float: + sz = 0.0 + if self.false_case: + for inst in self.false_case: + sz += inst.getblksize() + return sz + + def getblksize(self) -> float: + return self._getblksize() + max(self.get_truesize(), self.get_falsesize()) + + def to_image(self, x:int, y:int, x_sz: int) -> Iterable[float]: + true_x, true_y, true_sz_x, _, false_x, false_y, false_sz_x, _ = cti.draw_if_statement( + self.instruction_text, x, y, x_sz, self.getblksize() + ) + self.draw_true_case(true_x, true_y, true_sz_x) + self.draw_false_case(false_x, false_y, false_sz_x) + blk_size = self.getblksize() + return x, y + blk_size + + def draw_true_case(self, x: float, y:float, x_sz:float): + for instruction in self.true_case: + x, y = instruction.to_image(x, y, x_sz) + + def draw_false_case(self, x: float, y:float, x_sz:float): if self.false_case: - y_sz /= len(self.false_case) for instruction in self.false_case: - x, y = instruction.to_image(x, y, x_sz, y_sz) - return y - start_y + x, y = instruction.to_image(x, y, x_sz) #TODO # class switch_instruction(Iinstruction): @@ -87,34 +102,41 @@ class while_instruction_front(Iinstruction): def __init__(self, condition: str, instructions: List[Iinstruction]) -> None: Iinstruction.__init__(self, condition) self.child_instructions = instructions + + def get_children_size(self) -> float: + children_sz = 0 + for inst in self.child_instructions: + children_sz += inst.getblksize() + return children_sz + + def getblksize(self) -> float: + return self._getblksize() + self.get_children_size() - def to_image(self, x:int, y:int, x_sz: int, y_sz: int): - children_x, children_y, children_sz_x, children_sz_y = cti.draw_while_loop_front(self.instruction_text, x, y, x_sz, y_sz) - blk_size = self.draw_children(children_x, children_y, children_sz_x, children_sz_y) - return x, y + blk_size + def to_image(self, x:int, y:int, x_sz: int) -> Iterable[float]: + children_x, children_y, children_sz_x = cti.draw_while_loop_front(self.instruction_text, x, y, x_sz, self.getblksize()) + self.draw_children(children_x, children_y, children_sz_x) - def draw_children(self, x:float, y:float, x_sz:float, y_sz:float) -> float: - y_sz /= len(self.child_instructions) - for instruction in self.child_instructions: - x, y = instruction.to_image(x, y, x_sz, y_sz) - return y_sz + return x, y + self.getblksize() + def draw_children(self, x:float, y:float, x_sz:float): + for inst in self.child_instructions: + x, y = inst.to_image(x, y, x_sz) + return self.get_children_size() + class while_instruction_back(while_instruction_front): def __init__(self, condition: str, instructions: List[Iinstruction]) -> None: while_instruction_front.__init__(self, condition, instructions) - def to_image(self, x:int, y:int, x_sz: int, y_sz: int): + def to_image(self, x:int, y:int, x_sz: int): children_x, children_y, children_sz_x, children_sz_y = cti.draw_while_loop_back(self.instruction_text, x, y, x_sz, y_sz) - blk_size = self.draw_children(children_x, children_y, children_sz_x, children_sz_y) - return x, y + blk_size + blk_size = self.draw_children(children_x, children_y, children_sz_x) + return x - def draw_children(self, x:float, y:float, x_sz:float, y_sz:float) -> float: - y_sz /= len(self.child_instructions) + def draw_children(self, x:float, y:float, x_sz:float): for instruction in self.child_instructions: - x, y = instruction.to_image(x, y, x_sz, y_sz) - return y_sz + x, y = instruction.to_image(x, y, x_sz) if __name__ == "__main__": @@ -130,5 +152,5 @@ if __name__ == "__main__": if_instruction("shouldNiet()", [ generic_instruction("hiet()") ], [generic_instruction("hiet()")]), ]) cti.NSD_init(500, 500) - test.to_image(0, 0, 500, 500) + test.to_image(0, 0, 500) cti.NSD_save("Iinstruction") \ No newline at end of file diff --git a/draw/code_to_image.py b/draw/code_to_image.py index ed93be8..f94d10e 100644 --- a/draw/code_to_image.py +++ b/draw/code_to_image.py @@ -16,15 +16,26 @@ def NSD_init(x: float, y: float): img = Image.new("RGB", (x, y), "white") output_img = ImageDraw.Draw(img) #font = ImageFont.load_default() - font = ImageFont.truetype("res/fonts/SpaceGrotesk-Light.ttf", 12) + font = ImageFont.truetype("res/fonts/SpaceGrotesk-Light.ttf", 14) + +def get_text_size(text: str): + if not font: + raise Exception("Output image was not initialized! Make sure to call NSD_init first") + return font.getsize(text, direction="ltr") + +def draw_debug_tile(x, y, x_sz, y_sz): + from random import randint + + output_img.rectangle((x, y) + (x + x_sz, y + y_sz), fill=(randint(0, 255))) + return x, y + y_sz def draw_generic_instruction(instruction: str, x, y, xsize, ysize) -> Iterable[float]: if not output_img: raise Exception("Output image was not initialized! Make sure to call NSD_init first") #size shit - #text_y_size = font.getsize(instruction, direction="ltr")[1] - #ysize = max(text_y_size, ysize) # ensure it is alway at least big enought to fit the text + text_y_size = font.getsize(instruction, direction="ltr")[1] + ysize = max(text_y_size, ysize) # ensure the bounding box is alway at least big enought to fit the text #draw shit output_img.rectangle((x,y) + (x + xsize, y + ysize), outline=(0), width=1) @@ -42,42 +53,44 @@ def draw_if_statement(condition: str, x: int, y: int, xsize: int, ysize: int): if not output_img: raise Exception("Output image was not initialized! Make sure to call NSD_init first") - output_img.line((x,y) + (x + xsize / 2, y + ysize / 4), fill=(0)) - output_img.line((x + xsize, y) + (x + xsize / 2, y + ysize / 4), fill=(0)) - output_img.rectangle((x, y + ysize / 4) + (x + xsize, y + ysize), outline=(0), width=1) - output_img.rectangle((x, y) + (x + xsize, y + ysize / 4), outline=(0), width=1) - output_img.line((x + xsize / 2, y + ysize / 4) + (x + xsize / 2, y + ysize), fill=(0)) + text_y_size = font.getsize(condition)[1] + + output_img.line((x,y) + (x + xsize / 2, y + text_y_size), fill=(0)) + output_img.line((x + xsize, y) + (x + xsize / 2, y + text_y_size), fill=(0)) + output_img.rectangle((x, y + text_y_size) + (x + xsize, y + ysize), outline=(0), width=1) + output_img.rectangle((x, y) + (x + xsize, y + text_y_size), outline=(0), width=1) + output_img.line((x + xsize / 2, y + text_y_size) + (x + xsize / 2, y + ysize), fill=(0)) # condition text - output_img.multiline_text((x + xsize / 2, y + ysize * .05 ), condition, fill=(0), font=font, anchor="mm", spacing=4, align='right') + output_img.multiline_text((x + xsize / 2, y + text_y_size), condition, fill=(0), font=font, anchor="md", spacing=4, align='right') # true / false - output_img.text((x + 5, y + ysize * .1875), "true", font = font, fill = (0), anchor="lm") - output_img.text((x + xsize - 5, y + ysize * .1875), "false", font = font, fill = (0), anchor="rm") + output_img.text((x + 5, y + text_y_size), "true", font = font, fill = (0), anchor="ld") + output_img.text((x + xsize - 5, y + text_y_size), "false", font = font, fill = (0), anchor="rd") #first x,y,xsize,ysize of first box then of second first true and then false - return x, y + ysize / 4, xsize / 2, ysize * .75, x + xsize / 2, y + ysize / 4, xsize / 2, ysize * .75 + return x, y + text_y_size, xsize / 2, ysize - text_y_size, x + xsize / 2, y + text_y_size, xsize / 2, ysize - text_y_size def draw_while_loop_front(condition: str, x: int, y: int, xsize: int, ysize: int): if not output_img: raise Exception("Output image was not initialized! Make sure to call NSD_init first") - #ole #TODO + text_y_sz = font.getsize(condition)[1] #the box output_img.line((x,y) + (x + xsize, y), fill=(0)) output_img.line((x,y) + (x, y + ysize), fill=(0)) - output_img.line((x + xsize * .1, y + ysize * .1) + (x + xsize, y + ysize * .1), fill=(0)) - output_img.line((x + xsize, y) + (x + xsize, y + ysize * .1), fill=(0)) + output_img.line((x + xsize * .1, y + text_y_sz) + (x + xsize, y + text_y_sz), fill=(0)) + output_img.line((x + xsize, y) + (x + xsize, y + text_y_sz), fill=(0)) output_img.line((x, y + ysize) + (x + xsize * .1, y + ysize ), fill=(0)) - output_img.line((x + xsize * .1, y + ysize) + (x + xsize * .1, y + ysize * .1), fill=(0)) + output_img.line((x + xsize * .1, y + ysize) + (x + xsize * .1, y + text_y_sz), fill=(0)) #the text - output_img.text((x + xsize * .1, y + ysize * .025), condition, font = font, fill = (0), anchor="lm") + output_img.text((x + xsize * .1, y + text_y_sz * 0.5), condition, font = font, fill = (0), anchor="lm") #the x, y offset then the x,y draw size (the canvas) - return x + xsize * .1, y + ysize * .1, xsize * .9, ysize * .9 + return x + xsize * .1, y + text_y_sz, xsize * .9 def draw_while_loop_back(condition: str, x: int, y: int, xsize: int, ysize: int): diff --git a/interpreter/NassiShneidermann.py b/interpreter/NassiShneidermann.py index 86f0c60..5c27175 100644 --- a/interpreter/NassiShneidermann.py +++ b/interpreter/NassiShneidermann.py @@ -29,7 +29,7 @@ class NassiShneidermanDiagram: cti.NSD_init(x_size, 5000) x, y, x_sz = 0, 0, x_size for _k, instruction in self.instructions.items(): - x, y = instruction.to_image(x, y, x_sz, 800) + x, y = instruction.to_image(x, y, x_sz) cti.NSD_save(filename) def load_from_file(self, filepath:str): diff --git a/res/input/input.java b/res/input/input.java index 79417b2..82b315d 100644 --- a/res/input/input.java +++ b/res/input/input.java @@ -1,29 +1,29 @@ -fahre1(); -fahre2(); -while(shouldNiet()) +// fahre1(); +// fahre2(); +// while(shouldNiet()) -{ - niet4(); - niet5(); - if(if6) - { - niet7(); - niet8(); - } else - { - niet10(); - niet11(); - } - niet13(); -} -niet15(); -niet16(); +// { +// niet4(); +// niet5(); +// if(if6) +// { +// niet7(); +// niet8(); +// } else +// { +// niet10(); +// niet11(); +// } +// niet13(); +// } +// niet15(); +// niet16(); -do{ - niet21(); - niet22(); -}while(bool23); +// do{ +// niet21(); +// niet22(); +// }while(bool23); drehe("links"); while(huegelVorhanden("rechts"))