src/postprocessing/postprocessing.py

import pandas as pd
import numpy as np
import random
import os
import sys
from xml.dom import minidom
from collections import defaultdict

sys.path.append(os.getcwd())
from src.postprocessing.get_svg_size_pos import get_svg_bbox, get_path_bbox, get_midpoint_of_path_bbox
from src.postprocessing.get_style_attributes import get_style_attributes_path

random.seed(0)

filter_id = 0

def animate_logo(model_output: pd.DataFrame, logo_path: str):
    # Add animation id
    document = minidom.parse(logo_path)

    paths = document.getElementsByTagName('path')
    for i in range(len(paths)):
        paths[i].setAttribute('animation_id', str(i))
    with open(logo_path, 'wb') as svg_file:
        svg_file.write(document.toxml(encoding='iso-8859-1'))

    
    logo_xmin, logo_xmax, logo_ymin, logo_ymax = get_svg_bbox(logo_path)
    # ---- Normalize model output ----
    animations_by_id = defaultdict(list)
    for row in model_output.iterrows():
        # Structure animations by animation id
        animation_id = row[1]['animation_id']
        output = row[1]['model_output']
        animations_by_id[animation_id].append(output)
    total_animations = []
    for animation_id in animations_by_id.keys():
        print(animation_id)
        try:
            path_xmin, path_xmax, path_ymin, path_ymax = get_path_bbox(logo_path, animation_id)
        except:
            path_xmin, path_xmax, path_ymin, path_ymax = 0, 0, 0, 0
        xmin = logo_xmin - path_xmin
        xmax = logo_xmax - path_xmax
        ymin = logo_ymin - path_ymin
        ymax = logo_ymax - path_ymax
        # Structure animations by type (check first 10 parameters)
        animations_by_type = defaultdict(list)
        for animation in animations_by_id[animation_id]:
            if animation[0] == 1:
                # EOS
                continue
            try:
                animation_type = animation[1:10].index(1)
                animations_by_type[animation_type].append(animation)
            except:
                # No value found
                print('Model output invalid: no animation type found')
                return
            
        for animation_type in animations_by_type.keys():
            # Set up list of animations for later distribution
            current_animations = []
            # Sort animations by begin
            animations_by_type[animation_type].sort(key=lambda l : l[10]) # Sort by begin
            # For every animation, check consistency of begin and duration, then set parameters
            for i in range(len(animations_by_type[animation_type])):
                # Check if begin is equal to next animation's begin - in this case, set second begin to average of first and third animation
                # Get next animation with different begin time
                if len(animations_by_type[animation_type]) > 1:
                    j = 1
                    next_animation = animations_by_type[animation_type][j]
                    while (i + j) < len(animations_by_type[animation_type]) and animations_by_type[animation_type][i][10] == next_animation[10]:
                        j += 1
                        next_animation = animations_by_type[animation_type][j]
                    if j != 1:
                        # Get difference
                        difference = animations_by_type[animation_type][j][10] - animations_by_type[animation_type][i][10]
                        interval = difference / (j - i)
                        factor = 0
                        for a in range(i, j):
                            animations_by_type[animation_type][a][10] = animations_by_type[animation_type][i][10] + interval * factor
                            factor += 1
                    # Check if duration and begin of next animation are consistent - if not, shorten duration
                    if i < len(animations_by_type[animation_type]) - 1:
                        max_duration = animations_by_type[animation_type][i+1][10] - animations_by_type[animation_type][i][10]
                        if animations_by_type[animation_type][i][11] > max_duration:
                            animations_by_type[animation_type][i][11] = max_duration

                # Get general parameters
                begin = animations_by_type[animation_type][i][10]
                dur = animations_by_type[animation_type][i][10]
                if dur < 1:
                    dur = 1
                # Check type and call method
                if animation_type == 1:
                    # animation: translate
                    from_x = int(animations_by_type[animation_type][i][12])
                    from_y = int(animations_by_type[animation_type][i][13])
                    # Check if there is a next translate animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next translate animation's starting point
                        to_x = int(animations_by_type[animation_type][i+1][12])
                        to_y = int(animations_by_type[animation_type][i+1][13])
                    else:
                        # animation endpoint is final position of object
                        to_x = 0
                        to_y = 0
                    # Check if parameters are within boundary
                    if from_x < xmin:
                        from_x = xmin
                    elif from_x > xmax:
                        from_x = xmax
                    if from_y < ymin:
                        from_y = ymin
                    elif from_y > ymax:
                        from_y = ymax
                    if to_x < xmin:
                        to_x = xmin
                    elif to_x > xmax:
                        to_x = xmax
                    if to_y < ymin:
                        to_y = ymin
                    elif to_y > ymax:
                        to_y = ymax 
                    # Append animation to list
                    current_animations.append(_animation_translate(animation_id, begin, dur, from_x, from_y, to_x, to_y))
                elif animation_type == 2:
                    print('curve')
                    from_x = int(animations_by_type[animation_type][i][12])
                    from_y = int(animations_by_type[animation_type][i][13])
                    via_x = int(animations_by_type[animation_type][i][14])
                    via_y = int(animations_by_type[animation_type][i][15])
                    # Check if there is a next curve animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next curve animation's starting point
                        to_x = animations_by_type[animation_type][i+1][12]
                        to_y = animations_by_type[animation_type][i+1][13]
                    else:
                        # animation endpoint is final position of object
                        to_x = 0
                        to_y = 0
                    # Check if parameters are within boundary
                    if from_x < xmin:
                        from_x = xmin
                    elif from_x > xmax:
                        from_x = xmax
                    if from_y < ymin:
                        from_y = ymin
                    elif from_y > ymax:
                        from_y = ymax
                    if via_x < xmin:
                        via_x = xmin
                    elif via_x > xmax:
                        via_x = xmax
                    if via_y < ymin:
                        via_y = ymin
                    elif via_y > ymax:
                        via_y = ymax
                    if to_x < xmin:
                        to_x = xmin
                    elif to_x > xmax:
                        to_x = xmax
                    if to_y < ymin:
                        to_y = ymin
                    elif to_y > ymax:
                        to_y = ymax 
                    # Append animation to list
                    current_animations.append(_animation_curve(animation_id, begin, dur, from_x, from_y, via_x, via_y, to_x, to_y))
                elif animation_type == 3:
                    # animation: scale
                    from_f = animations_by_type[animation_type][i][16]
                    if from_f <= 0:
                        from_f = 0.0000001
                    # Check if there is a next scale animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next scale animation's starting point
                        to_f = animations_by_type[animation_type][i+1][16]
                    else:
                        # animation endpoint is final position of object
                        to_f = 1
                    current_animations.append(_animation_scale(animation_id, begin, dur, from_f, to_f))
                elif animation_type == 4:
                    # animation: rotate
                    from_degree = animations_by_type[animation_type][i][17]
                    if from_degree < 0:
                        from_degree = 0
                    elif from_degree > 360:
                        from_degree = 360
                    # Get midpoints
                    midpoints = get_midpoint_of_path_bbox(logo_path, animation_id)
                    # Check if there is a next scale animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next scale animation's starting point
                        to_degree = animations_by_type[animation_type][i+1][17]
                    else:
                        # animation endpoint is final position of object
                        to_degree = 360
                    current_animations.append(_animation_rotate(animation_id, begin, dur, from_degree, to_degree, midpoints))
                elif animation_type == 5:
                    # animation: skewX
                    from_x = int(animations_by_type[animation_type][i][18])
                    # Check if there is a next skewX animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next skewX animation's starting point
                        to_x = int(animations_by_type[animation_type][i+1][18])
                    else:
                        # animation endpoint is final position of object
                        to_x = 1
                    # Check if parameters are within boundary
                    if from_x < xmin:
                        from_x = xmin
                    elif from_x > xmax:
                        from_x = xmax
                    if to_x < xmin:
                        to_x = xmin
                    elif to_x > xmax:
                        to_x = xmax
                    current_animations.append(_animation_skewX(animation_id, begin, dur, from_x, to_x))
                elif animation_type == 6:
                    # animation: skewY
                    from_y = int(animations_by_type[animation_type][i][19])
                    # Check if there is a next skewY animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next skewY animation's starting point
                        to_y = int(animations_by_type[animation_type][i+1][19])
                    else:
                        # animation endpoint is final position of object
                        to_y = 1
                    # Check if parameters are within boundary
                    if from_y < ymin:
                        from_y = ymin
                    elif from_y > ymax:
                        from_y = ymax
                    if to_y < ymin:
                        to_y = ymin
                    elif to_y > ymax:
                        to_y = ymax 
                    current_animations.append(_animation_skewY(animation_id, begin, dur, from_y, to_y))
                elif animation_type == 7:
                    # animation: fill
                    from_rgb = '#' + _convert_to_hex_str(animations_by_type[animation_type][i][20]) + _convert_to_hex_str(animations_by_type[animation_type][i][21]) + _convert_to_hex_str(animations_by_type[animation_type][i][22])
                    # Check if there is a next fill animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next fill animation's starting point
                        to_rgb = '#' + _convert_to_hex_str(animations_by_type[animation_type][i+1][20]) + _convert_to_hex_str(animations_by_type[animation_type][i+1][21]) + _convert_to_hex_str(animations_by_type[animation_type][i+1][22])
                    else:
                        fill_style = get_style_attributes_path(logo_path, animation_id, "fill")
                        stroke_style = get_style_attributes_path(logo_path, animation_id, "stroke")
                        if fill_style == "none" and stroke_style != "none":
                            color_hex = stroke_style
                        else:
                            color_hex = fill_style
                        to_rgb = color_hex
                    current_animations.append(_animation_fill(animation_id, begin, dur, from_rgb, to_rgb))
                elif animation_type == 8:
                    # animation: opacity
                    from_f = animations_by_type[animation_type][i][23] / 100 # percent
                    if from_f < 0:
                        from_f = 0
                    elif from_f > 1:
                        from_f = 1
                    # Check if there is a next opacity animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next opacity animation's starting point
                        to_f = animations_by_type[animation_type][i+1][23] / 100 # percent
                    else:
                        # animation endpoint is final position of object
                        to_f = 1
                    current_animations.append(_animation_opacity(animation_id, begin, dur, from_f, to_f))
                elif animation_type == 9:
                    # animation: blur
                    from_f = animations_by_type[animation_type][i][24]
                    if from_f <= 0:
                        from_f = 1
                    # Check if there is a next blur animation
                    if i < len(animations_by_type[animation_type]) - 1:
                        # animation endpoint is next blur animation's starting point
                        to_f = animations_by_type[animation_type][i+1][24]
                    else:
                        # animation endpoint is final position of object
                        to_f = 1
                    current_animations.append(_animation_blur(animation_id, begin, dur, from_f, to_f))
            total_animations += current_animations
    # Shift begin - TODO test
    min_b = np.inf
    for animation in total_animations:
        print(animation["begin"], min_b)
        if float(animation["begin"]) < float(min_b):
            min_b = animation["begin"]
    for animation in total_animations:
        animation["begin"] = float(animation["begin"]) - float(min_b)

    _insert_animations(total_animations, logo_path, logo_path)

def _convert_to_hex_str(i: int):
    h = str(hex(int(i)))[2:]
    if i < 16:
        h = '0' + h
    return h
        
def _animation_translate(animation_id: int, begin: float, dur: float, from_x: int, from_y: int, to_x: int, to_y: int):
    print('animation: translate')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate_transform'
    animation_dict['attributeName'] = 'transform'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'translate'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = f'{from_x} {from_y}'
    animation_dict['to'] = f'{to_x} {to_y}'
    return animation_dict

def _animation_curve(animation_id: int, begin: float, dur: float, from_x: int, from_y: int, via_x: int, via_y: int, to_x: int, to_y: int):
    print('animation: curve')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate_motion'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = f'{from_x} {from_y}'
    animation_dict['via'] = f'{via_x} {via_y}'
    animation_dict['to'] = f'{to_x} {to_y}'
    return animation_dict

def _animation_scale(animation_id: int, begin: float, dur: float, from_f: float, to_f: float):
    print('animation: scale')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate_transform'
    animation_dict['attributeName'] = 'transform'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'scale'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = str(from_f)
    animation_dict['to'] = str(to_f)
    return animation_dict

def _animation_rotate(animation_id: int, begin: float, dur: float, from_degree: int, to_degree: int, midpoints: list):
    print('animation: rotate')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate_transform'
    animation_dict['attributeName'] = 'transform'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'rotate'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = f'{from_degree} {midpoints[0]} {midpoints[1]}'
    animation_dict['to'] = f'{to_degree} {midpoints[0]} {midpoints[1]}'
    return animation_dict

def _animation_skewX(animation_id: int, begin: float, dur: float, from_i: int, to_i: int):
    print('animation: skew')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate_transform'
    animation_dict['attributeName'] = 'transform'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'skewX'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = f'{from_i}'
    animation_dict['to'] = f'{to_i}'
    return animation_dict

def _animation_skewY(animation_id: int, begin: float, dur: float, from_i: int, to_i: int):
    print('animation: skew')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate_transform'
    animation_dict['attributeName'] = 'transform'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'skewY'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = f'{from_i}'
    animation_dict['to'] = f'{to_i}'
    return animation_dict

def _animation_fill(animation_id: int, begin: float, dur: float, from_rgb: str, to_rgb: str):
    print('animation: fill')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate'
    animation_dict['attributeName'] = 'fill'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'fill'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = from_rgb
    animation_dict['to'] = to_rgb
    return animation_dict

def _animation_opacity(animation_id: int, begin: float, dur: float, from_f: float, to_f: float):
    print('animation: opacity')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate'
    animation_dict['attributeName'] = 'opacity'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'opacity'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = str(from_f)
    animation_dict['to'] = str(to_f)
    return animation_dict

def _animation_blur(animation_id: int, begin: float, dur: float, from_f: float, to_f: float):
    print('animation: blur')
    animation_dict = {}
    animation_dict['animation_id'] = animation_id
    animation_dict['animation_type'] = 'animate_filter'
    animation_dict['attributeName'] = 'transform'
    animation_dict['attributeType'] = 'XML'
    animation_dict['type'] = 'blur'
    animation_dict['begin'] = str(begin)
    animation_dict['dur'] = str(dur)
    animation_dict['fill'] = 'freeze'
    animation_dict['from'] = str(from_f)
    animation_dict['to'] = str(to_f)
    return animation_dict

def _insert_animations(animations: list, path: str, target_path: str):
    print('Insert animations')
    # Load XML
    document = minidom.parse(path)
    # Collect all elements
    elements = document.getElementsByTagName('path') + document.getElementsByTagName('circle') + document.getElementsByTagName(
        'ellipse') + document.getElementsByTagName('line') + document.getElementsByTagName(
        'polygon') + document.getElementsByTagName('polyline') + document.getElementsByTagName(
        'rect') + document.getElementsByTagName('text')
    # Create statement
    for animation in animations:
        
        # Search for element
        current_element = None
        for element in elements:
            if element.getAttribute('animation_id') == str(animation['animation_id']):
                current_element = element
        if current_element == None:
            # Animation id not found - take next animation
            continue
        if animation['animation_type'] == 'animate_transform':
            animate_statement = _create_animate_transform_statement(animation)
            current_element.appendChild(document.createElement(animate_statement))
        elif animation['animation_type'] == 'animate_motion':
            animate_statement = _create_animate_motion_statement(animation)
            current_element.appendChild(document.createElement(animate_statement))
        elif animation['animation_type'] == 'animate':
            animate_statement = _create_animate_statement(animation)
            current_element.appendChild(document.createElement(animate_statement))
        elif animation['animation_type'] == 'animate_filter':
            filter_element, fe_element, animate_statement = _create_animate_filter_statement(animation, document)
            defs = document.getElementsByTagName('defs')
            current_defs = None
            # Check if defs tag exists; create otherwise
            if len(defs) == 0:
                svg = document.getElementsByTagName('svg')[0]
                current_defs = document.createElement('defs')
                svg.appendChild(current_defs)
            else:
                current_defs = defs[0]
            # Check if filter to be appended
            if filter_element != None:
                # Create filter
                print('append filter')
                current_defs.appendChild(filter_element)
            # Check if FE to be created
            if fe_element != None:
                print('create fe statement')
                # Check if filter set; else search
                if filter_element == None:
                    # Search for filter
                    id = 'filter_' + str(animation['animation_id'])
                    for f in document.getElementsByTagName('filter'):
                        if f.getAttribute('id') == id:
                            filter_element = f
                # Create FE
                filter_element.appendChild(fe_element)
            current_defs.appendChild(document.createElement(animate_statement))
            current_element.setAttribute('filter', f'url(#filter_{animation["animation_id"]})')

    # Save XML to target path
    with open(target_path, 'wb') as f:
        f.write(document.toprettyxml(encoding="iso-8859-1"))
        


def _create_animate_transform_statement(animation_dict: dict):
    """ Set up animation statement from model output for ANIMATETRANSFORM animations 
        (Adapted from AnimateSVG)
    """
    animation = f'animateTransform attributeName="transform" attributeType="XML" ' \
                f'type="{animation_dict["type"]}" ' \
                f'begin="{str(animation_dict["begin"])}" ' \
                f'dur="{str(animation_dict["dur"])}" ' \
                f'from="{str(animation_dict["from"])}" ' \
                f'to="{str(animation_dict["to"])}" ' \
                f'fill="{str(animation_dict["fill"])}" ' \
                'additive="sum"'

    return animation

def _create_animate_statement(animation_dict: dict):
    """ Set up animation statement from model output for ANIMATE animations 
        (adapted from AnimateSVG)
    """
    animation = f'animate attributeName="{animation_dict["type"]}" ' \
                f'begin="{str(animation_dict["begin"])}" ' \
                f'dur="{str(animation_dict["dur"])}" ' \
                f'from="{str(animation_dict["from"])}" ' \
                f'to="{str(animation_dict["to"])}" ' \
                f'fill="{str(animation_dict["fill"])}" '\
                'additive="sum"'

    return animation

def _create_animate_motion_statement(animation_dict: dict):
    """ Set up animatie motion statement from model output for ANIMATE_MOTION animations 
    """
    animation = f'animateMotion ' \
                f'begin="{str(animation_dict["begin"])}" ' \
                f'dur="{str(animation_dict["dur"])}" ' \
                f'path="M{animation_dict["from"]}" Q{animation_dict["via"]} {animation_dict["to"]}' \
                f'fill="{str(animation_dict["fill"])}" '\
                'additive="sum"'
    return animation

def _create_animate_filter_statement(animation_dict: dict, document: minidom.Document):
    global filter_id
    filter_id += 1
    filter_element = None
    fe_element = None
    animate_statement = None
    if animation_dict['type'] == 'blur':
        # Check if filter already exists
        filters = document.getElementsByTagName('filter')
        current_filter = None
        current_fe = None
        for f in filters:
            #print(f.getAttribute('id') == f'filter_{str(animation_dict["animation_id"])}')
            if f.getAttribute('id') == f'filter_{str(animation_dict["animation_id"])}':
                current_filter = f
        fe_elements = document.getElementsByTagName('feGaussianBlur')
        for fe in fe_elements:
            if fe.getAttribute('id') == f'filter_blur_{str(animation_dict["animation_id"])}':
                current_fe = fe
        if current_filter == None:
            filter_element = document.createElement('filter')
            filter_element.setAttribute('id', f'filter_{str(animation_dict["animation_id"])}')
        if current_fe == None:
            fe_element = document.createElement('feGaussianBlur')
            fe_element.setAttribute('id', f'filter_blur_{str(animation_dict["animation_id"])}')
            fe_element.setAttribute('stdDeviation', '0')
        animate_statement = f'animate href="#filter_blur_{str(animation_dict["animation_id"])}" ' \
                f'attributeName="stdDeviation" ' \
                f'begin="{str(animation_dict["begin"])}" ' \
                f'dur="{str(animation_dict["dur"])}" ' \
                f'from="{str(animation_dict["from"])}" ' \
                f'to="{str(animation_dict["to"])}" ' \
                f'fill="{str(animation_dict["fill"])}"'\
                'additive="sum"'
    return filter_element, fe_element, animate_statement








def randomly_animate_logo(logo_path: str, target_path: str, number_of_animations: int, previously_generated: pd.DataFrame = None):
    # Creates model output equal to defined number of animations. They are then randomly distributed over the paths.
    # Assign animation id to every path - TODO this changes the original logo!
    document = minidom.parse(logo_path)
    paths = document.getElementsByTagName('path') + document.getElementsByTagName('circle') + document.getElementsByTagName(
        'ellipse') + document.getElementsByTagName('line') + document.getElementsByTagName(
        'polygon') + document.getElementsByTagName('polyline') + document.getElementsByTagName(
        'rect') + document.getElementsByTagName('text')
    for i in range(len(paths)):
        paths[i].setAttribute('animation_id', str(i))
    with open(target_path, 'wb') as svg_file:
        svg_file.write(document.toxml(encoding='iso-8859-1'))
    # Create random animations
    for i in range(0, number_of_animations):
        animation_type = random.randint(0, 8) # Determine animation type (as of now only primitive animation types)
        model_output = np.zeros(18)
        model_output[animation_type] = 1 # Set animation type
        # Set animation parameters
        
    
    
    


# model_output = [
#     {
#         'animation_id': 1,
#         'model_output': [0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10]
#     },
#     {
#         'animation_id': 1,
#         'model_output': [0, 0, 0, 0, 0, 0, 0, 1, 5, 3, 4, 5, 2, 1, 2, 3, 4, 5, 6, 7, 1000, 20]
#     }
# ]
# model_output = pd.DataFrame(model_output)
# #print(model_output)
# path = 'src/postprocessing/logo_0.svg'
# # Assign animation id to every path - TODO this changes the original logo!
# document = minidom.parse(path)
# paths = document.getElementsByTagName('path')
# for i in range(len(paths)):
#     paths[i].setAttribute('animation_id', str(i))
# with open(path, 'wb') as svg_file:
#     svg_file.write(document.toxml(encoding='iso-8859-1'))
# #print('Inserted animation id')
# animate_logo(model_output, path)