docs: def draw_onto_canvas(self, export_path: ExportPath, stroke_thickness: int, margin: int, destination_width: int,
                           destination_height: int, staff_line_spacing: int = 14,
                           staff_line_vertical_offsets: List[int] = None,
                           bounding_boxes: dict = None, random_position_on_canvas: bool = False) -> None:
          """
          Draws the symbol onto a canvas with a fixed size
  
          :param bounding_boxes: The dictionary into which the bounding-boxes will be added of each generated image
          :param export_path: The path, where the symbols should be created on disk
          :param stroke_thickness:
          :param margin:
          :param destination_width:
          :param destination_height:
          :param staff_line_spacing:
          :param staff_line_vertical_offsets: Offsets used for drawing staff-lines. If None provided, no staff-lines will be drawn if multiple integers are provided, multiple images will be generated
          """
          width = self.dimensions.width + 2 * margin
          height = self.dimensions.height + 2 * margin
          if random_position_on_canvas:
              # max is required for elements that are larger than the canvas,
              # where the possible range for the random value would be negative
              random_horizontal_offset = random.randint(0, max(0, destination_width - width))
              random_vertical_offset = random.randint(0, max(0, destination_height - height))
              offset = Point2D(self.dimensions.origin.x - margin - random_horizontal_offset,
                               self.dimensions.origin.y - margin - random_vertical_offset)
          else:
              width_offset_for_centering = (destination_width - width) / 2
              height_offset_for_centering = (destination_height - height) / 2
              offset = Point2D(self.dimensions.origin.x - margin - width_offset_for_centering,
                               self.dimensions.origin.y - margin - height_offset_for_centering)
  
          image_without_staff_lines = Image.new('RGB', (destination_width, destination_height),
                                                "white")  # create a new white image
          draw = ImageDraw.Draw(image_without_staff_lines)
          black = (0, 0, 0)
  
          for stroke in self.strokes:
              for i in range(0, len(stroke) - 1):
                  start_point = self.__subtract_offset(stroke[i], offset)
                  end_point = self.__subtract_offset(stroke[i + 1], offset)
                  draw.line((start_point.x, start_point.y, end_point.x, end_point.y), black, stroke_thickness)
  
          location = self.__subtract_offset(self.dimensions.origin, offset)
          bounding_box_in_image = Rectangle(location, self.dimensions.width, self.dimensions.height)
          # self.draw_bounding_box(draw, location)
  
          del draw
  
          if staff_line_vertical_offsets is not None and staff_line_vertical_offsets:
              for staff_line_vertical_offset in staff_line_vertical_offsets:
                  image_with_staff_lines = image_without_staff_lines.copy()
                  self.__draw_staff_lines_into_image(image_with_staff_lines, stroke_thickness,
                                                     staff_line_spacing, staff_line_vertical_offset)
                  file_name_with_offset = export_path.get_full_path(staff_line_vertical_offset)
                  image_with_staff_lines.save(file_name_with_offset)
                  image_with_staff_lines.close()
  
                  if bounding_boxes is not None:
                      # Note that the ImageDatasetGenerator does not yield the full path, but only the class_name and
                      # the file_name, e.g. '3-4-Time\\1-13_3_offset_74.png', so we store only that part in the dictionary
                      class_and_file_name = export_path.get_class_name_and_file_path(staff_line_vertical_offset)
                      bounding_boxes[class_and_file_name] = bounding_box_in_image
          else:
              image_without_staff_lines.save(export_path.get_full_path())
              if bounding_boxes is not None:
                  # Note that the ImageDatasetGenerator does not yield the full path, but only the class_name and
                  # the file_name, e.g. '3-4-Time\\1-13_3_offset_74.png', so we store only that part in the dictionary
                  class_and_file_name = export_path.get_class_name_and_file_path()
                  bounding_boxes[class_and_file_name] = bounding_box_in_image
  
          image_without_staff_lines.close()