def pillow(values: dict, step_data: StepData, prev_paths: dict):
"""
Erstellt ein Bild mit Hilfe der Python-Bibliothek Pillow.
Dazu wird ein neues Bild geöffnet oder ein bisher erstelltes Bild weiter bearbeitet.
In der JSON können beliebige viele Overlays angegeben werden, welche diese Methode alle
ausführt und auf das Bild setzt.
:param values: Image-Bauplan des zu erstellenden Bildes
:param step_data: Daten aus der API
:param prev_paths: alle Image-Baupläne und somit auch alle Pfade zu den bisher erstellten Bildern
:return: Pfad zum erstellten Bild
:rtype: str
"""
if values.get("path", None) is None:
image_name = step_data.format(values["image_name"])
source_img = Image.open(
resources.get_resource_path(prev_paths[image_name]))
else:
path = step_data.format(values["path"])
source_img = Image.open(resources.get_image_path(path))
img1 = Image.new("RGBA", source_img.size)
draw = ImageDraw.Draw(source_img)
for overlay in values["overlay"]:
over_func = get_type_func(overlay, OVERLAY_TYPES)
over_func(overlay, step_data, source_img, prev_paths, draw)
file = resources.new_temp_resource_path(step_data.data["_pipe_id"], "png")
Image.composite(img1, source_img, img1).save(file)
return file
def precondition(values: dict, step_data: StepData):
if values.get("precondition", None):
if step_data.get_config("testing", False) is False:
api_func = get_type_func(values["precondition"],
Precondition_TYPES)
api_func(values, step_data)
def audio_parts(values, data):
return_string = ""
for value in values:
return_value = get_type_func(value, AUDIO_PARTS_TYPES)(value, data)
if not return_value[1]:
return "", False
return_string = return_string + return_value[0]
return return_string, True
def api_request(values: dict,
data: StepData,
name: str,
save_key,
ignore_testing=False):
api_func = get_type_func(values, API_TYPES)
api_func(values, data, name, save_key, ignore_testing)
def calculate(values: dict, data: StepData):
"""Berechnet die angegebene `"action"`.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
"""
action_func = get_type_func(values, CALCULATE_ACTIONS, "action")
action_func(values, data)
def link(values: dict, step_data: StepData):
"""Überprüft, welcher Typ der Video-Generierung vorliegt und ruft die passende Typ-Methode auf.
:param values: Werte aus der JSON-Datei
:param step_data: Daten aus der API
:return: Pfad zum Output-Video
:rtype: str
"""
out_images, out_audios, out_audio_l = [], [], []
attach_mode = step_data.get_config("attach_mode", "")
seq_func = get_type_func(values["sequence"], SEQUENCE_TYPES)
seq_func(values, step_data, out_images, out_audios, out_audio_l)
if step_data.get_config("attach", None) is not None and not attach_mode:
if not step_data.get_config("separate_rendering", False):
for item in step_data.get_config("attach", None):
pipeline = init_pipeline(step_data, step_data.data["_pipe_id"], item["steps"],
config=item.get("config", {}),
no_tmp_dir=True)
pipeline.start()
# Add images and audios from the pipeline
extend_out_config(pipeline.config["sequence"], out_images, out_audios, out_audio_l)
_generate(out_images, out_audios, out_audio_l, step_data, values)
else:
# Save and manipulate out path (to save video to tmp dir)
out_path = step_data.get_config("output_path")
step_data.data["_conf"]["output_path"] = get_relative_temp_resource_path("", step_data.data["_pipe_id"])
_generate(out_images, out_audios, out_audio_l, step_data, values)
# Resote out_path
step_data.data["_conf"]["output_path"] = out_path
sequence_out = [values["sequence"]]
for idx, item in enumerate(step_data.get_config("attach", None)):
pipeline = init_pipeline(step_data, uuid.uuid4().hex, item["steps"], idx, item.get("config", {}))
pipeline.start()
sequence_out.append(pipeline.config["sequence"])
_combine(sequence_out, step_data, values)
else:
if attach_mode == "combined":
values["sequence"] = {
"out_images": out_images,
"out_audios": out_audios,
"out_audio_l": out_audio_l
}
else:
_generate(out_images, out_audios, out_audio_l, step_data, values)
def new(values: dict, step_data: StepData):
"""Erstellt ein neues Bild, welches als Thumbnail für das zu erstellende Video verwendet wird.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
image_func = get_type_func(values["thumbnail"]["image"], IMAGE_TYPES)
src_file = image_func(values["thumbnail"]["image"], step_data,
values["images"])
_copy_and_rename(src_file, values, step_data)
def transform(values: dict, data: StepData):
"""Führt die unter `"type"` angegebene transform-Funktion als Schleife aus.
:param values: Werte aus der JSON-Datei
:param data: Daten aus der API
:return:
"""
for transformation in values["transform"]:
transformation["_loop_states"] = values.get("_loop_states", {})
trans_func = get_type_func(transformation, TRANSFORM_TYPES)
trans_func(transformation, data)
def generate_all_images(values: dict, step_data: StepData):
"""
Durchläuft jedes Bild in values (in der JSON), überprüft welcher Typ des Bildes vorliegt und ruft die
passende Typ-Methode auf. Nach der Erstellung der Bilder wird der Bauplan des Bilder (in values) mit dem Bildpfad ersetzt.
:param values: Werte aus der JSON-Datei
:param step_data: Daten aus der API
"""
for key, item in enumerate(values["images"]):
image_func = get_type_func(values["images"][item], IMAGE_TYPES)
values["images"][item] = image_func(values["images"][item], step_data,
values["images"])
def thumbnail(values: dict, step_data: StepData):
if step_data.get_config("thumbnail", False) is False:
return
thumbnail = values["thumbnail"]
seq_func = get_type_func(values["thumbnail"], THUMBNAIL_TYPES)
seq_func(values, step_data)
if "size_x" in thumbnail and "size_y" in thumbnail:
size_x = step_data.get_data(thumbnail["size_x"], None, numbers.Number)
size_y = step_data.get_data(thumbnail["size_y"], None, numbers.Number)
source_img = Image.open(values["thumbnail"])
source_img = source_img.resize([size_x, size_y], Image.LANCZOS)
source_img.save(values["thumbnail"])
def option(values: dict, step_data: StepData, source_img, prev_paths, draw):
"""
Methode, welche zwei verschiedene Baupläne bekommt, was auf ein Bild geschrieben werden soll. Dazu
wird ein boolean-Wert in der step_data ausgewertet und je nachdem, ob dieser Wert
`true` oder `false` ist, wird entweder Bauplan A oder Bauplan B ausgeführt.
:param values: Baupläne des zu schreibenden Overlays
:param step_data: Daten aus der API
:param source_img: Bild, auf welches geschrieben werden soll
:param prev_paths: Alle Image-Baupläne und somit auch alle Pfade zu den bisher erstellen Bildern
:param draw: Draw-Objekt
"""
chosen_text = execute_type_option(values, step_data)
for overlay in chosen_text:
over_func = get_type_func(overlay, OVERLAY_TYPES)
over_func(overlay, step_data, source_img, prev_paths, draw)
def compare(values: dict, step_data: StepData, source_img, prev_paths, draw):
"""
Methode, welche verschiedene Baupläne bekommt was auf ein Bild geschrieben werden soll. Dazu
werden zwei Werte miteinander verglichen und je nachdem ob der `value_left` =, !=, > oder < als `value_right` ist,
werden unterscheidliche Baupläne ausgeführt.
:param values: Baupläne des zu schreibenden Overlays
:param step_data: Daten aus der API
:param source_img: Bild, auf welches geschrieben werden soll
:param prev_paths: Alle Image-Baupläne und somit auch alle Pfade zu den bisher erstellen Bildern
:param draw: Draw-Objekt
"""
chosen_text = execute_type_compare(values, step_data)
for overlay in chosen_text:
over_func = get_type_func(overlay, OVERLAY_TYPES)
over_func(overlay, step_data, source_img, prev_paths, draw)
def generate_all_diagrams(values: dict, step_data: StepData):
"""
Durchläuft jedes Bild in values (in der JSON), überprüft welcher Typ des Bildes vorliegt und ruft die
passende Typ-Methode auf. Nach der Erstellung der Bilder wird der Bauplan des Bilder (in values) mit dem Bildpfad ersetzt.
:param values: Werte aus der JSON-Datei
:param step_data: Daten aus der API
"""
if not values.get("diagrams", None):
# continue, if the step 'diagrams' does not exist (for old stepdata-files)
return
for key, item in enumerate(values["diagrams"]):
diagram_func = get_type_func(values["diagrams"][item], DIAGRAM_TYPES)
values["diagrams"][item] = diagram_func(values["diagrams"][item],
step_data, values["diagrams"])
def text(overlay: dict, step_data: StepData, source_img, prev_paths, draw):
"""
Methode, um Text auf ein gegebenes Bild zu schreiben mit dem Bauplan, der in overlay vorgegeben ist.
:param overlay: Bauplan des zu schreibenden Overlays
:param step_data: Daten aus der API
:param source_img: Bild, auf welches geschrieben werden soll
:param prev_paths: Alle Image-Baupläne und somit auch alle Pfade zu den bisher erstellen Bildern
:param draw: Draw-Objekt
"""
content = step_data.format(overlay["pattern"])
draw_func = get_type_func(overlay, DRAW_TYPES, "anchor_point")
draw_func(draw,
(step_data.get_data(overlay["pos_x"], None, numbers.Number),
step_data.get_data(overlay["pos_y"], None, numbers.Number)),
content,
step_data.get_data(overlay["font_size"], None, numbers.Number),
step_data.format(overlay["color"]),
step_data.format(overlay["font"]), overlay.get("width", None))
def generate_audios(values: dict, data: StepData):
config: dict = _get_audio_config(values, data)
audio_func = get_type_func(config, GENERATE_AUDIO_TYPES)
audio_func(values["audio"]["audios"], data, config)
