add model files

AnimationTransformer.py

@@ -0,0 +1,272 @@
+import math
+import time
+
+import torch
+import torch.nn as nn
+
+import dataset_helper
+
+
+class AnimationTransformer(nn.Module):
+    def __init__(
+            self,
+            dim_model,  # hidden_size; corresponds to embedding length
+            num_heads,
+            num_encoder_layers,
+            num_decoder_layers,
+            dropout_p,
+            use_positional_encoder=True
+    ):
+        super().__init__()
+
+        self.model_type = "Transformer"
+        self.dim_model = dim_model
+
+        # TODO: Currently left out, as input sequence shuffled. Later check if use is beneficial.
+        self.use_positional_encoder = use_positional_encoder
+        self.positional_encoder = PositionalEncoding(
+            dim_model=dim_model,
+            dropout_p=dropout_p
+        )
+
+        self.transformer = nn.Transformer(
+            d_model=dim_model,
+            nhead=num_heads,
+            num_encoder_layers=num_encoder_layers,
+            num_decoder_layers=num_decoder_layers,
+            dropout=dropout_p,
+            batch_first=True
+        )
+
+    def forward(self, src, tgt, tgt_mask=None, src_key_padding_mask=None, tgt_key_padding_mask=None):
+        # Src size must be (batch_size, src sequence length)
+        # Tgt size must be (batch_size, tgt sequence length)
+
+        if self.use_positional_encoder:
+            src = self.positional_encoder(src)
+            tgt = self.positional_encoder(tgt)
+
+        # Transformer blocks - Out size = (sequence length, batch_size, num_tokens)
+        out = self.transformer(src, tgt, tgt_mask=tgt_mask, src_key_padding_mask=src_key_padding_mask,
+                               tgt_key_padding_mask=tgt_key_padding_mask)
+        return out
+
+
+def get_tgt_mask(size) -> torch.tensor:
+    # Generates a square matrix where each row allows one word more to be seen
+    mask = torch.tril(torch.ones(size, size) == 1)  # Lower triangular matrix
+    mask = mask.float()
+    mask = mask.masked_fill(mask == 0, float('-inf'))  # Convert zeros to -inf
+    mask = mask.masked_fill(mask == 1, float(0.0))  # Convert ones to 0
+
+    # EX for size=5:
+    # [[0., -inf, -inf, -inf, -inf],
+    #  [0.,   0., -inf, -inf, -inf],
+    #  [0.,   0.,   0., -inf, -inf],
+    #  [0.,   0.,   0.,   0., -inf],
+    #  [0.,   0.,   0.,   0.,   0.]]
+
+    return mask
+
+
+def create_pad_mask(matrix: torch.tensor) -> torch.tensor:
+    pad_masks = []
+
+    # Iterate over each sequence in the batch.
+    for i in range(0, matrix.size(0)):
+        sequence = []
+
+        # Iterate over each element in the sequence and append True if padding value
+        for j in range(0, matrix.size(1)):
+            sequence.append(matrix[i, j, 0] == dataset_helper.PADDING_VALUE)
+
+        pad_masks.append(sequence)
+
+    #print("matrix", matrix, matrix.shape, "pad_mask", pad_masks)
+    return torch.tensor(pad_masks)
+
+
+def _transformer_call_in_loops(model, batch, device, loss_function):
+    source, target = batch[0], batch[1]
+    source, target = source.to(device), target.to(device)
+
+    # First index is all batch entries, second is
+    target_input = target[:, :-1]  # trg input is offset by one (SOS token and excluding EOS)
+    target_expected = target[:, 1:]  # trg is offset by one (excluding SOS token)
+
+    # SOS -  1  -  2  -  3  -  4  - EOS - PAD - PAD // target_input
+    #  1  -  2  -  3  -  4  - EOS - PAD - PAD - PAD // target_expected
+
+    # Get mask to mask out the next words
+    tgt_mask = get_tgt_mask(target_input.size(1)).to(device)
+
+    # Standard training except we pass in y_input and tgt_mask
+    prediction = model(source, target_input,
+                       tgt_mask=tgt_mask,
+                       src_key_padding_mask=create_pad_mask(source).to(device),
+                       # Mask with expected as EOS is no input (see above)
+                       tgt_key_padding_mask=create_pad_mask(target_expected).to(device))
+
+    return loss_function(prediction, target_expected, create_pad_mask(target_expected).to(device))
+    #return loss_function(prediction, target_expected)
+
+def train_loop(model, opt, loss_function, dataloader, device):
+    model.train()
+    total_loss = 0
+
+    t0 = time.time()
+    i = 1
+    for batch in dataloader:
+        loss = _transformer_call_in_loops(model, batch, device, loss_function)
+
+        opt.zero_grad()
+        loss.backward()
+        opt.step()
+
+        total_loss += loss.detach().item()
+
+        if i == 1 or i % 10 == 0:
+            elapsed_time = time.time() - t0
+            total_expected = elapsed_time / i * len(dataloader)
+            print(f">> {i}: Time per Batch {elapsed_time / i : .2f}s | "
+                  f"Total expected {total_expected / 60 : .2f} min | "
+                  f"Remaining {(total_expected - elapsed_time) / 60 : .2f} min ")
+        i += 1
+
+    print(f">> Epoch time: {(time.time() - t0)/60:.2f} min")
+    return total_loss / len(dataloader)
+
+
+def validation_loop(model, loss_function, dataloader, device):
+    model.eval()
+    total_loss = 0
+
+    with torch.no_grad():
+        for batch in dataloader:
+            loss = _transformer_call_in_loops(model, batch, device, loss_function)
+
+            total_loss += loss.detach().item()
+
+    return total_loss / len(dataloader)
+
+
+def fit(model, optimizer, loss_function, train_dataloader, val_dataloader, epochs, device):
+    train_loss_list, validation_loss_list = [], []
+
+    print("Training and validating model")
+    for epoch in range(epochs):
+        print("-" * 25, f"Epoch {epoch + 1}", "-" * 25)
+
+        train_loss = train_loop(model, optimizer, loss_function, train_dataloader, device)
+        train_loss_list += [train_loss]
+
+        validation_loss = validation_loop(model, loss_function, val_dataloader, device)
+        validation_loss_list += [validation_loss]
+
+        print(f"Training loss: {train_loss:.4f}")
+        print(f"Validation loss: {validation_loss:.4f}")
+        print()
+
+    return train_loss_list, validation_loss_list
+
+
+def predict(model, source_sequence, sos_token: torch.Tensor, device, max_length=32, eos_scaling=1, backpropagate=False, showResult= True):
+    if backpropagate:
+        model.train()
+    else:
+        model.eval()
+
+    source_sequence = source_sequence.float().to(device)
+    y_input = torch.unsqueeze(sos_token, dim=0).float().to(device)
+
+    i = 0
+    while i < max_length:
+        # Get source mask
+        prediction = model(source_sequence.unsqueeze(0), y_input.unsqueeze(0),  # un-squeeze for batch
+                           # tgt_mask=get_tgt_mask(y_input.size(0)).to(device),
+                           src_key_padding_mask=create_pad_mask(source_sequence.unsqueeze(0)).to(device))
+
+        next_embedding = prediction[0, -1, :]  # prediction on last token
+        pred_deep_svg, pred_type, pred_parameters = dataset_helper.unpack_embedding(next_embedding, dim=0)
+        #print(pred_deep_svg, pred_type, pred_parameters)
+        pred_deep_svg, pred_type, pred_parameters = pred_deep_svg.to(device), pred_type.to(device), pred_parameters.to(
+            device)
+
+        # === TYPE ===
+        # Apply Softmax
+        type_softmax = torch.softmax(pred_type, dim=0)
+        type_softmax[0] = type_softmax[0] * eos_scaling  # Reduce EOS
+        animation_type = torch.argmax(type_softmax, dim=0)
+
+        # Break if EOS is most likely
+        if animation_type == 0:
+            print("END OF ANIMATION")
+            y_input = torch.cat((y_input, sos_token.unsqueeze(0).to(device)), dim=0)
+            return y_input
+
+        pred_type = torch.zeros(11)
+        pred_type[animation_type] = 1
+
+        # === DEEP SVG ===
+        # Find the closest path
+        distances = [torch.norm(pred_deep_svg - embedding[:-26]) for embedding in source_sequence]
+        closest_index = distances.index(min(distances))
+        closest_token = source_sequence[closest_index]
+
+        # === PARAMETERS ===
+        # overwrite unused parameters
+        for j in range(len(pred_parameters)):
+            if j in dataset_helper.ANIMATION_PARAMETER_INDICES[int(animation_type)]:
+                continue
+            pred_parameters[j] = -1
+
+        # === SEQUENCE ===
+        y_new = torch.concat([closest_token[:-26], pred_type.to(device), pred_parameters], dim=0)
+        y_input = torch.cat((y_input, y_new.unsqueeze(0)), dim=0)
+
+        # === INFO PRINT ===
+        if showResult:
+            print(f"{int(y_input.size(0))}: Path {closest_index} ({round(float(distances[closest_index]), 3)}) "
+                f"got animation {animation_type} ({round(float(type_softmax[animation_type]), 3)}%) "
+                f"with parameters {[round(num, 2) for num in pred_parameters.tolist()]}")
+
+        i += 1
+
+    return y_input
+
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, dim_model, dropout_p, max_len=5000):
+        """
+        Initializes the PositionalEncoding module which injects information about the relative or absolute position
+        of the tokens in the sequence. The positional encodings have the same dimension as the embeddings so that the
+        two can be summed. Uses a sinusoidal pattern for positional encoding.
+
+        Args:
+            dim_model (int): The dimension of the embeddings and the expected dimension of the positional encoding.
+            dropout_p (float): Dropout probability to be applied to the summed embeddings and positional encodings.
+            max_len (int): The max length of the sequences for which positional encodings are precomputed and stored.
+        """
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout_p)
+
+        position = torch.arange(max_len).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, dim_model, 2).float() * (-math.log(10000.0) / dim_model))
+        pos_encoding = torch.zeros(max_len, 1, dim_model)
+        pos_encoding[:, 0, 0::2] = torch.sin(position * div_term)
+        pos_encoding[:, 0, 1::2] = torch.cos(position * div_term)
+
+        self.register_buffer('pos_encoding', pos_encoding)
+
+    def forward(self, embedding: torch.Tensor) -> torch.Tensor:
+        """
+        Applies positional encoding to the input embeddings and applies dropout.
+
+        Args:
+            embedding (torch.Tensor): The input embeddings with shape [batch_size, seq_len, dim_model]
+
+        Returns:
+            torch.Tensor: The embeddings with positional encoding applied, and dropout, having the same shape as the
+            input token embeddings [seq_len, batch_size, dim_model].
+        """
+        return self.dropout(embedding + self.pos_encoding[:embedding.size(0), :])

models/animation_transformer.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12ae92d0b1a5ada8a8681122f76ea7c4e6b3fdf0169dd4b3a5d908899e563f86
+size 60658902

models/reward_function_mode_state_dict.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49ea58f01ad6a281e005b9b2793e53f901037402c96411f444ed9630fff05fbf
+size 111027985

src/postprocessing/get_style_attributes.py

@@ -0,0 +1,318 @@
+from svgpathtools import svg2paths
+import pandas as pd
+import numpy as np
+from xml.dom import minidom
+
+pd.options.mode.chained_assignment = None  # default='warn'
+
+
+def get_style_attributes_svg(file):
+    """ Get style attributes of an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+        pd.DataFrame: Dataframe containing the attributes of each path.
+
+    """
+    local_styles = get_local_style_attributes(file)
+    global_styles = get_global_style_attributes(file)
+    global_group_styles = get_global_group_style_attributes(file)
+    return combine_style_attributes(local_styles, global_styles, global_group_styles)
+
+
+def get_style_attributes_path(file, animation_id, attribute):
+    """ Get style attributes of a specific path in an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_id (int): ID of element.
+        attribute (str): One of the following: fill, stroke, stroke_width, opacity, stroke_opacity.
+
+    Returns:
+        str: Attribute of specific path.
+
+    """
+    styles = get_style_attributes_svg(file)
+    styles_animation_id = styles[styles["animation_id"] == str(animation_id)]
+    return styles_animation_id.iloc[0][attribute]
+
+
+def parse_svg(file):
+    """ Parse a SVG file.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+        list, list: List of path objects, list of dictionaries containing the attributes of each path.
+
+    """
+    paths, attrs = svg2paths(file)
+    return paths, attrs
+
+
+def get_local_style_attributes(file):
+    """ Generate dataframe containing local style attributes of an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+        pd.DataFrame: Dataframe containing filename, animation_id, class, fill, stroke, stroke_width, opacity, stroke_opacity.
+
+    """
+    return pd.DataFrame.from_records(_get_local_style_attributes(file))
+
+
+def _get_local_style_attributes(file):
+    try:
+        _, attributes = parse_svg(file)
+    except:
+        print(f'{file}: Attributes not defined.')
+    for i, attr in enumerate(attributes):
+        animation_id = attr['animation_id']
+        class_ = ''
+        fill = '#000000'
+        stroke = '#000000'
+        stroke_width = '0'
+        opacity = '1.0'
+        stroke_opacity = '1.0'
+
+        if 'style' in attr:
+            a = attr['style']
+            if a.find('fill') != -1:
+                fill = a.split('fill:', 1)[-1].split(';', 1)[0]
+            if a.find('stroke') != -1:
+                stroke = a.split('stroke:', 1)[-1].split(';', 1)[0]
+            if a.find('stroke-width') != -1:
+                stroke_width = a.split('stroke-width:', 1)[-1].split(';', 1)[0]
+            if a.find('opacity') != -1:
+                opacity = a.split('opacity:', 1)[-1].split(';', 1)[0]
+            if a.find('stroke-opacity') != -1:
+                stroke_opacity = a.split('stroke-opacity:', 1)[-1].split(';', 1)[0]
+        else:
+            if 'fill' in attr:
+                fill = attr['fill']
+            if 'stroke' in attr:
+                stroke = attr['stroke']
+            if 'stroke-width' in attr:
+                stroke_width = attr['stroke-width']
+            if 'opacity' in attr:
+                opacity = attr['opacity']
+            if 'stroke-opacity' in attr:
+                stroke_opacity = attr['stroke-opacity']
+
+        if 'class' in attr:
+            class_ = attr['class']
+
+        # transform None and RGB to hex
+        if '#' not in fill and fill != '':
+            fill = transform_to_hex(fill)
+        if '#' not in stroke and stroke != '':
+            stroke = transform_to_hex(stroke)
+
+        yield dict(filename=file.split('.svg')[0], animation_id=animation_id, class_=class_, fill=fill, stroke=stroke,
+                   stroke_width=stroke_width, opacity=opacity, stroke_opacity=stroke_opacity)
+
+
+def get_global_style_attributes(file):
+    """ Generate dataframe containing global style attributes of an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+        pd.DataFrame: Dataframe containing filename, class, fill, stroke, stroke_width, opacity, stroke_opacity.
+
+    """
+    return pd.DataFrame.from_records(_get_global_style_attributes(file))
+
+
+def _get_global_style_attributes(file):
+    doc = minidom.parse(file)
+    style = doc.getElementsByTagName('style')
+    for i, attr in enumerate(style):
+        a = attr.toxml()
+        for j in range(0, len(a.split(';}')) - 1):
+            fill = ''
+            stroke = ''
+            stroke_width = ''
+            opacity = ''
+            stroke_opacity = ''
+            attr = a.split(';}')[j]
+            class_ = attr.split('.', 1)[-1].split('{', 1)[0]
+            if attr.find('fill:') != -1:
+                fill = attr.split('fill:', 1)[-1].split(';', 1)[0]
+            if attr.find('stroke:') != -1:
+                stroke = attr.split('stroke:', 1)[-1].split(';', 1)[0]
+            if attr.find('stroke-width:') != -1:
+                stroke_width = attr.split('stroke-width:', 1)[-1].split(';', 1)[0]
+            if attr.find('opacity:') != -1:
+                opacity = attr.split('opacity:', 1)[-1].split(';', 1)[0]
+            if attr.find('stroke-opacity:') != -1:
+                stroke_opacity = attr.split('stroke-opacity:', 1)[-1].split(';', 1)[0]
+
+            # transform None and RGB to hex
+            if '#' not in fill and fill != '':
+                fill = transform_to_hex(fill)
+            if '#' not in stroke and stroke != '':
+                stroke = transform_to_hex(stroke)
+
+            yield dict(filename=file.split('.svg')[0], class_=class_, fill=fill, stroke=stroke,
+                       stroke_width=stroke_width, opacity=opacity, stroke_opacity=stroke_opacity)
+
+
+def get_global_group_style_attributes(file):
+    """ Generate dataframe containing global style attributes defined through <g> tags of an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+        pd.DataFrame: Dataframe containing filename, href, animation_id, fill, stroke, stroke_width, opacity, stroke_opacity.
+
+    """
+    df_group_animation_id_matching = pd.DataFrame.from_records(_get_group_animation_id_matching(file))
+
+    df_group_attributes = pd.DataFrame.from_records(_get_global_group_style_attributes(file))
+    df_group_attributes.drop_duplicates(inplace=True)
+    df_group_attributes.replace("", float("NaN"), inplace=True)
+    df_group_attributes.dropna(thresh=3, inplace=True)
+
+    if "href" in df_group_attributes.columns:
+        df_group_attributes.dropna(subset=["href"], inplace=True)
+
+    if df_group_attributes.empty:
+        return df_group_attributes
+    else:
+        return df_group_animation_id_matching.merge(df_group_attributes, how='left', on=['filename', 'href'])
+
+
+def _get_global_group_style_attributes(file):
+    doc = minidom.parse(file)
+    groups = doc.getElementsByTagName('g')
+    for i, _ in enumerate(groups):
+        style = groups[i].getAttribute('style')
+        href = ''
+        fill = ''
+        stroke = ''
+        stroke_width = ''
+        opacity = ''
+        stroke_opacity = ''
+        if len(groups[i].getElementsByTagName('use')) != 0:
+            href = groups[i].getElementsByTagName('use')[0].getAttribute('xlink:href')
+            if style != '':
+                attributes = style.split(';')
+                for j, _ in enumerate(attributes):
+                    attr = attributes[j]
+                    if attr.find('fill:') != -1:
+                        fill = attr.split('fill:', 1)[-1].split(';', 1)[0]
+                    if attr.find('stroke:') != -1:
+                        stroke = attr.split('stroke:', 1)[-1].split(';', 1)[0]
+                    if attr.find('stroke-width:') != -1:
+                        stroke_width = attr.split('stroke-width:', 1)[-1].split(';', 1)[0]
+                    if attr.find('opacity:') != -1:
+                        opacity = attr.split('opacity:', 1)[-1].split(';', 1)[0]
+                    if attr.find('stroke-opacity:') != -1:
+                        stroke_opacity = attr.split('stroke-opacity:', 1)[-1].split(';', 1)[0]
+            else:
+                fill = groups[i].getAttribute('fill')
+                stroke = groups[i].getAttribute('stroke')
+                stroke_width = groups[i].getAttribute('stroke-width')
+                opacity = groups[i].getAttribute('opacity')
+                stroke_opacity = groups[i].getAttribute('stroke-opacity')
+
+        # transform None and RGB to hex
+        if '#' not in fill and fill != '':
+            fill = transform_to_hex(fill)
+        if '#' not in stroke and stroke != '':
+            stroke = transform_to_hex(stroke)
+
+        yield dict(filename=file.split('.svg')[0], href=href.replace('#', ''), fill=fill, stroke=stroke,
+                   stroke_width=stroke_width, opacity=opacity, stroke_opacity=stroke_opacity)
+
+
+def _get_group_animation_id_matching(file):
+    doc = minidom.parse(file)
+    try:
+        symbol = doc.getElementsByTagName('symbol')
+        for i, _ in enumerate(symbol):
+            href = symbol[i].getAttribute('id')
+            animation_id = symbol[i].getElementsByTagName('path')[0].getAttribute('animation_id')
+            yield dict(filename=file.split('.svg')[0], href=href, animation_id=animation_id)
+    except:
+        defs = doc.getElementsByTagName('defs')
+        for i, _ in enumerate(defs):
+            href = defs[i].getElementsByTagName('symbol')[0].getAttribute('id')
+            animation_id = defs[i].getElementsByTagName('clipPath')[0].getElementsByTagName('path')[0].getAttribute('animation_id')
+            yield dict(filename=file.split('.svg')[0], href=href, animation_id=animation_id)
+
+
+def combine_style_attributes(df_local, df_global, df_global_groups):
+    """ Combine local und global style attributes. Global attributes have priority.
+
+    Args:
+        df_local (pd.DataFrame): Dataframe with local style attributes.
+        df_global (pd.DataFrame): Dataframe with global style attributes.
+        df_global_groups (pd.DataFrame): Dataframe with global style attributes defined through <g> tags.
+
+    Returns:
+        pd.DataFrame: Dataframe with all style attributes.
+
+    """
+    if df_global.empty and df_global_groups.empty:
+        df_local.insert(loc=3, column='href', value="")
+        return df_local
+
+    if not df_global.empty:
+        df = df_local.merge(df_global, how='left', on=['filename', 'class_'])
+        df_styles = df[["filename", "animation_id", "class_"]]
+        df_styles["fill"] = _combine_columns(df, "fill")
+        df_styles["stroke"] = _combine_columns(df, "stroke")
+        df_styles["stroke_width"] = _combine_columns(df, "stroke_width")
+        df_styles["opacity"] = _combine_columns(df, "opacity")
+        df_styles["stroke_opacity"] = _combine_columns(df, "stroke_opacity")
+        df_local = df_styles.copy(deep=True)
+    if not df_global_groups.empty:
+        df = df_local.merge(df_global_groups, how='left', on=['filename', 'animation_id'])
+        df_styles = df[["filename", "animation_id", "class_", "href"]]
+        df_styles["href"] = df_styles["href"].fillna('')
+        df_styles["fill"] = _combine_columns(df, "fill")
+        df_styles["stroke"] = _combine_columns(df, "stroke")
+        df_styles["stroke_width"] = _combine_columns(df, "stroke_width")
+        df_styles["opacity"] = _combine_columns(df, "opacity")
+        df_styles["stroke_opacity"] = _combine_columns(df, "stroke_opacity")
+
+    return df_styles
+
+
+def _combine_columns(df, col_name):
+    col = np.where(~df[f"{col_name}_y"].astype(str).isin(["", "nan"]),
+                   df[f"{col_name}_y"], df[f"{col_name}_x"])
+    return col
+
+
+def transform_to_hex(rgb):
+    """ Transform RGB to hex.
+
+    Args:
+        rgb (str): RGB code.
+
+    Returns:
+        str: Hex code.
+
+    """
+    if rgb == 'none':
+        return '#000000'
+    if 'rgb' in rgb:
+        rgb = rgb.replace('rgb(', '').replace(')', '')
+        if '%' in rgb:
+            rgb = rgb.replace('%', '')
+            rgb_list = rgb.split(',')
+            r_value, g_value, b_value = [int(float(i) / 100 * 255) for i in rgb_list]
+        else:
+            rgb_list = rgb.split(',')
+            r_value, g_value, b_value = [int(float(i)) for i in rgb_list]
+        return '#%02x%02x%02x' % (r_value, g_value, b_value)

src/postprocessing/get_svg_color_tendency.py

@@ -0,0 +1,19 @@
+from src.postprocessing.get_style_attributes import get_style_attributes_svg
+
+
+def get_svg_color_tendencies(file):
+    """ Get two most frequent colors in SVG. Black and white are excluded.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+        list: List of two most frequent colors in SVG.
+
+    """
+    df = get_style_attributes_svg(file)
+    df = df[~df['fill'].isin(['#FFFFFF', '#ffffff'])]
+    colour_tendencies_list = df["fill"].value_counts()[:2].index.tolist()
+    colour_tendencies_list.append("#000000")
+    return colour_tendencies_list[:2]
+

src/postprocessing/get_svg_size_pos.py

@@ -0,0 +1,268 @@
+from xml.dom import minidom
+from svgpathtools import svg2paths
+
+
+def get_svg_size(file):
+    """ Get width and height of an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+        float, float: Width and height of SVG.
+
+    """
+    doc = minidom.parse(file)
+    width = doc.getElementsByTagName('svg')[0].getAttribute('width')
+    height = doc.getElementsByTagName('svg')[0].getAttribute('height')
+
+    if width != "" and height != "":
+        if not width[-1].isdigit():
+            width = width.replace('px', '').replace('pt', '')
+        if not height[-1].isdigit():
+            height = height.replace('px', '').replace('pt', '')
+
+    if width == "" or height == "" or not width[-1].isdigit() or not height[-1].isdigit():
+        # get bounding box of svg
+        xmin_svg, xmax_svg, ymin_svg, ymax_svg = 100, -100, 100, -100
+        paths, _ = svg2paths(file)
+        for path in paths:
+            xmin, xmax, ymin, ymax = path.bbox()
+            if xmin < xmin_svg:
+                xmin_svg = xmin
+            if xmax > xmax_svg:
+                xmax_svg = xmax
+            if ymin < ymin_svg:
+                ymin_svg = ymin
+            if ymax > ymax_svg:
+                ymax_svg = ymax
+            width = xmax_svg - xmin_svg
+            height = ymax_svg - ymin_svg
+
+    return float(width), float(height)
+
+
+def get_svg_bbox(file):
+    """ Get bounding box coordinates of an SVG.
+
+    xmin, ymin: Upper left corner.
+
+    xmax, ymax: Lower right corner.
+
+    Args:
+        file (str): Path of SVG file.
+
+    Returns:
+         float, float, float, float: Bounding box of SVG (xmin, xmax, ymin, ymax).
+
+    """
+    try:
+        paths, _ = svg2paths(file)
+    except Exception as e:
+        print(f"{file}: svg2path fails. SVG bbox is computed by using get_svg_size. {e}")
+        width, height = get_svg_size(file)
+        return 0, width, 0, height
+
+    xmin_svg, xmax_svg, ymin_svg, ymax_svg = 100, -100, 100, -100
+    for path in paths:
+        try:
+            xmin, xmax, ymin, ymax = path.bbox()
+            if xmin < xmin_svg:
+                xmin_svg = xmin
+            if xmax > xmax_svg:
+                xmax_svg = xmax
+            if ymin < ymin_svg:
+                ymin_svg = ymin
+            if ymax > ymax_svg:
+                ymax_svg = ymax
+        except:
+            pass
+    
+    return xmin_svg, xmax_svg, ymin_svg, ymax_svg
+
+
+def get_path_bbox(file, animation_id):
+    """ Get bounding box coordinates of a path in an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_id (int): ID of element.
+
+    Returns:
+        float, float, float, float: Bounding box of path (xmin, xmax, ymin, ymax).
+
+    """
+    try:
+        paths, attributes = svg2paths(file)
+    except Exception as e1:
+        print(f"{file}, animation ID {animation_id}: svg2path fails and path bbox cannot be computed. {e1}")
+        return 0, 0, 0, 0
+
+    for i, path in enumerate(paths):
+        if attributes[i]["animation_id"] == str(animation_id):
+            try:
+                xmin, xmax, ymin, ymax = path.bbox()
+                return xmin, xmax, ymin, ymax
+            except Exception as e2:
+                print(f"{file}, animation ID {animation_id}: svg2path fails and path bbox cannot be computed. {e2}")
+                return 0, 0, 0, 0
+
+
+def get_midpoint_of_path_bbox(file, animation_id):
+    """ Get midpoint of bounding box of path.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_id (int): ID of element.
+
+    Returns:
+        float, float: Midpoint of bounding box of path (x_midpoint, y_midpoint).
+
+    """
+    try:
+        xmin, xmax, ymin, ymax = get_path_bbox(file, animation_id)
+        x_midpoint = (xmin + xmax) / 2
+        y_midpoint = (ymin + ymax) / 2
+
+        return x_midpoint, y_midpoint
+    except Exception as e:
+        print(f'Could not get midpoint for file {file} and animation ID {animation_id}: {e}')
+        return 0, 0
+
+
+def get_bbox_of_multiple_paths(file, animation_ids):
+    """ Get bounding box of multiple paths in an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_ids (list(int)): List of element IDs.
+
+    Returns:
+        float, float, float, float: Bounding box of given paths (xmin, xmax, ymin, ymax).
+
+    """
+    try:
+        paths, attributes = svg2paths(file)
+    except Exception as e1:
+        print(f"{file}: svg2path fails and bbox of multiple paths cannot be computed. {e1}")
+        return 0, 0, 0, 0
+
+    xmin_paths, xmax_paths, ymin_paths, ymax_paths = 100, -100, 100, -100
+
+    for i, path in enumerate(paths):
+        if attributes[i]["animation_id"] in list(map(str, animation_ids)):
+            try:
+                xmin, xmax, ymin, ymax = path.bbox()
+                if xmin < xmin_paths:
+                    xmin_paths = xmin
+                if xmax > xmax_paths:
+                    xmax_paths = xmax
+                if ymin < ymin_paths:
+                    ymin_paths = ymin
+                if ymax > ymax_paths:
+                    ymax_paths = ymax
+            except:
+                pass
+
+    return xmin_paths, xmax_paths, ymin_paths, ymax_paths
+
+
+def get_relative_path_pos(file, animation_id):
+    """ Get relative position of a path in an SVG.
+
+    Args:
+        file (string): Path of SVG file.
+        animation_id (int): ID of element.
+
+    Returns:
+        float, float: Relative x- and y-position of path.
+
+    """
+    path_midpoint_x, path_midpoint_y = get_midpoint_of_path_bbox(file, animation_id)
+    svg_xmin, svg_xmax, svg_ymin, svg_ymax = get_svg_bbox(file)
+    rel_x_position = (path_midpoint_x - svg_xmin) / (svg_xmax - svg_xmin)
+    rel_y_position = (path_midpoint_y - svg_ymin) / (svg_ymax - svg_ymin)
+    return rel_x_position, rel_y_position
+
+
+def get_relative_pos_to_bounding_box_of_animated_paths(file, animation_id, animated_animation_ids):
+    """ Get relative position of a path to the bounding box of all animated paths.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_id (int): ID of element.
+        animated_animation_ids (list(int)): List of animated element IDs.
+
+    Returns:
+        float, float: Relative x- and y-position of path to bounding box of all animated paths.
+
+    """
+    path_midpoint_x, path_midpoint_y = get_midpoint_of_path_bbox(file, animation_id)
+    xmin, xmax, ymin, ymax = get_bbox_of_multiple_paths(file, animated_animation_ids)
+    try:
+        rel_x_position = (path_midpoint_x - xmin) / (xmax - xmin)
+    except Exception as e1:
+        rel_x_position = 0.5
+        print(f"{file}, animation_id {animation_id}, animated_animation_ids {animated_animation_ids}: rel_x_position not defined and set to 0.5. {e1}")
+    try:
+        rel_y_position = (path_midpoint_y - ymin) / (ymax - ymin)
+    except Exception as e2:
+        rel_y_position = 0.5
+        print(f"{file}, animation_id {animation_id}, animated_animation_ids {animated_animation_ids}: rel_y_position not defined and set to 0.5. {e2}")
+
+    return rel_x_position, rel_y_position
+
+
+def get_relative_path_size(file, animation_id):
+    """ Get relative size of a path in an SVG.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_id (int): ID of element.
+
+    Returns:
+        float, float: Relative width and height of path.
+
+    """
+    svg_xmin, svg_xmax, svg_ymin, svg_ymax = get_svg_bbox(file)
+    svg_width = float(svg_xmax - svg_xmin)
+    svg_height = float(svg_ymax - svg_ymin)
+
+    path_xmin, path_xmax, path_ymin, path_ymax = get_path_bbox(file, animation_id)
+    path_width = float(path_xmax - path_xmin)
+    path_height = float(path_ymax - path_ymin)
+
+    rel_width = path_width / svg_width
+    rel_height = path_height / svg_height
+
+    return rel_width, rel_height
+
+
+def get_begin_values_by_starting_pos(file, animation_ids, start=1, step=0.5):
+    """ Get begin values by sorting from left to right.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_ids (list(int)): List of element IDs.
+        start (float): First begin value.
+        step (float): Time between begin values.
+
+    Returns:
+        list: Begin values of element IDs.
+
+    """
+    starting_point_list = []
+    begin_list = []
+    begin = start
+    for i in range(len(animation_ids)):
+        x, _, _, _ = get_path_bbox(file, animation_ids[i])  # get x value of upper left corner
+        starting_point_list.append(x)
+        begin_list.append(begin)
+        begin = begin + step
+
+    animation_id_order = [z for _, z in sorted(zip(starting_point_list, range(len(starting_point_list))))]
+    begin_values = [z for _, z in sorted(zip(animation_id_order, begin_list))]
+
+    return begin_values
+
+

src/postprocessing/insert_animation.py

@@ -0,0 +1,333 @@
+import numpy as np
+from xml.dom import minidom
+from pathlib import Path
+from src.postprocessing.get_svg_size_pos import get_midpoint_of_path_bbox, get_begin_values_by_starting_pos
+from src.postprocessing.transform_animation_predictor_output import transform_animation_predictor_output
+
+
+def create_animated_svg(file, animation_ids, model_output, filename_suffix="", save=True):
+    """ Insert multiple animation statements.
+
+    Args:
+        file (str): Path of SVG file.
+        animation_ids (list[int]): List of element IDs that get animated.
+        model_output (ndarray): Array of 13 dimensional arrays with animation predictor model output.
+        filename_suffix  (str): Suffix of animated SVG.
+
+    Returns:
+        list(float): List of begin values of elements in SVG.
+        xml.dom.minidom.Document: Parsed file with inserted animation statements.
+
+    """
+    doc = svg_to_doc(file)
+    begin_values = get_begin_values_by_starting_pos(file, animation_ids, start=1, step=0.25)
+    for i in range(len(animation_ids)):
+        if not (model_output[i][:6] == np.array([0] * 6)).all():
+            try:  # there are some paths that can't be embedded and don't have style attributes
+                output_dict = transform_animation_predictor_output(file, animation_ids[i], model_output[i])
+                output_dict["begin"] = begin_values[i]
+                if output_dict["type"] == "translate":
+                    doc = insert_translate_statement(doc, animation_ids[i], output_dict)
+                if output_dict["type"] == "scale":
+                    doc = insert_scale_statement(doc, animation_ids[i], output_dict, file)
+                if output_dict["type"] == "rotate":
+                    doc = insert_rotate_statement(doc, animation_ids[i], output_dict)
+                if output_dict["type"] in ["skewX", "skewY"]:
+                    doc = insert_skew_statement(doc, animation_ids[i], output_dict)
+                if output_dict["type"] == "fill":
+                    doc = insert_fill_statement(doc, animation_ids[i], output_dict)
+                if output_dict["type"] in ["opacity"]:
+                    doc = insert_opacity_statement(doc, animation_ids[i], output_dict)
+            except Exception as e:
+                print(f"File {file}, animation ID {animation_ids[i]} can't be animated. {e}")
+                pass
+
+    if save:
+        filename = file.split('/')[-1].replace(".svg", "") + "_animated"
+        save_animated_svg(doc, filename)
+
+    return begin_values, doc
+
+
+def svg_to_doc(file):
+    """ Parse an SVG file.
+
+    Args:
+        file (string): Path of SVG file.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    return minidom.parse(file)
+
+
+def save_animated_svg(doc, filename):
+    """ Save animated SVGs to folder animated_svgs.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file.
+        filename (str): Name of output file.
+
+    """
+    Path("data/animated_svgs").mkdir(parents=True, exist_ok=True)
+
+    with open('data/animated_svgs/' + filename + '.svg', 'wb') as f:
+        f.write(doc.toprettyxml(encoding="iso-8859-1"))
+
+
+def insert_translate_statement(doc, animation_id, model_output_dict):
+    """ Insert translate statement.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file.
+        animation_id (int): ID of element that gets animated.
+        model_output_dict (dict): Dictionary containing animation statement.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    pre_animations = []
+    opacity_dict_1, opacity_dict_2 = create_opacity_pre_animation_dicts(model_output_dict)
+    pre_animations.append(create_animation_statement(opacity_dict_1))
+    pre_animations.append(create_animation_statement(opacity_dict_2))
+
+    animation = create_animation_statement(model_output_dict)
+    doc = insert_animation(doc, animation_id, animation, pre_animations)
+    return doc
+
+
+def insert_scale_statement(doc, animation_id, model_output_dict, file):
+    """ Insert scale statement.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file.
+        animation_id (int): ID of element that gets animated.
+        model_output_dict (dict): Dictionary containing animation statement.
+        file (str): Path of SVG file. Needed to get midpoint of path bbox to suppress simultaneous translate movement.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    pre_animations = []
+    opacity_dict_1, opacity_dict_2 = create_opacity_pre_animation_dicts(model_output_dict)
+    pre_animations.append(create_animation_statement(opacity_dict_1))
+    pre_animations.append(create_animation_statement(opacity_dict_2))
+
+    x_midpoint, y_midpoint = get_midpoint_of_path_bbox(file, animation_id)
+    if model_output_dict["from_"] > 1:
+        model_output_dict["from_"] = 2
+        pre_animation_from = f"-{x_midpoint} -{y_midpoint}"  # negative midpoint
+    else:
+        model_output_dict["from_"] = 0
+        pre_animation_from = f"{x_midpoint} {y_midpoint}"  # positive midpoint
+
+    translate_pre_animation_dict = {"type": "translate",
+                                    "begin": model_output_dict["begin"],
+                                    "dur": model_output_dict["dur"],
+                                    "from_": pre_animation_from,
+                                    "to": "0 0",
+                                    "fill": "freeze"}
+    pre_animations.append(create_animation_statement(translate_pre_animation_dict))
+
+    animation = create_animation_statement(model_output_dict) + ' additive="sum" '
+    doc = insert_animation(doc, animation_id, animation, pre_animations)
+    return doc
+
+
+def insert_rotate_statement(doc, animation_id, model_output_dict):
+    """ Insert rotate statement.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file.
+        animation_id (int): ID of element that gets animated.
+        model_output_dict (dict): Dictionary containing animation statement.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    pre_animations = []
+    opacity_dict_1, opacity_dict_2 = create_opacity_pre_animation_dicts(model_output_dict)
+    pre_animations.append(create_animation_statement(opacity_dict_1))
+    pre_animations.append(create_animation_statement(opacity_dict_2))
+
+    animation = create_animation_statement(model_output_dict)
+    doc = insert_animation(doc, animation_id, animation, pre_animations)
+    return doc
+
+
+def insert_skew_statement(doc, animation_id, model_output_dict):
+    """ Insert skew statement.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file.
+        animation_id (int): ID of element that gets animated.
+        model_output_dict (dict): Dictionary containing animation statement.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    pre_animations = []
+    opacity_dict_1, opacity_dict_2 = create_opacity_pre_animation_dicts(model_output_dict)
+    pre_animations.append(create_animation_statement(opacity_dict_1))
+    pre_animations.append(create_animation_statement(opacity_dict_2))
+
+    animation = create_animation_statement(model_output_dict)
+    doc = insert_animation(doc, animation_id, animation, pre_animations)
+    return doc
+
+
+def insert_fill_statement(doc, animation_id, model_output_dict):
+    """ Insert fill statement.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file
+        animation_id (int): ID of element that gets animated.
+        model_output_dict (dict): Dictionary containing animation statement.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    pre_animations = []
+    model_output_dict['dur'] = 2
+    if model_output_dict['begin'] < 2:
+        model_output_dict['begin'] = 0
+    else:  # Wave
+        pre_animation_dict = {"type": "fill",
+                              "begin": 0,
+                              "dur": model_output_dict["begin"],
+                              "from_": model_output_dict["to"],
+                              "to": model_output_dict["from_"],
+                              "fill": "remove"}
+        pre_animations.append(create_animation_statement(pre_animation_dict))
+
+    animation = create_animation_statement(model_output_dict)
+    doc = insert_animation(doc, animation_id, animation, pre_animations)
+    return doc
+
+
+def insert_opacity_statement(doc, animation_id, model_output_dict):
+    """ Insert opacity statement.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file.
+        animation_id (int): ID of element that gets animated.
+        model_output_dict (dict): Dictionary containing animation statement.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    pre_animations = []
+    opacity_pre_animation_dict = {"type": "opacity",
+                                  "begin": "0",
+                                  "dur": model_output_dict["begin"],
+                                  "from_": "0",
+                                  "to": "0",
+                                  "fill": "remove"}
+    pre_animations.append(create_animation_statement(opacity_pre_animation_dict))
+
+    animation = create_animation_statement(model_output_dict)
+    doc = insert_animation(doc, animation_id, animation, pre_animations)
+    return doc
+
+
+def insert_animation(doc, animation_id, animation, pre_animations=None):
+    """ Insert animation statements including pre-animation statements.
+
+    Args:
+        doc (xml.dom.minidom.Document): Parsed file.
+        animation_id (int): ID of element that gets animated.
+        animation (string): Animation that needs to be inserted.
+        pre_animations (list): List of animations that needs to be inserted before actual animation.
+
+    Returns:
+        xml.dom.minidom.Document: Parsed file with inserted animation statement.
+
+    """
+    elements = doc.getElementsByTagName('path') + doc.getElementsByTagName('circle') + doc.getElementsByTagName(
+        'ellipse') + doc.getElementsByTagName('line') + doc.getElementsByTagName(
+        'polygon') + doc.getElementsByTagName('polyline') + doc.getElementsByTagName(
+        'rect') + doc.getElementsByTagName('text')
+
+    for element in elements:
+        if element.getAttribute('animation_id') == str(animation_id):
+            if pre_animations is not None:
+                for i in range(len(pre_animations)):
+                    element.appendChild(doc.createElement(pre_animations[i]))
+            element.appendChild(doc.createElement(animation))
+
+    return doc
+
+
+def create_animation_statement(animation_dict):
+    """ Set up animation statement from a dictionary.
+
+    Args:
+        animation_dict (dict): Dictionary that is transformed into animation statement.
+
+    Returns:
+        str: Animation statement.
+
+    """
+    if animation_dict["type"] in ["translate", "scale", "rotate", "skewX", "skewY"]:
+        return _create_animate_transform_statement(animation_dict)
+    elif animation_dict["type"] in ["fill", "opacity"]:
+        return _create_animate_statement(animation_dict)
+
+
+def _create_animate_transform_statement(animation_dict):
+    """ Set up animation statement from model output for ANIMATETRANSFORM animations """
+    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"])}"'
+
+    return animation
+
+
+def _create_animate_statement(animation_dict):
+    """ Set up animation statement from model output for ANIMATE animations """
+    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"])}"'
+
+    return animation
+
+
+def create_opacity_pre_animation_dicts(animation_dict):
+    """ Set up pre_animation statements.
+
+    Args:
+        animation_dict (dict): Dictionary from animation that is needed to set up opacity pre-animations.
+
+    Returns:
+        str: Animation Statement.
+
+    """
+    opacity_pre_animation_dict_1 = {"type": "opacity",
+                                    "begin": "0",
+                                    "dur": animation_dict["begin"],
+                                    "from_": "0",
+                                    "to": "0",
+                                    "fill": "remove"}
+
+    opacity_pre_animation_dict_2 = {"type": "opacity",
+                                    "begin": animation_dict["begin"],
+                                    "dur": "0.5",
+                                    "from_": "0",
+                                    "to": "1",
+                                    "fill": "remove"}
+
+    return opacity_pre_animation_dict_1, opacity_pre_animation_dict_2

src/postprocessing/postprocessing.py

@@ -0,0 +1,604 @@
+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):
+    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)
+        path_xmin, path_xmax, path_ymin, path_ymax = get_path_bbox(logo_path, animation_id)
+        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]
+                # Check type and call method
+                if animation_type == 1:
+                    # animation: translate
+                    from_x = animations_by_type[animation_type][i][12]
+                    from_y = 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 = 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 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 = animations_by_type[animation_type][i][12]
+                    from_y = animations_by_type[animation_type][i][13]
+                    via_x = animations_by_type[animation_type][i][14]
+                    via_y = 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]
+                    # 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]
+                    # 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 = 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 = 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 = 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 = 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
+                    # 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]
+                    # 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(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)

src/postprocessing/transform_animation_predictor_output.py

@@ -0,0 +1,78 @@
+from src.postprocessing.get_svg_size_pos import get_svg_size, get_midpoint_of_path_bbox
+from src.postprocessing.get_style_attributes import get_style_attributes_path
+from src.postprocessing.get_svg_color_tendency import get_svg_color_tendencies
+
+
+def transform_animation_predictor_output(file, animation_id, output):
+    """ Function to translate the numeric model output to animation commands.
+    Example: transform_animation_predictor_output("data/svgs/logo_1.svg", 0, [0,0,1,0,0,0,-1,-1,-1,0.42,-1,-1])
+
+    Args:
+        file (str): Path of SVG file.
+        animation_id (int): ID of element in SVG that gets animated.
+        output (list): 12-dimensional list of numeric values of which first 6 determine the animation to be used and
+                        the last 6 determine the attribute from. Format: [translate, scale, rotate, skew, fill, opacity, translate_from_1, translate_from_2, scale_from, rotate_from, skew_from_1, skew_from_2].
+
+    Returns:
+        dict: Animation statement as dictionary.
+
+    """
+    animation = {}
+    width, height = get_svg_size(file)
+    x_midpoint, y_midpoint = get_midpoint_of_path_bbox(file, animation_id)
+    fill_style = get_style_attributes_path(file, animation_id, "fill")
+    stroke_style = get_style_attributes_path(file, animation_id, "stroke")
+    opacity_style = get_style_attributes_path(file, animation_id, "opacity")
+    color_1, color_2 = get_svg_color_tendencies(file)
+
+    if output[0] == 1:
+        animation["type"] = "translate"
+        x = (output[6] * 2 - 1) * width  # between -width and width
+        y = (output[7] * 2 - 1) * height  # between -height and height
+        animation["from_"] = f"{str(x)} {str(y)}"
+        animation["to"] = "0 0"
+
+    elif output[1] == 1:
+        animation["type"] = "scale"
+        animation["from_"] = output[8] * 2  # between 0 and 2
+        animation["to"] = 1
+
+    elif output[2] == 1:
+        animation["type"] = "rotate"
+        degree = int(output[9]*720) - 360  # between -360 and 360
+        animation["from_"] = f"{str(degree)} {str(x_midpoint)} {str(y_midpoint)}"
+        animation["to"] = f"0 {str(x_midpoint)} {str(y_midpoint)}"
+
+    elif output[3] == 1:
+        if output[10] > 0.5:
+            animation["type"] = "skewX"
+            animation["from_"] = (output[11] * 2 - 1) * width/20  # between -width/20 and width/20
+        else:
+            animation["type"] = "skewY"
+            animation["from_"] = (output[11] * 2 - 1) * height/20  # between -height/20 and height/20
+        animation["to"] = 0
+
+    elif output[4] == 1:
+        animation["type"] = "fill"
+        if fill_style == "none" and stroke_style != "none":
+            color_hex = stroke_style
+        else:
+            color_hex = fill_style
+        animation["to"] = color_hex
+
+        if color_hex != color_1:
+            color_from = color_1
+        else:
+            color_from = color_2
+        animation["from_"] = color_from
+
+    elif output[5] == 1:
+        animation["type"] = "opacity"
+        animation["from_"] = 0
+        animation["to"] = opacity_style
+
+    animation["dur"] = 4
+    animation["begin"] = 1
+    animation["fill"] = "freeze"
+
+    return animation

src/preprocessing/deepsvg/deepsvg_config/config.py

@@ -0,0 +1,106 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch.optim as optim
+from src.preprocessing.deepsvg.deepsvg_schedulers.warmup import GradualWarmupScheduler
+
+
+class _Config:
+    """
+    Training config.
+    """
+    def __init__(self, num_gpus=1):
+
+        self.num_gpus = num_gpus                              #
+
+        self.dataloader_module = "deepsvg.svgtensor_dataset"  #
+        self.collate_fn = None                                #
+        self.data_dir = "./data/svgs_tensors/"             #
+        self.meta_filepath = "./data/svgs_meta.csv"            #
+        self.loader_num_workers = 0                           #
+
+        self.pretrained_path = "./models/hierarchical_ordered.pth.tar"        #
+
+        self.model_cfg = None                                 #
+
+        self.num_epochs = None                                #
+        self.num_steps = None                                 #
+        self.learning_rate = 1e-3                             #
+        self.batch_size = 100                                 #
+        self.warmup_steps = 500                               #
+
+
+        # Dataset
+        self.train_ratio = 1.0                                #
+        self.nb_augmentations = 1                             #
+
+        self.max_num_groups = 15                              #
+        self.max_seq_len = 30                                 #
+        self.max_total_len = None                             #
+
+        self.filter_uni = None                                #
+        self.filter_category = None                           #
+        self.filter_platform = None                           #
+
+        self.filter_labels = None                             #
+
+        self.grad_clip = None                                 #
+
+        self.log_every = 20                                   #
+        self.val_every = 1000                                 #
+        self.ckpt_every = 1000                                #
+
+        self.stats_to_print = {
+            "train": ["lr", "time"]
+        }
+
+        self.model_args = []                                  #
+        self.optimizer_starts = [0]                           #
+
+    # Overridable methods
+    def make_model(self):
+        raise NotImplementedError
+
+    def make_losses(self):
+        raise NotImplementedError
+
+    def make_optimizers(self, model):
+        return [optim.AdamW(model.parameters(), self.learning_rate)]
+
+    def make_schedulers(self, optimizers, epoch_size):
+        return [None] * len(optimizers)
+
+    def make_warmup_schedulers(self, optimizers, scheduler_lrs):
+        return [GradualWarmupScheduler(optimizer, multiplier=1.0, total_epoch=self.warmup_steps, after_scheduler=scheduler_lr)
+                for optimizer, scheduler_lr in zip(optimizers, scheduler_lrs)]
+
+    def get_params(self, step, epoch):
+        return {}
+
+    def get_weights(self, step, epoch):
+        return {}
+
+    def set_train_vars(self, train_vars, dataloader):
+        pass
+
+    def visualize(self, model, output, train_vars, step, epoch, summary_writer, visualization_dir):
+        pass
+
+    # Utility methods
+    def values(self):
+        for key in dir(self):
+            if not key.startswith("__") and not callable(getattr(self, key)):
+                yield key, getattr(self, key)
+
+    def to_dict(self):
+        return {key: val for key, val in self.values()}
+
+    def load_dict(self, dict):
+        for key, val in dict.items():
+            setattr(self, key, val)
+
+    def print_params(self):
+        for key, val in self.values():
+            print(f"  {key} = {val}")

src/preprocessing/deepsvg/deepsvg_config/config_hierarchical_ordered.py

@@ -0,0 +1,29 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from .default_icons import *
+
+
+class ModelConfig(Hierarchical):
+    def __init__(self):
+        super().__init__()
+
+        self.label_condition = False
+        self.use_vae = False
+
+
+class Config(Config):
+    def __init__(self, num_gpus=1):
+        super().__init__(num_gpus=num_gpus)
+
+        self.model_cfg = ModelConfig()
+        self.model_args = self.model_cfg.get_model_args()
+
+        self.filter_category = None
+
+        self.learning_rate = 1e-3 * num_gpus
+        self.batch_size = 20 #60 * num_gpus
+
+        self.val_every = 10 #2000

src/preprocessing/deepsvg/deepsvg_config/default_icons.py

@@ -0,0 +1,102 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from src.preprocessing.deepsvg.deepsvg_config.config import _Config
+from src.preprocessing.deepsvg.deepsvg_models.model import SVGTransformer
+from src.preprocessing.deepsvg.deepsvg_models.loss import SVGLoss
+from src.preprocessing.deepsvg.deepsvg_models.model_config import *
+from src.preprocessing.deepsvg.deepsvg_svglib.svg import SVG
+from src.preprocessing.deepsvg.deepsvg_difflib.tensor import SVGTensor
+from src.preprocessing.deepsvg.deepsvg_svglib.svglib_utils import make_grid
+from src.preprocessing.deepsvg.deepsvg_svglib.geom import Bbox
+from src.preprocessing.deepsvg.deepsvg_utils.utils import batchify, linear
+
+import torchvision.transforms.functional as TF
+import torch.optim.lr_scheduler as lr_scheduler
+import random
+
+
+class ModelConfig(Hierarchical):
+    """
+    Overriding default model config.
+    """
+    def __init__(self):
+        super().__init__()
+
+
+class Config(_Config):
+    """
+    Overriding default training config.
+    """
+    def __init__(self, num_gpus=1):
+        super().__init__(num_gpus=num_gpus)
+
+        # Model
+        self.model_cfg = ModelConfig()
+        self.model_args = self.model_cfg.get_model_args()
+
+        # Dataset
+        self.filter_category = None
+
+        self.train_ratio = 1.0
+
+        self.max_num_groups = 8
+        self.max_total_len = 50
+
+        # Dataloader
+        self.loader_num_workers = 4 * num_gpus
+
+        # Training
+        self.num_epochs = 50
+        self.val_every = 1000
+
+        # Optimization
+        self.learning_rate = 1e-3 * num_gpus
+        self.batch_size = 60 * num_gpus
+        self.grad_clip = 1.0
+
+    def make_schedulers(self, optimizers, epoch_size):
+        optimizer, = optimizers
+        return [lr_scheduler.StepLR(optimizer, step_size=2.5 * epoch_size, gamma=0.9)]
+
+    def make_model(self):
+        return SVGTransformer(self.model_cfg)
+
+    def make_losses(self):
+        return [SVGLoss(self.model_cfg)]
+
+    def get_weights(self, step, epoch):
+        return {
+            "kl_tolerance": 0.1,
+            "loss_kl_weight": linear(0, 10, step, 0, 10000),
+            "loss_hierarch_weight": 1.0,
+            "loss_cmd_weight": 1.0,
+            "loss_args_weight": 2.0,
+            "loss_visibility_weight": 1.0
+        }
+
+    def set_train_vars(self, train_vars, dataloader):
+        train_vars.x_inputs_train = [dataloader.dataset.get(idx, [*self.model_args, "tensor_grouped"])
+                                     for idx in random.sample(range(len(dataloader.dataset)), k=10)]
+
+    def visualize(self, model, output, train_vars, step, epoch, summary_writer, visualization_dir):
+        device = next(model.parameters()).device
+        
+        # Reconstruction
+        for i, data in enumerate(train_vars.x_inputs_train):
+            model_args = batchify((data[key] for key in self.model_args), device)
+            commands_y, args_y = model.module.greedy_sample(*model_args)
+            tensor_pred = SVGTensor.from_cmd_args(commands_y[0].cpu(), args_y[0].cpu())
+
+            try:
+                svg_path_sample = SVG.from_tensor(tensor_pred.data, viewbox=Bbox(256), allow_empty=True).normalize().split_paths().set_color("random")
+            except:
+                continue
+
+            tensor_target = data["tensor_grouped"][0].copy().drop_sos().unpad()
+            svg_path_gt = SVG.from_tensor(tensor_target.data, viewbox=Bbox(256)).normalize().split_paths().set_color("random")
+
+            img = make_grid([svg_path_sample, svg_path_gt]).draw(do_display=False, return_png=True, fill=False, with_points=False)
+            summary_writer.add_image(f"reconstructions_train/{i}", TF.to_tensor(img), step)

src/preprocessing/deepsvg/deepsvg_dataloader/svg_dataset.py

@@ -0,0 +1,239 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from src.preprocessing.deepsvg.deepsvg_config.config import _Config
+from src.preprocessing.deepsvg.deepsvg_difflib.tensor import SVGTensor
+from src.preprocessing.deepsvg.deepsvg_svglib.svg import SVG
+from src.preprocessing.deepsvg.deepsvg_svglib.geom import Point
+
+import math
+import torch
+import torch.utils.data
+import random
+from typing import List, Union
+import pandas as pd
+import os
+import pickle
+Num = Union[int, float]
+
+
+class SVGDataset(torch.utils.data.Dataset):
+    def __init__(self, data_dir, meta_filepath, model_args, max_num_groups, max_seq_len, max_total_len=None,
+                 filter_uni=None, filter_platform=None, filter_category=None, train_ratio=1.0, df=None, PAD_VAL=-1,
+                 nb_augmentations=1, already_preprocessed=True):
+        self.data_dir = data_dir
+
+        self.already_preprocessed = already_preprocessed
+
+        self.MAX_NUM_GROUPS = max_num_groups
+        self.MAX_SEQ_LEN = max_seq_len
+        self.MAX_TOTAL_LEN = max_total_len
+
+        if max_total_len is None:
+            self.MAX_TOTAL_LEN = max_num_groups * max_seq_len
+
+        if df is None:
+            df = pd.read_csv(meta_filepath)
+
+        if len(df) > 0:
+            if filter_uni is not None:
+                df = df[df.uni.isin(filter_uni)]
+
+            if filter_platform is not None:
+                df = df[df.platform.isin(filter_platform)]
+
+            if filter_category is not None:
+                df = df[df.category.isin(filter_category)]
+
+            df = df[(df.nb_groups <= max_num_groups) & (df.max_len_group <= max_seq_len)]
+            if max_total_len is not None:
+                df = df[df.total_len <= max_total_len]
+
+        self.df = df.sample(frac=train_ratio) if train_ratio < 1.0 else df
+
+        self.model_args = model_args
+
+        self.PAD_VAL = PAD_VAL
+
+        self.nb_augmentations = nb_augmentations
+
+    def search_name(self, name):
+        return self.df[self.df.commonName.str.contains(name)]
+
+    def _filter_categories(self, filter_category):
+        self.df = self.df[self.df.category.isin(filter_category)]
+
+    @staticmethod
+    def _uni_to_label(uni):
+        if 48 <= uni <= 57:
+            return uni - 48
+        elif 65 <= uni <= 90:
+            return uni - 65 + 10
+        return uni - 97 + 36
+
+    @staticmethod
+    def _label_to_uni(label_id):
+        if 0 <= label_id <= 9:
+            return label_id + 48
+        elif 10 <= label_id <= 35:
+            return label_id + 65 - 10
+        return label_id + 97 - 36
+
+    @staticmethod
+    def _category_to_label(category):
+        categories = ['characters', 'free-icons', 'logos', 'alphabet', 'animals', 'arrows', 'astrology', 'baby', 'beauty',
+                      'business', 'cinema', 'city', 'clothing', 'computer-hardware', 'crime', 'cultures', 'data', 'diy',
+                      'drinks', 'ecommerce', 'editing', 'files', 'finance', 'folders', 'food', 'gaming', 'hands', 'healthcare',
+                      'holidays', 'household', 'industry', 'maps', 'media-controls', 'messaging', 'military', 'mobile',
+                      'music', 'nature', 'network', 'photo-video', 'plants', 'printing',  'profile', 'programming', 'science',
+                      'security', 'shopping', 'social-networks', 'sports', 'time-and-date', 'transport', 'travel', 'user-interface',
+                      'users', 'weather', 'flags', 'emoji', 'men', 'women']
+        return categories.index(category)
+
+    def get_label(self, idx=0, entry=None):
+        if entry is None:
+            entry = self.df.iloc[idx]
+
+        if "uni" in self.df.columns:  # Font dataset
+            label = self._uni_to_label(entry.uni)
+            return torch.tensor(label)
+        elif "category" in self.df.columns:  # Icons dataset
+            label = self._category_to_label(entry.category)
+            return torch.tensor(label)
+
+        return None
+
+    def idx_to_id(self, idx):
+        return self.df.iloc[idx].id
+
+    def entry_from_id(self, id):
+        return self.df[self.df.id == str(id)].iloc[0]
+
+    def _load_svg(self, icon_id):
+        svg = SVG.load_svg(os.path.join(self.data_dir, f"{icon_id}.svg"))
+
+        if not self.already_preprocessed:
+            svg.fill_(False)
+            svg.normalize().zoom(0.9)
+            svg.canonicalize()
+            svg = svg.simplify_heuristic()
+
+        return svg
+
+    def __len__(self):
+        return len(self.df) * self.nb_augmentations
+
+    def random_icon(self):
+        return self[random.randrange(0, len(self))]
+
+    def random_id(self):
+        idx = random.randrange(0, len(self)) % len(self.df)
+        return self.idx_to_id(idx)
+
+    def random_id_by_uni(self, uni):
+        df = self.df[self.df.uni == uni]
+        return df.id.sample().iloc[0]
+
+    def __getitem__(self, idx):
+        return self.get(idx, self.model_args)
+
+    @staticmethod
+    def _augment(svg, mean=False):
+        dx, dy = (0, 0) if mean else (5 * random.random() - 2.5, 5 * random.random() - 2.5)
+        factor = 0.7 if mean else 0.2 * random.random() + 0.6
+
+        return svg.zoom(factor).translate(Point(dx, dy))
+
+    @staticmethod
+    def simplify(svg, normalize=True):
+        svg.canonicalize(normalize=normalize)
+        svg = svg.simplify_heuristic()
+        return svg.normalize()
+
+    @staticmethod
+    def preprocess(svg, augment=True, numericalize=True, mean=False):
+        if augment:
+            svg = SVGDataset._augment(svg, mean=mean)
+        if numericalize:
+            return svg.numericalize(256)
+        return svg
+
+    def get(self, idx=0, model_args=None, random_aug=True, id=None, svg: SVG=None):
+        if id is None:
+            idx = idx % len(self.df)
+            id = self.idx_to_id(idx)
+
+        if svg is None:
+            svg = self._load_svg(id)
+
+            svg = SVGDataset.preprocess(svg, augment=random_aug)
+
+        t_sep, fillings = svg.to_tensor(concat_groups=False, PAD_VAL=self.PAD_VAL), svg.to_fillings()
+
+        # Note: DeepSVG can only handle 8 paths in a SVG and 30 sequences per path
+        if len(t_sep) > 8:
+            #print(f"SVG {id} has more than 30 segments.")
+            t_sep = t_sep[0:8]
+            fillings = fillings[0:8]
+
+        for i in range(len(t_sep)):
+            if len(t_sep[i]) > 30:
+                #print(f"SVG {id}: Path nr {i} has more than 30 segments.")
+                t_sep[i] = t_sep[i][0:30]
+
+        label = self.get_label(idx)
+
+        return self.get_data(t_sep, fillings, model_args=model_args, label=label)
+
+    def get_data(self, t_sep, fillings, model_args=None, label=None):
+        res = {}
+
+        if model_args is None:
+            model_args = self.model_args
+
+        pad_len = max(self.MAX_NUM_GROUPS - len(t_sep), 0)
+
+        t_sep.extend([torch.empty(0, 14)] * pad_len)
+        fillings.extend([0] * pad_len)
+
+        t_grouped = [SVGTensor.from_data(torch.cat(t_sep, dim=0), PAD_VAL=self.PAD_VAL).add_eos().add_sos().pad(
+            seq_len=self.MAX_TOTAL_LEN + 2)]
+
+        t_sep = [SVGTensor.from_data(t, PAD_VAL=self.PAD_VAL, filling=f).add_eos().add_sos().pad(seq_len=self.MAX_SEQ_LEN + 2) for
+                 t, f in zip(t_sep, fillings)]
+
+        for arg in set(model_args):
+            if "_grouped" in arg:
+                arg_ = arg.split("_grouped")[0]
+                t_list = t_grouped
+            else:
+                arg_ = arg
+                t_list = t_sep
+
+            if arg_ == "tensor":
+                res[arg] = t_list
+
+            if arg_ == "commands":
+                res[arg] = torch.stack([t.cmds() for t in t_list])
+
+            if arg_ == "args_rel":
+                res[arg] = torch.stack([t.get_relative_args() for t in t_list])
+            if arg_ == "args":
+                res[arg] = torch.stack([t.args() for t in t_list])
+
+        if "filling" in model_args:
+            res["filling"] = torch.stack([torch.tensor(t.filling) for t in t_sep]).unsqueeze(-1)
+
+        if "label" in model_args:
+            res["label"] = label
+
+        return res
+
+
+def load_dataset(cfg: _Config, already_preprocessed=True):
+    dataset = SVGDataset(cfg.data_dir, cfg.meta_filepath, cfg.model_args, cfg.max_num_groups, cfg.max_seq_len, cfg.max_total_len,
+                         cfg.filter_uni, cfg.filter_platform, cfg.filter_category, cfg.train_ratio,
+                         nb_augmentations=cfg.nb_augmentations, already_preprocessed=already_preprocessed)
+    return dataset

src/preprocessing/deepsvg/deepsvg_difflib/tensor.py

@@ -0,0 +1,305 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from __future__ import annotations
+import torch
+import torch.utils.data
+from typing import Union
+Num = Union[int, float]
+
+
+class AnimationTensor:
+
+    COMMANDS_SIMPLIFIED = ['a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9']
+
+    CMD_ARGS_MASK = torch.tensor([[0, 0, 0],  # a0
+                                  [0, 0, 0],  # a1
+                                  [0, 0, 0],  # a2
+                                  [1, 1, 1],  # a3
+                                  [0, 0, 0],  # a4
+                                  [0, 0, 0],  # a5
+                                  [0, 0, 0],  # a6
+                                  [0, 0, 0],  # a7
+                                  [1, 1, 1],  # a8
+                                  [0, 0, 0]])  # a9
+
+    class Index:
+        COMMAND = 0
+        DURATION = 1
+        FROM = 2
+        BEGIN = 3
+
+    class IndexArgs:
+        DURATION = 0
+        FROM = 1
+        BEGIN = 2
+
+    all_arg_keys = ['duration', 'from', 'begin']
+    cmd_arg_keys = ["commands", *all_arg_keys]
+    all_keys = ["commands", *all_arg_keys]
+
+    def __init__(self, commands, duration, from_, begin,
+                 seq_len=None, label=None, PAD_VAL=-1, ARGS_DIM=256, filling=0):
+
+        self.commands = commands.reshape(-1, 1).float()
+
+        self.duration = duration.float()
+        self.from_ = from_.float()
+        self.begin = begin.float()
+
+        self.seq_len = torch.tensor(len(commands)) if seq_len is None else seq_len
+        self.label = label
+
+        self.PAD_VAL = PAD_VAL
+        self.ARGS_DIM = ARGS_DIM
+
+        # self.sos_token = torch.Tensor([self.COMMANDS_SIMPLIFIED.index("SOS")]).unsqueeze(-1)
+        # self.eos_token = self.pad_token = torch.Tensor([self.COMMANDS_SIMPLIFIED.index("EOS")]).unsqueeze(-1)
+
+        self.filling = filling
+
+
+class SVGTensor:
+    #                       0    1    2    3     4      5     6
+    COMMANDS_SIMPLIFIED = ["m", "l", "c", "a", "EOS", "SOS", "z"]
+
+    #                              rad  x  lrg sw  ctrl ctrl  end
+    #                              ius axs arc eep  1    2    pos
+    #                                   rot fg fg
+    CMD_ARGS_MASK = torch.tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],   # m
+                                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],   # l
+                                  [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1],   # c
+                                  [1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1],   # a
+                                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],   # EOS
+                                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],   # SOS
+                                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])  # z
+
+    class Index:
+        COMMAND = 0
+        RADIUS = slice(1, 3)
+        X_AXIS_ROT = 3
+        LARGE_ARC_FLG = 4
+        SWEEP_FLG = 5
+        START_POS = slice(6, 8)
+        CONTROL1 = slice(8, 10)
+        CONTROL2 = slice(10, 12)
+        END_POS = slice(12, 14)
+
+    class IndexArgs:
+        RADIUS = slice(0, 2)
+        X_AXIS_ROT = 2
+        LARGE_ARC_FLG = 3
+        SWEEP_FLG = 4
+        CONTROL1 = slice(5, 7)
+        CONTROL2 = slice(7, 9)
+        END_POS = slice(9, 11)
+
+    position_keys = ["control1", "control2", "end_pos"]
+    all_position_keys = ["start_pos", *position_keys]
+    arg_keys = ["radius", "x_axis_rot", "large_arc_flg", "sweep_flg", *position_keys]
+    all_arg_keys = [*arg_keys[:4], "start_pos", *arg_keys[4:]]
+    cmd_arg_keys = ["commands", *arg_keys]
+    all_keys = ["commands", *all_arg_keys]
+
+    def __init__(self, commands, radius, x_axis_rot, large_arc_flg, sweep_flg, control1, control2, end_pos,
+                 seq_len=None, label=None, PAD_VAL=-1, ARGS_DIM=256, filling=0):
+
+        self.commands = commands.reshape(-1, 1).float()
+
+        self.radius = radius.float()
+        self.x_axis_rot = x_axis_rot.reshape(-1, 1).float()
+        self.large_arc_flg = large_arc_flg.reshape(-1, 1).float()
+        self.sweep_flg = sweep_flg.reshape(-1, 1).float()
+
+        self.control1 = control1.float()
+        self.control2 = control2.float()
+        self.end_pos = end_pos.float()
+
+        self.seq_len = torch.tensor(len(commands)) if seq_len is None else seq_len
+        self.label = label
+
+        self.PAD_VAL = PAD_VAL
+        self.ARGS_DIM = ARGS_DIM
+
+        self.sos_token = torch.Tensor([self.COMMANDS_SIMPLIFIED.index("SOS")]).unsqueeze(-1)
+        self.eos_token = self.pad_token = torch.Tensor([self.COMMANDS_SIMPLIFIED.index("EOS")]).unsqueeze(-1)
+
+        self.filling = filling
+
+    @property
+    def start_pos(self):
+        start_pos = self.end_pos[:-1]
+
+        return torch.cat([
+            start_pos.new_zeros(1, 2),
+            start_pos
+        ])
+
+    @staticmethod
+    def from_data(data, *args, **kwargs):
+        return SVGTensor(data[:, SVGTensor.Index.COMMAND], data[:, SVGTensor.Index.RADIUS], data[:, SVGTensor.Index.X_AXIS_ROT],
+                         data[:, SVGTensor.Index.LARGE_ARC_FLG], data[:, SVGTensor.Index.SWEEP_FLG], data[:, SVGTensor.Index.CONTROL1],
+                         data[:, SVGTensor.Index.CONTROL2], data[:, SVGTensor.Index.END_POS], *args, **kwargs)
+
+    @staticmethod
+    def from_cmd_args(commands, args, *nargs, **kwargs):
+        return SVGTensor(commands, args[:, SVGTensor.IndexArgs.RADIUS], args[:, SVGTensor.IndexArgs.X_AXIS_ROT],
+                         args[:, SVGTensor.IndexArgs.LARGE_ARC_FLG], args[:, SVGTensor.IndexArgs.SWEEP_FLG], args[:, SVGTensor.IndexArgs.CONTROL1],
+                         args[:, SVGTensor.IndexArgs.CONTROL2], args[:, SVGTensor.IndexArgs.END_POS], *nargs, **kwargs)
+
+    def get_data(self, keys):
+        return torch.cat([self.__getattribute__(key) for key in keys], dim=-1)
+
+    @property
+    def data(self):
+        return self.get_data(self.all_keys)
+
+    def copy(self):
+        return SVGTensor(*[self.__getattribute__(key).clone() for key in self.cmd_arg_keys],
+                         seq_len=self.seq_len.clone(), label=self.label, PAD_VAL=self.PAD_VAL, ARGS_DIM=self.ARGS_DIM,
+                         filling=self.filling)
+
+    def add_sos(self):
+        self.commands = torch.cat([self.sos_token, self.commands])
+
+        for key in self.arg_keys:
+            v = self.__getattribute__(key)
+            self.__setattr__(key, torch.cat([v.new_full((1, v.size(-1)), self.PAD_VAL), v]))
+
+        self.seq_len += 1
+        return self
+
+    def drop_sos(self):
+        for key in self.cmd_arg_keys:
+            self.__setattr__(key, self.__getattribute__(key)[1:])
+
+        self.seq_len -= 1
+        return self
+
+    def add_eos(self):
+        self.commands = torch.cat([self.commands, self.eos_token])
+
+        for key in self.arg_keys:
+            v = self.__getattribute__(key)
+            self.__setattr__(key, torch.cat([v, v.new_full((1, v.size(-1)), self.PAD_VAL)]))
+
+        return self
+
+    def pad(self, seq_len=51):
+        pad_len = max(seq_len - len(self.commands), 0)
+
+        self.commands = torch.cat([self.commands, self.pad_token.repeat(pad_len, 1)])
+
+        for key in self.arg_keys:
+            v = self.__getattribute__(key)
+            self.__setattr__(key, torch.cat([v, v.new_full((pad_len, v.size(-1)), self.PAD_VAL)]))
+
+        return self
+
+    def unpad(self):
+        # Remove EOS + padding
+        for key in self.cmd_arg_keys:
+            self.__setattr__(key, self.__getattribute__(key)[:self.seq_len])
+        return self
+
+    def draw(self, *args, **kwags):
+        from deepsvg.svglib.svg import SVGPath
+        return SVGPath.from_tensor(self.data).draw(*args, **kwags)
+
+    def cmds(self):
+        return self.commands.reshape(-1)
+
+    def args(self, with_start_pos=False):
+        if with_start_pos:
+            return self.get_data(self.all_arg_keys)
+
+        return self.get_data(self.arg_keys)
+
+    def _get_real_commands_mask(self):
+        mask = self.cmds() < self.COMMANDS_SIMPLIFIED.index("EOS")
+        return mask
+
+    def _get_args_mask(self):
+        mask = SVGTensor.CMD_ARGS_MASK[self.cmds().long()].bool()
+        return mask
+
+    def get_relative_args(self):
+        data = self.args().clone()
+
+        real_commands = self._get_real_commands_mask()
+        data_real_commands = data[real_commands]
+
+        start_pos = data_real_commands[:-1, SVGTensor.IndexArgs.END_POS].clone()
+
+        data_real_commands[1:, SVGTensor.IndexArgs.CONTROL1] -= start_pos
+        data_real_commands[1:, SVGTensor.IndexArgs.CONTROL2] -= start_pos
+        data_real_commands[1:, SVGTensor.IndexArgs.END_POS] -= start_pos
+        data[real_commands] = data_real_commands
+
+        mask = self._get_args_mask()
+        data[mask] += self.ARGS_DIM - 1
+        data[~mask] = self.PAD_VAL
+
+        return data
+
+    def sample_points(self, n=10):
+        device = self.commands.device
+
+        z = torch.linspace(0, 1, n, device=device)
+        Z = torch.stack([torch.ones_like(z), z, z.pow(2), z.pow(3)], dim=1)
+
+        Q = torch.tensor([
+            [[0., 0., 0., 0.],  #  "m"
+             [0., 0., 0., 0.],
+             [0., 0., 0., 0.],
+             [0., 0., 0., 0.]],
+
+            [[1., 0., 0., 0.],  # "l"
+             [-1, 0., 0., 1.],
+             [0., 0., 0., 0.],
+             [0., 0., 0., 0.]],
+
+            [[1., 0., 0., 0.],  #  "c"
+             [-3, 3., 0., 0.],
+             [3., -6, 3., 0.],
+             [-1, 3., -3, 1.]],
+
+            torch.zeros(4, 4),  # "a", no support yet
+
+            torch.zeros(4, 4),  # "EOS"
+            torch.zeros(4, 4),  # "SOS"
+            torch.zeros(4, 4),  # "z"
+        ], device=device)
+
+        commands, pos = self.commands.reshape(-1).long(), self.get_data(self.all_position_keys).reshape(-1, 4, 2)
+        inds = (commands == self.COMMANDS_SIMPLIFIED.index("l")) | (commands == self.COMMANDS_SIMPLIFIED.index("c"))
+        commands, pos = commands[inds], pos[inds]
+
+        Z_coeffs = torch.matmul(Q[commands], pos)
+
+        # Last point being first point of next command, we drop last point except the one from the last command
+        sample_points = torch.matmul(Z, Z_coeffs)
+        sample_points = torch.cat([sample_points[:, :-1].reshape(-1, 2), sample_points[-1, -1].unsqueeze(0)])
+
+        return sample_points
+
+    @staticmethod
+    def get_length_distribution(p, normalize=True):
+        start, end = p[:-1], p[1:]
+        length_distr = torch.norm(end - start, dim=-1).cumsum(dim=0)
+        length_distr = torch.cat([length_distr.new_zeros(1), length_distr])
+        if normalize:
+            length_distr = length_distr / length_distr[-1]
+        return length_distr
+
+    def sample_uniform_points(self, n=100):
+        p = self.sample_points(n=n)
+
+        distr_unif = torch.linspace(0., 1., n).to(p.device)
+        distr = self.get_length_distribution(p, normalize=True)
+        d = torch.cdist(distr_unif.unsqueeze(-1), distr.unsqueeze(-1))
+        matching = d.argmin(dim=-1)
+
+        return p[matching]

src/preprocessing/deepsvg/deepsvg_models/basic_blocks.py

@@ -0,0 +1,70 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch
+import torch.nn as nn
+
+
+class FCN(nn.Module):
+    def __init__(self, d_model, n_commands, n_args, args_dim=256):
+        super().__init__()
+
+        self.n_args = n_args
+        self.args_dim = args_dim
+
+        self.command_fcn = nn.Linear(d_model, n_commands)
+        self.args_fcn = nn.Linear(d_model, n_args * args_dim)
+
+    def forward(self, out):
+        S, N, _ = out.shape
+
+        command_logits = self.command_fcn(out)  # Shape [S, N, n_commands]
+
+        args_logits = self.args_fcn(out)  # Shape [S, N, n_args * args_dim]
+        args_logits = args_logits.reshape(S, N, self.n_args, self.args_dim)  # Shape [S, N, n_args, args_dim]
+
+        return command_logits, args_logits
+
+
+class HierarchFCN(nn.Module):
+    def __init__(self, d_model, dim_z):
+        super().__init__()
+
+        self.visibility_fcn = nn.Linear(d_model, 2)
+        self.z_fcn = nn.Linear(d_model, dim_z)
+
+    def forward(self, out):
+        G, N, _ = out.shape
+
+        visibility_logits = self.visibility_fcn(out)  # Shape [G, N, 2]
+        z = self.z_fcn(out)  # Shape [G, N, dim_z]
+
+        return visibility_logits.unsqueeze(0), z.unsqueeze(0)
+
+
+class ResNet(nn.Module):
+    def __init__(self, d_model):
+        super().__init__()
+
+        self.linear1 = nn.Sequential(
+            nn.Linear(d_model, d_model), nn.ReLU()
+        )
+        self.linear2 = nn.Sequential(
+            nn.Linear(d_model, d_model), nn.ReLU()
+        )
+        self.linear3 = nn.Sequential(
+            nn.Linear(d_model, d_model), nn.ReLU()
+        )
+        self.linear4 = nn.Sequential(
+            nn.Linear(d_model, d_model), nn.ReLU()
+        )
+
+    def forward(self, z):
+        z = z + self.linear1(z)
+        z = z + self.linear2(z)
+        z = z + self.linear3(z)
+        z = z + self.linear4(z)
+
+        return z

src/preprocessing/deepsvg/deepsvg_models/layers/attention.py

@@ -0,0 +1,166 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch
+from torch.nn import Linear
+from torch.nn.init import xavier_uniform_
+from torch.nn.init import constant_
+from torch.nn.init import xavier_normal_
+from torch.nn.parameter import Parameter
+from torch.nn.modules.module import Module
+
+from .functional import multi_head_attention_forward
+
+
+class MultiheadAttention(Module):
+    r"""Allows the model to jointly attend to information
+    from different representation subspaces.
+    See reference: Attention Is All You Need
+
+    .. math::
+        \text{MultiHead}(Q, K, V) = \text{Concat}(head_1,\dots,head_h)W^O
+        \text{where} head_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)
+
+    Args:
+        embed_dim: total dimension of the model.
+        num_heads: parallel attention heads.
+        dropout: a Dropout layer on attn_output_weights. Default: 0.0.
+        bias: add bias as module parameter. Default: True.
+        add_bias_kv: add bias to the key and value sequences at dim=0.
+        add_zero_attn: add a new batch of zeros to the key and
+                       value sequences at dim=1.
+        kdim: total number of features in key. Default: None.
+        vdim: total number of features in key. Default: None.
+
+        Note: if kdim and vdim are None, they will be set to embed_dim such that
+        query, key, and value have the same number of features.
+
+    Examples::
+
+        >>> multihead_attn = nn.MultiheadAttention(embed_dim, num_heads)
+        >>> attn_output, attn_output_weights = multihead_attn(query, key, value)
+    """
+    __annotations__ = {
+        'bias_k': torch._jit_internal.Optional[torch.Tensor],
+        'bias_v': torch._jit_internal.Optional[torch.Tensor],
+    }
+    __constants__ = ['q_proj_weight', 'k_proj_weight', 'v_proj_weight', 'in_proj_weight']
+
+    def __init__(self, embed_dim, num_heads, dropout=0., bias=True, add_bias_kv=False, add_zero_attn=False, kdim=None, vdim=None):
+        super(MultiheadAttention, self).__init__()
+        self.embed_dim = embed_dim
+        self.kdim = kdim if kdim is not None else embed_dim
+        self.vdim = vdim if vdim is not None else embed_dim
+        self._qkv_same_embed_dim = self.kdim == embed_dim and self.vdim == embed_dim
+
+        self.num_heads = num_heads
+        self.dropout = dropout
+        self.head_dim = embed_dim // num_heads
+        assert self.head_dim * num_heads == self.embed_dim, "embed_dim must be divisible by num_heads"
+
+        if self._qkv_same_embed_dim is False:
+            self.q_proj_weight = Parameter(torch.Tensor(embed_dim, embed_dim))
+            self.k_proj_weight = Parameter(torch.Tensor(embed_dim, self.kdim))
+            self.v_proj_weight = Parameter(torch.Tensor(embed_dim, self.vdim))
+            self.register_parameter('in_proj_weight', None)
+        else:
+            self.in_proj_weight = Parameter(torch.empty(3 * embed_dim, embed_dim))
+            self.register_parameter('q_proj_weight', None)
+            self.register_parameter('k_proj_weight', None)
+            self.register_parameter('v_proj_weight', None)
+
+        if bias:
+            self.in_proj_bias = Parameter(torch.empty(3 * embed_dim))
+        else:
+            self.register_parameter('in_proj_bias', None)
+        self.out_proj = Linear(embed_dim, embed_dim, bias=bias)
+
+        if add_bias_kv:
+            self.bias_k = Parameter(torch.empty(1, 1, embed_dim))
+            self.bias_v = Parameter(torch.empty(1, 1, embed_dim))
+        else:
+            self.bias_k = self.bias_v = None
+
+        self.add_zero_attn = add_zero_attn
+
+        self._reset_parameters()
+
+    def _reset_parameters(self):
+        if self._qkv_same_embed_dim:
+            xavier_uniform_(self.in_proj_weight)
+        else:
+            xavier_uniform_(self.q_proj_weight)
+            xavier_uniform_(self.k_proj_weight)
+            xavier_uniform_(self.v_proj_weight)
+
+        if self.in_proj_bias is not None:
+            constant_(self.in_proj_bias, 0.)
+            constant_(self.out_proj.bias, 0.)
+        if self.bias_k is not None:
+            xavier_normal_(self.bias_k)
+        if self.bias_v is not None:
+            xavier_normal_(self.bias_v)
+
+    def __setstate__(self, state):
+        # Support loading old MultiheadAttention checkpoints generated by v1.1.0
+        if '_qkv_same_embed_dim' not in state:
+            state['_qkv_same_embed_dim'] = True
+
+        super(MultiheadAttention, self).__setstate__(state)
+
+    def forward(self, query, key, value, key_padding_mask=None,
+                need_weights=True, attn_mask=None):
+        # type: (Tensor, Tensor, Tensor, Optional[Tensor], bool, Optional[Tensor]) -> Tuple[Tensor, Optional[Tensor]]
+        r"""
+    Args:
+        query, key, value: map a query and a set of key-value pairs to an output.
+            See "Attention Is All You Need" for more details.
+        key_padding_mask: if provided, specified padding elements in the key will
+            be ignored by the attention. This is an binary mask. When the value is True,
+            the corresponding value on the attention layer will be filled with -inf.
+        need_weights: output attn_output_weights.
+        attn_mask: 2D or 3D mask that prevents attention to certain positions. This is an additive mask
+            (i.e. the values will be added to the attention layer). A 2D mask will be broadcasted for all
+            the batches while a 3D mask allows to specify a different mask for the entries of each batch.
+
+    Shape:
+        - Inputs:
+        - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key_padding_mask: :math:`(N, S)`, ByteTensor, where N is the batch size, S is the source sequence length.
+        - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length.
+          3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length,
+          S is the source sequence length.
+
+        - Outputs:
+        - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size,
+          E is the embedding dimension.
+        - attn_output_weights: :math:`(N, L, S)` where N is the batch size,
+          L is the target sequence length, S is the source sequence length.
+        """
+        if not self._qkv_same_embed_dim:
+            return multi_head_attention_forward(
+                query, key, value, self.embed_dim, self.num_heads,
+                self.in_proj_weight, self.in_proj_bias,
+                self.bias_k, self.bias_v, self.add_zero_attn,
+                self.dropout, self.out_proj.weight, self.out_proj.bias,
+                training=self.training,
+                key_padding_mask=key_padding_mask, need_weights=need_weights,
+                attn_mask=attn_mask, use_separate_proj_weight=True,
+                q_proj_weight=self.q_proj_weight, k_proj_weight=self.k_proj_weight,
+                v_proj_weight=self.v_proj_weight)
+        else:
+            return multi_head_attention_forward(
+                query, key, value, self.embed_dim, self.num_heads,
+                self.in_proj_weight, self.in_proj_bias,
+                self.bias_k, self.bias_v, self.add_zero_attn,
+                self.dropout, self.out_proj.weight, self.out_proj.bias,
+                training=self.training,
+                key_padding_mask=key_padding_mask, need_weights=need_weights,
+                attn_mask=attn_mask)

src/preprocessing/deepsvg/deepsvg_models/layers/functional.py

@@ -0,0 +1,261 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from __future__ import division
+
+
+import torch
+import torch.nn.functional as F
+
+
+def multi_head_attention_forward(query,                           # type: Tensor
+                                 key,                             # type: Tensor
+                                 value,                           # type: Tensor
+                                 embed_dim_to_check,              # type: int
+                                 num_heads,                       # type: int
+                                 in_proj_weight,                  # type: Tensor
+                                 in_proj_bias,                    # type: Tensor
+                                 bias_k,                          # type: Optional[Tensor]
+                                 bias_v,                          # type: Optional[Tensor]
+                                 add_zero_attn,                   # type: bool
+                                 dropout_p,                       # type: float
+                                 out_proj_weight,                 # type: Tensor
+                                 out_proj_bias,                   # type: Tensor
+                                 training=True,                   # type: bool
+                                 key_padding_mask=None,           # type: Optional[Tensor]
+                                 need_weights=True,               # type: bool
+                                 attn_mask=None,                  # type: Optional[Tensor]
+                                 use_separate_proj_weight=False,  # type: bool
+                                 q_proj_weight=None,              # type: Optional[Tensor]
+                                 k_proj_weight=None,              # type: Optional[Tensor]
+                                 v_proj_weight=None,              # type: Optional[Tensor]
+                                 static_k=None,                   # type: Optional[Tensor]
+                                 static_v=None                    # type: Optional[Tensor]
+                                 ):
+    # type: (...) -> Tuple[Tensor, Optional[Tensor]]
+    r"""
+    Args:
+        query, key, value: map a query and a set of key-value pairs to an output.
+            See "Attention Is All You Need" for more details.
+        embed_dim_to_check: total dimension of the model.
+        num_heads: parallel attention heads.
+        in_proj_weight, in_proj_bias: input projection weight and bias.
+        bias_k, bias_v: bias of the key and value sequences to be added at dim=0.
+        add_zero_attn: add a new batch of zeros to the key and
+                       value sequences at dim=1.
+        dropout_p: probability of an element to be zeroed.
+        out_proj_weight, out_proj_bias: the output projection weight and bias.
+        training: apply dropout if is ``True``.
+        key_padding_mask: if provided, specified padding elements in the key will
+            be ignored by the attention. This is an binary mask. When the value is True,
+            the corresponding value on the attention layer will be filled with -inf.
+        need_weights: output attn_output_weights.
+        attn_mask: 2D or 3D mask that prevents attention to certain positions. This is an additive mask
+            (i.e. the values will be added to the attention layer). A 2D mask will be broadcasted for all
+            the batches while a 3D mask allows to specify a different mask for the entries of each batch.
+        use_separate_proj_weight: the function accept the proj. weights for query, key,
+            and value in different forms. If false, in_proj_weight will be used, which is
+            a combination of q_proj_weight, k_proj_weight, v_proj_weight.
+        q_proj_weight, k_proj_weight, v_proj_weight, in_proj_bias: input projection weight and bias.
+        static_k, static_v: static key and value used for attention operators.
+    Shape:
+        Inputs:
+        - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key_padding_mask: :math:`(N, S)`, ByteTensor, where N is the batch size, S is the source sequence length.
+        - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length.
+          3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length,
+          S is the source sequence length.
+        - static_k: :math:`(N*num_heads, S, E/num_heads)`, where S is the source sequence length,
+          N is the batch size, E is the embedding dimension. E/num_heads is the head dimension.
+        - static_v: :math:`(N*num_heads, S, E/num_heads)`, where S is the source sequence length,
+          N is the batch size, E is the embedding dimension. E/num_heads is the head dimension.
+        Outputs:
+        - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size,
+          E is the embedding dimension.
+        - attn_output_weights: :math:`(N, L, S)` where N is the batch size,
+          L is the target sequence length, S is the source sequence length.
+    """
+
+    tgt_len, bsz, embed_dim = query.size()
+    assert embed_dim == embed_dim_to_check
+    assert key.size() == value.size()
+
+    head_dim = embed_dim // num_heads
+    assert head_dim * num_heads == embed_dim, "embed_dim must be divisible by num_heads"
+    scaling = float(head_dim) ** -0.5
+
+    if not use_separate_proj_weight:
+        if torch.equal(query, key) and torch.equal(key, value):
+            # self-attention
+            q, k, v = F.linear(query, in_proj_weight, in_proj_bias).chunk(3, dim=-1)
+
+        elif torch.equal(key, value):
+            # encoder-decoder attention
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = 0
+            _end = embed_dim
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            q = F.linear(query, _w, _b)
+
+            if key is None:
+                assert value is None
+                k = None
+                v = None
+            else:
+
+                # This is inline in_proj function with in_proj_weight and in_proj_bias
+                _b = in_proj_bias
+                _start = embed_dim
+                _end = None
+                _w = in_proj_weight[_start:, :]
+                if _b is not None:
+                    _b = _b[_start:]
+                k, v = F.linear(key, _w, _b).chunk(2, dim=-1)
+
+        else:
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = 0
+            _end = embed_dim
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            q = F.linear(query, _w, _b)
+
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = embed_dim
+            _end = embed_dim * 2
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            k = F.linear(key, _w, _b)
+
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = embed_dim * 2
+            _end = None
+            _w = in_proj_weight[_start:, :]
+            if _b is not None:
+                _b = _b[_start:]
+            v = F.linear(value, _w, _b)
+    else:
+        q_proj_weight_non_opt = torch.jit._unwrap_optional(q_proj_weight)
+        len1, len2 = q_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == query.size(-1)
+
+        k_proj_weight_non_opt = torch.jit._unwrap_optional(k_proj_weight)
+        len1, len2 = k_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == key.size(-1)
+
+        v_proj_weight_non_opt = torch.jit._unwrap_optional(v_proj_weight)
+        len1, len2 = v_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == value.size(-1)
+
+        if in_proj_bias is not None:
+            q = F.linear(query, q_proj_weight_non_opt, in_proj_bias[0:embed_dim])
+            k = F.linear(key, k_proj_weight_non_opt, in_proj_bias[embed_dim:(embed_dim * 2)])
+            v = F.linear(value, v_proj_weight_non_opt, in_proj_bias[(embed_dim * 2):])
+        else:
+            q = F.linear(query, q_proj_weight_non_opt, in_proj_bias)
+            k = F.linear(key, k_proj_weight_non_opt, in_proj_bias)
+            v = F.linear(value, v_proj_weight_non_opt, in_proj_bias)
+    q = q * scaling
+
+    if attn_mask is not None:
+        if attn_mask.dim() == 2:
+            attn_mask = attn_mask.unsqueeze(0)
+            if list(attn_mask.size()) != [1, query.size(0), key.size(0)]:
+                raise RuntimeError('The size of the 2D attn_mask is not correct.')
+        elif attn_mask.dim() == 3:
+            if list(attn_mask.size()) != [bsz * num_heads, query.size(0), key.size(0)]:
+                raise RuntimeError('The size of the 3D attn_mask is not correct.')
+        else:
+            raise RuntimeError("attn_mask's dimension {} is not supported".format(attn_mask.dim()))
+        # attn_mask's dim is 3 now.
+
+    if bias_k is not None and bias_v is not None:
+        if static_k is None and static_v is None:
+            k = torch.cat([k, bias_k.repeat(1, bsz, 1)])
+            v = torch.cat([v, bias_v.repeat(1, bsz, 1)])
+            if attn_mask is not None:
+                attn_mask = F.pad(attn_mask, (0, 1))
+            if key_padding_mask is not None:
+                key_padding_mask = F.pad(key_padding_mask, (0, 1))
+        else:
+            assert static_k is None, "bias cannot be added to static key."
+            assert static_v is None, "bias cannot be added to static value."
+    else:
+        assert bias_k is None
+        assert bias_v is None
+
+    q = q.contiguous().view(tgt_len, bsz * num_heads, head_dim).transpose(0, 1)
+    if k is not None:
+        k = k.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1)
+    if v is not None:
+        v = v.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1)
+
+    if static_k is not None:
+        assert static_k.size(0) == bsz * num_heads
+        assert static_k.size(2) == head_dim
+        k = static_k
+
+    if static_v is not None:
+        assert static_v.size(0) == bsz * num_heads
+        assert static_v.size(2) == head_dim
+        v = static_v
+
+    src_len = k.size(1)
+
+    if key_padding_mask is not None:
+        assert key_padding_mask.size(0) == bsz
+        assert key_padding_mask.size(1) == src_len
+
+    if add_zero_attn:
+        src_len += 1
+        k = torch.cat([k, torch.zeros((k.size(0), 1) + k.size()[2:], dtype=k.dtype, device=k.device)], dim=1)
+        v = torch.cat([v, torch.zeros((v.size(0), 1) + v.size()[2:], dtype=v.dtype, device=v.device)], dim=1)
+        if attn_mask is not None:
+            attn_mask = F.pad(attn_mask, (0, 1))
+        if key_padding_mask is not None:
+            key_padding_mask = F.pad(key_padding_mask, (0, 1))
+
+    attn_output_weights = torch.bmm(q, k.transpose(1, 2))
+    assert list(attn_output_weights.size()) == [bsz * num_heads, tgt_len, src_len]
+
+    if attn_mask is not None:
+        attn_output_weights += attn_mask
+
+    if key_padding_mask is not None:
+        attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len)
+        attn_output_weights = attn_output_weights.masked_fill(
+            key_padding_mask.unsqueeze(1).unsqueeze(2),
+            float('-inf'),
+        )
+        attn_output_weights = attn_output_weights.view(bsz * num_heads, tgt_len, src_len)
+
+    attn_output_weights = F.softmax(
+        attn_output_weights, dim=-1)
+    attn_output_weights = F.dropout(attn_output_weights, p=dropout_p, training=training)
+
+    attn_output = torch.bmm(attn_output_weights, v)
+    assert list(attn_output.size()) == [bsz * num_heads, tgt_len, head_dim]
+    attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
+    attn_output = F.linear(attn_output, out_proj_weight, out_proj_bias)
+
+    if need_weights:
+        # average attention weights over heads
+        attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len)
+        return attn_output, attn_output_weights.sum(dim=1) / num_heads
+    else:
+        return attn_output, None

src/preprocessing/deepsvg/deepsvg_models/layers/improved_transformer.py

@@ -0,0 +1,146 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch
+import copy
+
+from torch.nn import functional as F
+from torch.nn.modules.module import Module
+from torch.nn.modules.container import ModuleList
+from torch.nn.init import xavier_uniform_
+from torch.nn.modules.dropout import Dropout
+from torch.nn.modules.linear import Linear
+from torch.nn.modules.normalization import LayerNorm
+
+from .attention import MultiheadAttention
+from .transformer import _get_activation_fn
+
+
+class TransformerEncoderLayerImproved(Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation="relu", d_global2=None):
+        super(TransformerEncoderLayerImproved, self).__init__()
+        self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+
+        if d_global2 is not None:
+            self.linear_global2 = Linear(d_global2, d_model)
+
+        # Implementation of Feedforward model
+        self.linear1 = Linear(d_model, dim_feedforward)
+        self.dropout = Dropout(dropout)
+        self.linear2 = Linear(dim_feedforward, d_model)
+
+        self.norm1 = LayerNorm(d_model)
+        self.norm2 = LayerNorm(d_model)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2_2 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+
+    def __setstate__(self, state):
+        if 'activation' not in state:
+            state['activation'] = F.relu
+        super(TransformerEncoderLayerImproved, self).__setstate__(state)
+
+    def forward(self, src, memory2=None, src_mask=None, src_key_padding_mask=None):
+        src1 = self.norm1(src)
+        src2 = self.self_attn(src1, src1, src1, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+
+        if memory2 is not None:
+            src2_2 = self.linear_global2(memory2)
+            src = src + self.dropout2_2(src2_2)
+
+        src1 = self.norm2(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src1))))
+        src = src + self.dropout2(src2)
+        return src
+
+
+class TransformerDecoderLayerImproved(Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation="relu"):
+        super(TransformerDecoderLayerImproved, self).__init__()
+        self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = Linear(d_model, dim_feedforward)
+        self.dropout = Dropout(dropout)
+        self.linear2 = Linear(dim_feedforward, d_model)
+
+        self.norm1 = LayerNorm(d_model)
+        self.norm2 = LayerNorm(d_model)
+        self.norm3 = LayerNorm(d_model)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.dropout3 = Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+
+    def __setstate__(self, state):
+        if 'activation' not in state:
+            state['activation'] = F.relu
+        super(TransformerDecoderLayerImproved, self).__setstate__(state)
+
+    def forward(self, tgt, memory, tgt_mask=None, memory_mask=None,
+                tgt_key_padding_mask=None, memory_key_padding_mask=None):
+        tgt1 = self.norm1(tgt)
+        tgt2 = self.self_attn(tgt1, tgt1, tgt1, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+
+        tgt1 = self.norm2(tgt)
+        tgt2 = self.multihead_attn(tgt1, memory, memory, attn_mask=memory_mask, key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout2(tgt2)
+
+        tgt1 = self.norm3(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt1))))
+        tgt = tgt + self.dropout3(tgt2)
+        return tgt
+
+
+class TransformerDecoderLayerGlobalImproved(Module):
+    def __init__(self, d_model, d_global, nhead, dim_feedforward=2048, dropout=0.1, activation="relu", d_global2=None):
+        super(TransformerDecoderLayerGlobalImproved, self).__init__()
+        self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+
+        self.linear_global = Linear(d_global, d_model)
+
+        if d_global2 is not None:
+            self.linear_global2 = Linear(d_global2, d_model)
+
+        # Implementation of Feedforward model
+        self.linear1 = Linear(d_model, dim_feedforward)
+        self.dropout = Dropout(dropout)
+        self.linear2 = Linear(dim_feedforward, d_model)
+
+        self.norm1 = LayerNorm(d_model)
+        self.norm2 = LayerNorm(d_model)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.dropout2_2 = Dropout(dropout)
+        self.dropout3 = Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+
+    def __setstate__(self, state):
+        if 'activation' not in state:
+            state['activation'] = F.relu
+        super(TransformerDecoderLayerGlobalImproved, self).__setstate__(state)
+
+    def forward(self, tgt, memory, memory2=None, tgt_mask=None, tgt_key_padding_mask=None, *args, **kwargs):
+        tgt1 = self.norm1(tgt)
+        tgt2 = self.self_attn(tgt1, tgt1, tgt1, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+
+        tgt2 = self.linear_global(memory)
+        tgt = tgt + self.dropout2(tgt2)  # implicit broadcast
+
+        if memory2 is not None:
+            tgt2_2 = self.linear_global2(memory2)
+            tgt = tgt + self.dropout2_2(tgt2_2)
+
+        tgt1 = self.norm2(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt1))))
+        tgt = tgt + self.dropout3(tgt2)
+        return tgt

src/preprocessing/deepsvg/deepsvg_models/layers/positional_encoding.py

@@ -0,0 +1,48 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import math
+import torch
+import torch.nn as nn
+
+
+class PositionalEncodingSinCos(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=250):
+        super(PositionalEncodingSinCos, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        x = x + self.pe[:x.size(0), :]
+        return self.dropout(x)
+
+
+class PositionalEncodingLUT(nn.Module):
+
+    def __init__(self, d_model, dropout=0.1, max_len=250):
+        super(PositionalEncodingLUT, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        position = torch.arange(0, max_len, dtype=torch.long).unsqueeze(1)
+        self.register_buffer('position', position)
+
+        self.pos_embed = nn.Embedding(max_len, d_model)
+
+        self._init_embeddings()
+
+    def _init_embeddings(self):
+        nn.init.kaiming_normal_(self.pos_embed.weight, mode="fan_in")
+
+    def forward(self, x):
+        pos = self.position[:x.size(0)]
+        x = x + self.pos_embed(pos)
+        return self.dropout(x)

src/preprocessing/deepsvg/deepsvg_models/layers/transformer.py

@@ -0,0 +1,398 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch
+import copy
+
+from torch.nn import functional as F
+from torch.nn.modules.module import Module
+from torch.nn.modules.container import ModuleList
+from torch.nn.init import xavier_uniform_
+from torch.nn.modules.dropout import Dropout
+from torch.nn.modules.linear import Linear
+from torch.nn.modules.normalization import LayerNorm
+
+from .attention import MultiheadAttention
+
+
+class Transformer(Module):
+    r"""A transformer model. User is able to modify the attributes as needed. The architecture
+    is based on the paper "Attention Is All You Need". Ashish Vaswani, Noam Shazeer,
+    Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and
+    Illia Polosukhin. 2017. Attention is all you need. In Advances in Neural Information
+    Processing Systems, pages 6000-6010. Users can build the BERT(https://arxiv.org/abs/1810.04805)
+    model with corresponding parameters.
+
+    Args:
+        d_model: the number of expected features in the encoder/decoder inputs (default=512).
+        nhead: the number of heads in the multiheadattention models (default=8).
+        num_encoder_layers: the number of sub-encoder-layers in the encoder (default=6).
+        num_decoder_layers: the number of sub-decoder-layers in the decoder (default=6).
+        dim_feedforward: the dimension of the feedforward network model (default=2048).
+        dropout: the dropout value (default=0.1).
+        activation: the activation function of encoder/decoder intermediate layer, relu or gelu (default=relu).
+        custom_encoder: custom encoder (default=None).
+        custom_decoder: custom decoder (default=None).
+
+    Examples::
+        >>> transformer_model = nn.Transformer(nhead=16, num_encoder_layers=12)
+        >>> src = torch.rand((10, 32, 512))
+        >>> tgt = torch.rand((20, 32, 512))
+        >>> out = transformer_model(src, tgt)
+
+    Note: A full example to apply nn.Transformer module for the word language model is available in
+    https://github.com/pytorch/examples/tree/master/word_language_model
+    """
+
+    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
+                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", custom_encoder=None, custom_decoder=None):
+        super(Transformer, self).__init__()
+
+        if custom_encoder is not None:
+            self.encoder = custom_encoder
+        else:
+            encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, activation)
+            encoder_norm = LayerNorm(d_model)
+            self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+
+        if custom_decoder is not None:
+            self.decoder = custom_decoder
+        else:
+            decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout, activation)
+            decoder_norm = LayerNorm(d_model)
+            self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm)
+
+        self._reset_parameters()
+
+        self.d_model = d_model
+        self.nhead = nhead
+
+    def forward(self, src, tgt, src_mask=None, tgt_mask=None,
+                memory_mask=None, src_key_padding_mask=None,
+                tgt_key_padding_mask=None, memory_key_padding_mask=None):
+        # type: (Tensor, Tensor, Optional[Tensor], Optional[Tensor], Optional[Tensor], Optional[Tensor], Optional[Tensor], Optional[Tensor]) -> Tensor  # noqa
+        r"""Take in and process masked source/target sequences.
+
+        Args:
+            src: the sequence to the encoder (required).
+            tgt: the sequence to the decoder (required).
+            src_mask: the additive mask for the src sequence (optional).
+            tgt_mask: the additive mask for the tgt sequence (optional).
+            memory_mask: the additive mask for the encoder output (optional).
+            src_key_padding_mask: the ByteTensor mask for src keys per batch (optional).
+            tgt_key_padding_mask: the ByteTensor mask for tgt keys per batch (optional).
+            memory_key_padding_mask: the ByteTensor mask for memory keys per batch (optional).
+
+        Shape:
+            - src: :math:`(S, N, E)`.
+            - tgt: :math:`(T, N, E)`.
+            - src_mask: :math:`(S, S)`.
+            - tgt_mask: :math:`(T, T)`.
+            - memory_mask: :math:`(T, S)`.
+            - src_key_padding_mask: :math:`(N, S)`.
+            - tgt_key_padding_mask: :math:`(N, T)`.
+            - memory_key_padding_mask: :math:`(N, S)`.
+
+            Note: [src/tgt/memory]_mask should be filled with
+            float('-inf') for the masked positions and float(0.0) else. These masks
+            ensure that predictions for position i depend only on the unmasked positions
+            j and are applied identically for each sequence in a batch.
+            [src/tgt/memory]_key_padding_mask should be a ByteTensor where True values are positions
+            that should be masked with float('-inf') and False values will be unchanged.
+            This mask ensures that no information will be taken from position i if
+            it is masked, and has a separate mask for each sequence in a batch.
+
+            - output: :math:`(T, N, E)`.
+
+            Note: Due to the multi-head attention architecture in the transformer model,
+            the output sequence length of a transformer is same as the input sequence
+            (i.e. target) length of the decode.
+
+            where S is the source sequence length, T is the target sequence length, N is the
+            batch size, E is the feature number
+
+        Examples:
+            >>> output = transformer_model(src, tgt, src_mask=src_mask, tgt_mask=tgt_mask)
+        """
+
+        if src.size(1) != tgt.size(1):
+            raise RuntimeError("the batch number of src and tgt must be equal")
+
+        if src.size(2) != self.d_model or tgt.size(2) != self.d_model:
+            raise RuntimeError("the feature number of src and tgt must be equal to d_model")
+
+        memory = self.encoder(src, mask=src_mask, src_key_padding_mask=src_key_padding_mask)
+        output = self.decoder(tgt, memory, tgt_mask=tgt_mask, memory_mask=memory_mask,
+                              tgt_key_padding_mask=tgt_key_padding_mask,
+                              memory_key_padding_mask=memory_key_padding_mask)
+        return output
+
+
+    def generate_square_subsequent_mask(self, sz):
+        r"""Generate a square mask for the sequence. The masked positions are filled with float('-inf').
+            Unmasked positions are filled with float(0.0).
+        """
+        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
+        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
+        return mask
+
+
+    def _reset_parameters(self):
+        r"""Initiate parameters in the transformer model."""
+
+        for p in self.parameters():
+            if p.dim() > 1:
+                xavier_uniform_(p)
+
+
+class TransformerEncoder(Module):
+    r"""TransformerEncoder is a stack of N encoder layers
+
+    Args:
+        encoder_layer: an instance of the TransformerEncoderLayer() class (required).
+        num_layers: the number of sub-encoder-layers in the encoder (required).
+        norm: the layer normalization component (optional).
+
+    Examples::
+        >>> encoder_layer = nn.TransformerEncoderLayer(d_model=512, nhead=8)
+        >>> transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=6)
+        >>> src = torch.rand(10, 32, 512)
+        >>> out = transformer_encoder(src)
+    """
+    __constants__ = ['norm']
+
+    def __init__(self, encoder_layer, num_layers, norm=None):
+        super(TransformerEncoder, self).__init__()
+        self.layers = _get_clones(encoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+
+    def forward(self, src, memory2=None, mask=None, src_key_padding_mask=None):
+        # type: (Tensor, Optional[Tensor], Optional[Tensor], Optional[Tensor]) -> Tensor
+        r"""Pass the input through the encoder layers in turn.
+
+        Args:
+            src: the sequence to the encoder (required).
+            mask: the mask for the src sequence (optional).
+            src_key_padding_mask: the mask for the src keys per batch (optional).
+
+        Shape:
+            see the docs in Transformer class.
+        """
+        output = src
+
+        for mod in self.layers:
+            output = mod(output, memory2=memory2, src_mask=mask, src_key_padding_mask=src_key_padding_mask)
+
+        if self.norm is not None:
+            output = self.norm(output)
+
+        return output
+
+
+class TransformerDecoder(Module):
+    r"""TransformerDecoder is a stack of N decoder layers
+
+    Args:
+        decoder_layer: an instance of the TransformerDecoderLayer() class (required).
+        num_layers: the number of sub-decoder-layers in the decoder (required).
+        norm: the layer normalization component (optional).
+
+    Examples::
+        >>> decoder_layer = nn.TransformerDecoderLayer(d_model=512, nhead=8)
+        >>> transformer_decoder = nn.TransformerDecoder(decoder_layer, num_layers=6)
+        >>> memory = torch.rand(10, 32, 512)
+        >>> tgt = torch.rand(20, 32, 512)
+        >>> out = transformer_decoder(tgt, memory)
+    """
+    __constants__ = ['norm']
+
+    def __init__(self, decoder_layer, num_layers, norm=None):
+        super(TransformerDecoder, self).__init__()
+        self.layers = _get_clones(decoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+
+    def forward(self, tgt, memory, memory2=None, tgt_mask=None,
+                memory_mask=None, tgt_key_padding_mask=None,
+                memory_key_padding_mask=None):
+        # type: (Tensor, Tensor, Optional[Tensor], Optional[Tensor], Optional[Tensor], Optional[Tensor], Optional[Tensor]) -> Tensor
+        r"""Pass the inputs (and mask) through the decoder layer in turn.
+
+        Args:
+            tgt: the sequence to the decoder (required).
+            memory: the sequence from the last layer of the encoder (required).
+            tgt_mask: the mask for the tgt sequence (optional).
+            memory_mask: the mask for the memory sequence (optional).
+            tgt_key_padding_mask: the mask for the tgt keys per batch (optional).
+            memory_key_padding_mask: the mask for the memory keys per batch (optional).
+
+        Shape:
+            see the docs in Transformer class.
+        """
+        output = tgt
+
+        for mod in self.layers:
+            output = mod(output, memory, memory2=memory2, tgt_mask=tgt_mask,
+                         memory_mask=memory_mask,
+                         tgt_key_padding_mask=tgt_key_padding_mask,
+                         memory_key_padding_mask=memory_key_padding_mask)
+
+        if self.norm is not None:
+            output = self.norm(output)
+
+        return output
+
+
+class TransformerEncoderLayer(Module):
+    r"""TransformerEncoderLayer is made up of self-attn and feedforward network.
+    This standard encoder layer is based on the paper "Attention Is All You Need".
+    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,
+    Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in
+    Neural Information Processing Systems, pages 6000-6010. Users may modify or implement
+    in a different way during application.
+
+    Args:
+        d_model: the number of expected features in the input (required).
+        nhead: the number of heads in the multiheadattention models (required).
+        dim_feedforward: the dimension of the feedforward network model (default=2048).
+        dropout: the dropout value (default=0.1).
+        activation: the activation function of intermediate layer, relu or gelu (default=relu).
+
+    Examples::
+        >>> encoder_layer = nn.TransformerEncoderLayer(d_model=512, nhead=8)
+        >>> src = torch.rand(10, 32, 512)
+        >>> out = encoder_layer(src)
+    """
+
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation="relu"):
+        super(TransformerEncoderLayer, self).__init__()
+        self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = Linear(d_model, dim_feedforward)
+        self.dropout = Dropout(dropout)
+        self.linear2 = Linear(dim_feedforward, d_model)
+
+        self.norm1 = LayerNorm(d_model)
+        self.norm2 = LayerNorm(d_model)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+
+    def __setstate__(self, state):
+        if 'activation' not in state:
+            state['activation'] = F.relu
+        super(TransformerEncoderLayer, self).__setstate__(state)
+
+    def forward(self, src, src_mask=None, src_key_padding_mask=None):
+        # type: (Tensor, Optional[Tensor], Optional[Tensor]) -> Tensor
+        r"""Pass the input through the encoder layer.
+
+        Args:
+            src: the sequence to the encoder layer (required).
+            src_mask: the mask for the src sequence (optional).
+            src_key_padding_mask: the mask for the src keys per batch (optional).
+
+        Shape:
+            see the docs in Transformer class.
+        """
+        src2 = self.self_attn(src, src, src, attn_mask=src_mask,
+                              key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+        src = self.norm1(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
+        src = src + self.dropout2(src2)
+        src = self.norm2(src)
+        return src
+
+
+class TransformerDecoderLayer(Module):
+    r"""TransformerDecoderLayer is made up of self-attn, multi-head-attn and feedforward network.
+    This standard decoder layer is based on the paper "Attention Is All You Need".
+    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,
+    Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in
+    Neural Information Processing Systems, pages 6000-6010. Users may modify or implement
+    in a different way during application.
+
+    Args:
+        d_model: the number of expected features in the input (required).
+        nhead: the number of heads in the multiheadattention models (required).
+        dim_feedforward: the dimension of the feedforward network model (default=2048).
+        dropout: the dropout value (default=0.1).
+        activation: the activation function of intermediate layer, relu or gelu (default=relu).
+
+    Examples::
+        >>> decoder_layer = nn.TransformerDecoderLayer(d_model=512, nhead=8)
+        >>> memory = torch.rand(10, 32, 512)
+        >>> tgt = torch.rand(20, 32, 512)
+        >>> out = decoder_layer(tgt, memory)
+    """
+
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation="relu"):
+        super(TransformerDecoderLayer, self).__init__()
+        self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = Linear(d_model, dim_feedforward)
+        self.dropout = Dropout(dropout)
+        self.linear2 = Linear(dim_feedforward, d_model)
+
+        self.norm1 = LayerNorm(d_model)
+        self.norm2 = LayerNorm(d_model)
+        self.norm3 = LayerNorm(d_model)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.dropout3 = Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+
+    def __setstate__(self, state):
+        if 'activation' not in state:
+            state['activation'] = F.relu
+        super(TransformerDecoderLayer, self).__setstate__(state)
+
+    def forward(self, tgt, memory, tgt_mask=None, memory_mask=None,
+                tgt_key_padding_mask=None, memory_key_padding_mask=None):
+        # type: (Tensor, Tensor, Optional[Tensor], Optional[Tensor], Optional[Tensor], Optional[Tensor]) -> Tensor
+        r"""Pass the inputs (and mask) through the decoder layer.
+
+        Args:
+            tgt: the sequence to the decoder layer (required).
+            memory: the sequence from the last layer of the encoder (required).
+            tgt_mask: the mask for the tgt sequence (optional).
+            memory_mask: the mask for the memory sequence (optional).
+            tgt_key_padding_mask: the mask for the tgt keys per batch (optional).
+            memory_key_padding_mask: the mask for the memory keys per batch (optional).
+
+        Shape:
+            see the docs in Transformer class.
+        """
+        tgt2 = self.self_attn(tgt, tgt, tgt, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt = self.norm1(tgt)
+        tgt2 = self.multihead_attn(tgt, memory, memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt = self.norm2(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
+        tgt = tgt + self.dropout3(tgt2)
+        tgt = self.norm3(tgt)
+        return tgt
+
+
+def _get_clones(module, N):
+    return ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+def _get_activation_fn(activation):
+    if activation == "relu":
+        return F.relu
+    elif activation == "gelu":
+        return F.gelu
+
+    raise RuntimeError("activation should be relu/gelu, not {}".format(activation))

src/preprocessing/deepsvg/deepsvg_models/loss.py

@@ -0,0 +1,70 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from src.preprocessing.deepsvg.deepsvg_difflib.tensor import SVGTensor
+from .model_utils import _get_padding_mask, _get_visibility_mask
+from .model_config import _DefaultConfig
+
+
+class SVGLoss(nn.Module):
+    def __init__(self, cfg: _DefaultConfig):
+        super().__init__()
+
+        self.cfg = cfg
+
+        self.args_dim = 2 * cfg.args_dim if cfg.rel_targets else cfg.args_dim + 1
+
+        self.register_buffer("cmd_args_mask", SVGTensor.CMD_ARGS_MASK)
+
+    def forward(self, output, labels, weights):
+        loss = 0.
+        res = {}
+
+        # VAE
+        if self.cfg.use_vae:
+            mu, logsigma = output["mu"], output["logsigma"]
+            loss_kl = -0.5 * torch.mean(1 + logsigma - mu.pow(2) - torch.exp(logsigma))
+            loss_kl = loss_kl.clamp(min=weights["kl_tolerance"])
+
+            loss += weights["loss_kl_weight"] * loss_kl
+            res["loss_kl"] = loss_kl
+
+        # Target & predictions
+        tgt_commands, tgt_args = output["tgt_commands"], output["tgt_args"]
+
+        visibility_mask = _get_visibility_mask(tgt_commands, seq_dim=-1)
+        padding_mask = _get_padding_mask(tgt_commands, seq_dim=-1, extended=True) * visibility_mask.unsqueeze(-1)
+
+        command_logits, args_logits = output["command_logits"], output["args_logits"]
+
+        # 2-stage visibility
+        if self.cfg.decode_stages == 2:
+            visibility_logits = output["visibility_logits"]
+            loss_visibility = F.cross_entropy(visibility_logits.reshape(-1, 2), visibility_mask.reshape(-1).long())
+
+            loss += weights["loss_visibility_weight"] * loss_visibility
+            res["loss_visibility"] = loss_visibility
+
+        # Commands & args
+        tgt_commands, tgt_args, padding_mask = tgt_commands[..., 1:], tgt_args[..., 1:, :], padding_mask[..., 1:]
+
+        mask = self.cmd_args_mask[tgt_commands.long()]
+
+        loss_cmd = F.cross_entropy(command_logits[padding_mask.bool()].reshape(-1, self.cfg.n_commands), tgt_commands[padding_mask.bool()].reshape(-1).long())
+        loss_args = F.cross_entropy(args_logits[mask.bool()].reshape(-1, self.args_dim), tgt_args[mask.bool()].reshape(-1).long() + 1)  # shift due to -1 PAD_VAL
+
+        loss += weights["loss_cmd_weight"] * loss_cmd \
+                + weights["loss_args_weight"] * loss_args
+
+        res.update({
+            "loss": loss,
+            "loss_cmd": loss_cmd,
+            "loss_args": loss_args
+        })
+
+        return res

src/preprocessing/deepsvg/deepsvg_models/model.py

@@ -0,0 +1,484 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from src.preprocessing.deepsvg.deepsvg_difflib.tensor import SVGTensor
+from src.preprocessing.deepsvg.deepsvg_utils.utils import _pack_group_batch, _unpack_group_batch, _make_seq_first, _make_batch_first
+
+from .layers.transformer import *
+from .layers.improved_transformer import *
+from .layers.positional_encoding import *
+from .basic_blocks import FCN, HierarchFCN, ResNet
+from .model_config import _DefaultConfig
+from .model_utils import (_get_padding_mask, _get_key_padding_mask, _get_group_mask, _get_visibility_mask,
+                    _get_key_visibility_mask, _generate_square_subsequent_mask, _sample_categorical, _threshold_sample)
+
+from torch.nn.utils.rnn import pad_packed_sequence, pack_padded_sequence
+from scipy.optimize import linear_sum_assignment
+
+
+class SVGEmbedding(nn.Module):
+    def __init__(self, cfg: _DefaultConfig, seq_len, rel_args=False, use_group=True, group_len=None):
+        super().__init__()
+
+        self.cfg = cfg
+
+        self.command_embed = nn.Embedding(cfg.n_commands, cfg.d_model)
+
+        args_dim = 2 * cfg.args_dim if rel_args else cfg.args_dim + 1
+        self.arg_embed = nn.Embedding(args_dim, 64)
+        self.embed_fcn = nn.Linear(64 * cfg.n_args, cfg.d_model)
+
+        self.use_group = use_group
+        if use_group:
+            if group_len is None:
+                group_len = cfg.max_num_groups
+            self.group_embed = nn.Embedding(group_len+2, cfg.d_model)
+
+        self.pos_encoding = PositionalEncodingLUT(cfg.d_model, max_len=seq_len+2)
+
+        self._init_embeddings()
+
+    def _init_embeddings(self):
+        nn.init.kaiming_normal_(self.command_embed.weight, mode="fan_in")
+        nn.init.kaiming_normal_(self.arg_embed.weight, mode="fan_in")
+        nn.init.kaiming_normal_(self.embed_fcn.weight, mode="fan_in")
+
+        if self.use_group:
+            nn.init.kaiming_normal_(self.group_embed.weight, mode="fan_in")
+
+    def forward(self, commands, args, groups=None):
+        S, GN = commands.shape
+
+        src = self.command_embed(commands.long()) + \
+              self.embed_fcn(self.arg_embed((args + 1).long()).view(S, GN, -1))  # shift due to -1 PAD_VAL
+
+        if self.use_group:
+            src = src + self.group_embed(groups.long())
+
+        src = self.pos_encoding(src)
+
+        return src
+
+
+class ConstEmbedding(nn.Module):
+    def __init__(self, cfg: _DefaultConfig, seq_len):
+        super().__init__()
+
+        self.cfg = cfg
+
+        self.seq_len = seq_len
+
+        self.PE = PositionalEncodingLUT(cfg.d_model, max_len=seq_len)
+
+    def forward(self, z):
+        N = z.size(1)
+        src = self.PE(z.new_zeros(self.seq_len, N, self.cfg.d_model))
+        return src
+
+
+class LabelEmbedding(nn.Module):
+    def __init__(self, cfg: _DefaultConfig):
+        super().__init__()
+
+        self.label_embedding = nn.Embedding(cfg.n_labels, cfg.dim_label)
+
+        self._init_embeddings()
+
+    def _init_embeddings(self):
+        nn.init.kaiming_normal_(self.label_embedding.weight, mode="fan_in")
+
+    def forward(self, label):
+        src = self.label_embedding(label)
+        return src
+
+
+class Encoder(nn.Module):
+    def __init__(self, cfg: _DefaultConfig):
+        super().__init__()
+
+        self.cfg = cfg
+
+        seq_len = cfg.max_seq_len if cfg.encode_stages == 2 else cfg.max_total_len
+        self.use_group = cfg.encode_stages == 1
+        self.embedding = SVGEmbedding(cfg, seq_len, use_group=self.use_group)
+
+        if cfg.label_condition:
+            self.label_embedding = LabelEmbedding(cfg)
+        dim_label = cfg.dim_label if cfg.label_condition else None
+
+        if cfg.model_type == "transformer":
+            encoder_layer = TransformerEncoderLayerImproved(cfg.d_model, cfg.n_heads, cfg.dim_feedforward, cfg.dropout, d_global2=dim_label)
+            encoder_norm = LayerNorm(cfg.d_model)
+            self.encoder = TransformerEncoder(encoder_layer, cfg.n_layers, encoder_norm)
+        else:  # "lstm"
+            self.encoder = nn.LSTM(cfg.d_model, cfg.d_model // 2, dropout=cfg.dropout, bidirectional=True)
+
+        if cfg.encode_stages == 2:
+            if not cfg.self_match:
+                self.hierarchical_PE = PositionalEncodingLUT(cfg.d_model, max_len=cfg.max_num_groups)
+
+            hierarchical_encoder_layer = TransformerEncoderLayerImproved(cfg.d_model, cfg.n_heads, cfg.dim_feedforward, cfg.dropout, d_global2=dim_label)
+            hierarchical_encoder_norm = LayerNorm(cfg.d_model)
+            self.hierarchical_encoder = TransformerEncoder(hierarchical_encoder_layer, cfg.n_layers, hierarchical_encoder_norm)
+
+    def forward(self, commands, args, label=None):
+        S, G, N = commands.shape
+        l = self.label_embedding(label).unsqueeze(0).unsqueeze(0).repeat(1, commands.size(1), 1, 1) if self.cfg.label_condition else None
+
+        if self.cfg.encode_stages == 2:
+            visibility_mask, key_visibility_mask = _get_visibility_mask(commands, seq_dim=0), _get_key_visibility_mask(commands, seq_dim=0)
+
+        commands, args, l = _pack_group_batch(commands, args, l)
+        padding_mask, key_padding_mask = _get_padding_mask(commands, seq_dim=0), _get_key_padding_mask(commands, seq_dim=0)
+        group_mask = _get_group_mask(commands, seq_dim=0) if self.use_group else None
+
+        src = self.embedding(commands, args, group_mask)
+
+        if self.cfg.model_type == "transformer":
+            memory = self.encoder(src, mask=None, src_key_padding_mask=key_padding_mask, memory2=l)
+
+            z = (memory * padding_mask).sum(dim=0, keepdim=True) / padding_mask.sum(dim=0, keepdim=True)
+        else:  # "lstm"
+            hidden_cell = (src.new_zeros(2, N, self.cfg.d_model // 2),
+                           src.new_zeros(2, N, self.cfg.d_model // 2))
+            sequence_lengths = padding_mask.sum(dim=0).squeeze(-1)
+            x = pack_padded_sequence(src, sequence_lengths, enforce_sorted=False)
+
+            packed_output, _ = self.encoder(x, hidden_cell)
+
+            memory, _ = pad_packed_sequence(packed_output)
+            idx = (sequence_lengths - 1).long().view(1, -1, 1).repeat(1, 1, self.cfg.d_model)
+            z = memory.gather(dim=0, index=idx)
+
+        z = _unpack_group_batch(N, z)
+
+        if self.cfg.encode_stages == 2:
+            src = z.transpose(0, 1)
+            src = _pack_group_batch(src)
+            l = self.label_embedding(label).unsqueeze(0) if self.cfg.label_condition else None
+
+            if not self.cfg.self_match:
+                src = self.hierarchical_PE(src)
+
+            memory = self.hierarchical_encoder(src, mask=None, src_key_padding_mask=key_visibility_mask, memory2=l)
+            z = (memory * visibility_mask).sum(dim=0, keepdim=True) / visibility_mask.sum(dim=0, keepdim=True)
+            z = _unpack_group_batch(N, z)
+
+        return z
+
+
+class VAE(nn.Module):
+    def __init__(self, cfg: _DefaultConfig):
+        super(VAE, self).__init__()
+
+        self.enc_mu_fcn = nn.Linear(cfg.d_model, cfg.dim_z)
+        self.enc_sigma_fcn = nn.Linear(cfg.d_model, cfg.dim_z)
+
+        self._init_embeddings()
+
+    def _init_embeddings(self):
+        nn.init.normal_(self.enc_mu_fcn.weight, std=0.001)
+        nn.init.constant_(self.enc_mu_fcn.bias, 0)
+        nn.init.normal_(self.enc_sigma_fcn.weight, std=0.001)
+        nn.init.constant_(self.enc_sigma_fcn.bias, 0)
+
+    def forward(self, z):
+        mu, logsigma = self.enc_mu_fcn(z), self.enc_sigma_fcn(z)
+        sigma = torch.exp(logsigma / 2.)
+        z = mu + sigma * torch.randn_like(sigma)
+
+        return z, mu, logsigma
+
+
+class Bottleneck(nn.Module):
+    def __init__(self, cfg: _DefaultConfig):
+        super(Bottleneck, self).__init__()
+
+        self.bottleneck = nn.Linear(cfg.d_model, cfg.dim_z)
+
+    def forward(self, z):
+        return self.bottleneck(z)
+
+
+class Decoder(nn.Module):
+    def __init__(self, cfg: _DefaultConfig):
+        super(Decoder, self).__init__()
+
+        self.cfg = cfg
+
+        if cfg.label_condition:
+            self.label_embedding = LabelEmbedding(cfg)
+        dim_label = cfg.dim_label if cfg.label_condition else None
+
+        if cfg.decode_stages == 2:
+            self.hierarchical_embedding = ConstEmbedding(cfg, cfg.num_groups_proposal)
+
+            hierarchical_decoder_layer = TransformerDecoderLayerGlobalImproved(cfg.d_model, cfg.dim_z, cfg.n_heads, cfg.dim_feedforward, cfg.dropout, d_global2=dim_label)
+            hierarchical_decoder_norm = LayerNorm(cfg.d_model)
+            self.hierarchical_decoder = TransformerDecoder(hierarchical_decoder_layer, cfg.n_layers_decode, hierarchical_decoder_norm)
+            self.hierarchical_fcn = HierarchFCN(cfg.d_model, cfg.dim_z)
+
+        if cfg.pred_mode == "autoregressive":
+            self.embedding = SVGEmbedding(cfg, cfg.max_total_len, rel_args=cfg.rel_targets, use_group=True, group_len=cfg.max_total_len)
+
+            square_subsequent_mask = _generate_square_subsequent_mask(self.cfg.max_total_len+1)
+            self.register_buffer("square_subsequent_mask", square_subsequent_mask)
+        else:  # "one_shot"
+            seq_len = cfg.max_seq_len+1 if cfg.decode_stages == 2 else cfg.max_total_len+1
+            self.embedding = ConstEmbedding(cfg, seq_len)
+
+        if cfg.model_type == "transformer":
+            decoder_layer = TransformerDecoderLayerGlobalImproved(cfg.d_model, cfg.dim_z, cfg.n_heads, cfg.dim_feedforward, cfg.dropout, d_global2=dim_label)
+            decoder_norm = LayerNorm(cfg.d_model)
+            self.decoder = TransformerDecoder(decoder_layer, cfg.n_layers_decode, decoder_norm)
+        else:  # "lstm"
+            self.fc_hc = nn.Linear(cfg.dim_z, 2 * cfg.d_model)
+            self.decoder = nn.LSTM(cfg.d_model, cfg.d_model, dropout=cfg.dropout)
+
+        args_dim = 2 * cfg.args_dim if cfg.rel_targets else cfg.args_dim + 1
+        self.fcn = FCN(cfg.d_model, cfg.n_commands, cfg.n_args, args_dim)
+
+    def _get_initial_state(self, z):
+        hidden, cell = torch.split(torch.tanh(self.fc_hc(z)), self.cfg.d_model, dim=2)
+        hidden_cell = hidden.contiguous(), cell.contiguous()
+        return hidden_cell
+
+    def forward(self, z, commands, args, label=None, hierarch_logits=None, return_hierarch=False):
+        N = z.size(2)
+        l = self.label_embedding(label).unsqueeze(0) if self.cfg.label_condition else None
+        if hierarch_logits is None:
+            z = _pack_group_batch(z)
+
+        if self.cfg.decode_stages == 2:
+            if hierarch_logits is None:
+                src = self.hierarchical_embedding(z)
+                out = self.hierarchical_decoder(src, z, tgt_mask=None, tgt_key_padding_mask=None, memory2=l)
+                hierarch_logits, z = self.hierarchical_fcn(out)
+
+            if self.cfg.label_condition: l = l.unsqueeze(0).repeat(1, z.size(1), 1, 1)
+
+            hierarch_logits, z, l = _pack_group_batch(hierarch_logits, z, l)
+
+            if return_hierarch:
+                return _unpack_group_batch(N, hierarch_logits, z)
+
+        if self.cfg.pred_mode == "autoregressive":
+            S = commands.size(0)
+            commands, args = _pack_group_batch(commands, args)
+
+            group_mask = _get_group_mask(commands, seq_dim=0)
+
+            src = self.embedding(commands, args, group_mask)
+
+            if self.cfg.model_type == "transformer":
+                key_padding_mask = _get_key_padding_mask(commands, seq_dim=0)
+                out = self.decoder(src, z, tgt_mask=self.square_subsequent_mask[:S, :S], tgt_key_padding_mask=key_padding_mask, memory2=l)
+            else:  # "lstm"
+                hidden_cell = self._get_initial_state(z)
+                out, _ = self.decoder(src, hidden_cell)
+
+        else:  # "one_shot"
+            src = self.embedding(z)
+            out = self.decoder(src, z, tgt_mask=None, tgt_key_padding_mask=None, memory2=l)
+
+        command_logits, args_logits = self.fcn(out)
+
+        out_logits = (command_logits, args_logits) + ((hierarch_logits,) if self.cfg.decode_stages == 2 else ())
+
+        return _unpack_group_batch(N, *out_logits)
+
+
+class SVGTransformer(nn.Module):
+    def __init__(self, cfg: _DefaultConfig):
+        super(SVGTransformer, self).__init__()
+
+        self.cfg = cfg
+        self.args_dim = 2 * cfg.args_dim if cfg.rel_targets else cfg.args_dim + 1
+
+        if self.cfg.encode_stages > 0:
+
+            self.encoder = Encoder(cfg)
+
+            if cfg.use_resnet:
+                self.resnet = ResNet(cfg.d_model)
+
+            if cfg.use_vae:
+                self.vae = VAE(cfg)
+            else:
+                self.bottleneck = Bottleneck(cfg)
+
+        self.decoder = Decoder(cfg)
+
+        self.register_buffer("cmd_args_mask", SVGTensor.CMD_ARGS_MASK)
+
+    def perfect_matching(self, command_logits, args_logits, hierarch_logits, tgt_commands, tgt_args):
+        with torch.no_grad():
+            N, G, S, n_args = tgt_args.shape
+            visibility_mask = _get_visibility_mask(tgt_commands, seq_dim=-1)
+            padding_mask = _get_padding_mask(tgt_commands, seq_dim=-1, extended=True) * visibility_mask.unsqueeze(-1)
+
+            # Unsqueeze
+            tgt_commands, tgt_args, tgt_hierarch = tgt_commands.unsqueeze(2), tgt_args.unsqueeze(2), visibility_mask.unsqueeze(2)
+            command_logits, args_logits, hierarch_logits = command_logits.unsqueeze(1), args_logits.unsqueeze(1), hierarch_logits.unsqueeze(1).squeeze(-2)
+
+            # Loss
+            tgt_hierarch, hierarch_logits = tgt_hierarch.repeat(1, 1, self.cfg.num_groups_proposal), hierarch_logits.repeat(1, G, 1, 1)
+            tgt_commands, command_logits = tgt_commands.repeat(1, 1, self.cfg.num_groups_proposal, 1), command_logits.repeat(1, G, 1, 1, 1)
+            tgt_args, args_logits = tgt_args.repeat(1, 1, self.cfg.num_groups_proposal, 1, 1), args_logits.repeat(1, G, 1, 1, 1, 1)
+
+            padding_mask, mask = padding_mask.unsqueeze(2).repeat(1, 1, self.cfg.num_groups_proposal, 1), self.cmd_args_mask[tgt_commands.long()]
+
+            loss_args = F.cross_entropy(args_logits.reshape(-1, self.args_dim), tgt_args.reshape(-1).long() + 1, reduction="none").reshape(N, G, self.cfg.num_groups_proposal, S, n_args)    # shift due to -1 PAD_VAL
+            loss_cmd = F.cross_entropy(command_logits.reshape(-1, self.cfg.n_commands), tgt_commands.reshape(-1).long(), reduction="none").reshape(N, G, self.cfg.num_groups_proposal, S)
+            loss_hierarch = F.cross_entropy(hierarch_logits.reshape(-1, 2), tgt_hierarch.reshape(-1).long(), reduction="none").reshape(N, G, self.cfg.num_groups_proposal)
+
+            loss_args = (loss_args * mask).sum(dim=[-1, -2]) / mask.sum(dim=[-1, -2])
+            loss_cmd = (loss_cmd * padding_mask).sum(dim=-1) / padding_mask.sum(dim=-1)
+
+            loss = 2.0 * loss_args + 1.0 * loss_cmd + 1.0 * loss_hierarch
+
+        # Iterate over the batch-dimension
+        assignment_list = []
+
+        full_set = set(range(self.cfg.num_groups_proposal))
+        for i in range(N):
+            costs = loss[i]
+            mask = visibility_mask[i]
+            _, assign = linear_sum_assignment(costs[mask].cpu())
+            assign = assign.tolist()
+            assignment_list.append(assign + list(full_set - set(assign)))
+
+        assignment = torch.tensor(assignment_list, device=command_logits.device)
+
+        return assignment.unsqueeze(-1).unsqueeze(-1)
+
+    def forward(self, commands_enc, args_enc, commands_dec, args_dec, label=None,
+                z=None, hierarch_logits=None,
+                return_tgt=True, params=None, encode_mode=False, return_hierarch=False):
+        commands_enc, args_enc = _make_seq_first(commands_enc, args_enc)  # Possibly None, None
+        commands_dec_, args_dec_ = _make_seq_first(commands_dec, args_dec)
+
+        if z is None:
+            z = self.encoder(commands_enc, args_enc, label)
+
+            if self.cfg.use_resnet:
+                z = self.resnet(z)
+
+            if self.cfg.use_vae:
+                z, mu, logsigma = self.vae(z)
+            else:
+                z = self.bottleneck(z)
+        else:
+            z = _make_seq_first(z)
+
+        if encode_mode: return z
+
+        if return_tgt:  # Train mode
+            commands_dec_, args_dec_ = commands_dec_[:-1], args_dec_[:-1]
+
+        out_logits = self.decoder(z, commands_dec_, args_dec_, label, hierarch_logits=hierarch_logits,
+                                  return_hierarch=return_hierarch)
+
+        if return_hierarch:
+            return out_logits
+
+        out_logits = _make_batch_first(*out_logits)
+
+        if return_tgt and self.cfg.self_match:  # Assignment
+            assert self.cfg.decode_stages == 2  # Self-matching expects two-stage decoder
+            command_logits, args_logits, hierarch_logits = out_logits
+
+            assignment = self.perfect_matching(command_logits, args_logits, hierarch_logits, commands_dec[..., 1:], args_dec[..., 1:, :])
+
+            command_logits = torch.gather(command_logits, dim=1, index=assignment.expand_as(command_logits))
+            args_logits = torch.gather(args_logits, dim=1, index=assignment.unsqueeze(-1).expand_as(args_logits))
+            hierarch_logits = torch.gather(hierarch_logits, dim=1, index=assignment.expand_as(hierarch_logits))
+
+            out_logits = (command_logits, args_logits, hierarch_logits)
+
+        res = {
+            "command_logits": out_logits[0],
+            "args_logits": out_logits[1]
+        }
+
+        if self.cfg.decode_stages == 2:
+            res["visibility_logits"] = out_logits[2]
+
+        if return_tgt:
+            res["tgt_commands"] = commands_dec
+            res["tgt_args"] = args_dec
+
+            if self.cfg.use_vae:
+                res["mu"] = _make_batch_first(mu)
+                res["logsigma"] = _make_batch_first(logsigma)
+
+        return res
+
+    def greedy_sample(self, commands_enc=None, args_enc=None, commands_dec=None, args_dec=None, label=None,
+                      z=None, hierarch_logits=None,
+                      concat_groups=True, temperature=0.0001):
+        if self.cfg.pred_mode == "one_shot":
+            res = self.forward(commands_enc, args_enc, commands_dec, args_dec, label=label, z=z, hierarch_logits=hierarch_logits, return_tgt=False)
+            commands_y, args_y = _sample_categorical(temperature, res["command_logits"], res["args_logits"])
+            args_y -= 1  # shift due to -1 PAD_VAL
+            visibility_y = _threshold_sample(res["visibility_logits"], threshold=0.7).bool().squeeze(-1) if self.cfg.decode_stages == 2 else None
+            commands_y, args_y = self._make_valid(commands_y, args_y, visibility_y)
+        else:
+            if z is None:
+                z = self.forward(commands_enc, args_enc, None, None, label=label, encode_mode=True)
+
+            PAD_VAL = -1
+            commands_y, args_y = z.new_zeros(1, 1, 1).fill_(SVGTensor.COMMANDS_SIMPLIFIED.index("SOS")).long(), z.new_ones(1, 1, 1, self.cfg.n_args).fill_(PAD_VAL).long()
+
+            for i in range(self.cfg.max_total_len):
+                res = self.forward(None, None, commands_y, args_y, label=label, z=z, hierarch_logits=hierarch_logits, return_tgt=False)
+                commands_new_y, args_new_y = _sample_categorical(temperature, res["command_logits"], res["args_logits"])
+                args_new_y -= 1  # shift due to -1 PAD_VAL
+                _, args_new_y = self._make_valid(commands_new_y, args_new_y)
+
+                commands_y, args_y = torch.cat([commands_y, commands_new_y[..., -1:]], dim=-1), torch.cat([args_y, args_new_y[..., -1:, :]], dim=-2)
+
+            commands_y, args_y = commands_y[..., 1:], args_y[..., 1:, :]  # Discard SOS token
+
+        if self.cfg.rel_targets:
+            args_y = self._make_absolute(commands_y, args_y)
+
+        if concat_groups:
+            N = commands_y.size(0)
+            padding_mask_y = _get_padding_mask(commands_y, seq_dim=-1).bool()
+            commands_y, args_y = commands_y[padding_mask_y].reshape(N, -1), args_y[padding_mask_y].reshape(N, -1, self.cfg.n_args)
+
+        return commands_y, args_y
+
+    def _make_valid(self, commands_y, args_y, visibility_y=None, PAD_VAL=-1):
+        if visibility_y is not None:
+            S = commands_y.size(-1)
+            commands_y[~visibility_y] = commands_y.new_tensor([SVGTensor.COMMANDS_SIMPLIFIED.index("m"), *[SVGTensor.COMMANDS_SIMPLIFIED.index("EOS")] * (S - 1)])
+            args_y[~visibility_y] = PAD_VAL
+
+        mask = self.cmd_args_mask[commands_y.long()].bool()
+        args_y[~mask] = PAD_VAL
+
+        return commands_y, args_y
+
+    def _make_absolute(self, commands_y, args_y):
+
+        mask = self.cmd_args_mask[commands_y.long()].bool()
+        args_y[mask] -= self.cfg.args_dim - 1
+
+        real_commands = commands_y < SVGTensor.COMMANDS_SIMPLIFIED.index("EOS")
+
+        args_real_commands = args_y[real_commands]
+        end_pos = args_real_commands[:-1, SVGTensor.IndexArgs.END_POS].cumsum(dim=0)
+
+        args_real_commands[1:, SVGTensor.IndexArgs.CONTROL1] += end_pos
+        args_real_commands[1:, SVGTensor.IndexArgs.CONTROL2] += end_pos
+        args_real_commands[1:, SVGTensor.IndexArgs.END_POS] += end_pos
+
+        args_y[real_commands] = args_real_commands
+
+        _, args_y = self._make_valid(commands_y, args_y)
+
+        return args_y

src/preprocessing/deepsvg/deepsvg_models/model_config.py

@@ -0,0 +1,113 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from src.preprocessing.deepsvg.deepsvg_difflib.tensor import SVGTensor
+
+
+class _DefaultConfig:
+    """
+    Model config.
+    """
+    def __init__(self):
+        self.args_dim = 256              # Coordinate numericalization, default: 256 (8-bit)
+        self.n_args = 11                 # Tensor nb of arguments, default: 11 (rx,ry,phi,fA,fS,qx1,qy1,qx2,qy2,x1,x2)
+        self.n_commands = len(SVGTensor.COMMANDS_SIMPLIFIED)  # m, l, c, a, EOS, SOS, z
+
+        self.dropout = 0.1                # Dropout rate used in basic layers and Transformers
+
+        self.model_type = "transformer"  # "transformer" ("lstm" implementation is work in progress)
+
+        self.encode_stages = 1           # One-stage or two-stage: 1 | 2
+        self.decode_stages = 1           # One-stage or two-stage: 1 | 2
+
+        self.use_resnet = True           # Use extra fully-connected residual blocks after Encoder
+
+        self.use_vae = True              # Sample latent vector (with reparametrization trick) or use encodings directly
+
+        self.pred_mode = "one_shot"      # Feed-forward (one-shot) or autogressive: "one_shot" | "autoregressive"
+        self.rel_targets = False         # Predict coordinates in relative or absolute format
+
+        self.label_condition = False     # Make all blocks conditional on the label
+        self.n_labels = 100              # Number of labels (when used)
+        self.dim_label = 64              # Label embedding dimensionality
+
+        self.self_match = False          # Use Hungarian (self-match) or Ordered assignment
+
+        self.n_layers = 4                # Number of Encoder blocks
+        self.n_layers_decode = 4         # Number of Decoder blocks
+        self.n_heads = 8                 # Transformer config: number of heads
+        self.dim_feedforward = 512       # Transformer config: FF dimensionality
+        self.d_model = 256               # Transformer config: model dimensionality
+
+        self.dim_z = 256                 # Latent vector dimensionality
+
+        self.max_num_groups = 8          # Number of paths (N_P)
+        self.max_seq_len = 30            # Number of commands (N_C)
+        self.max_total_len = self.max_num_groups * self.max_seq_len  # Concatenated sequence length for baselines
+
+        self.num_groups_proposal = self.max_num_groups  # Number of predicted paths, default: N_P
+
+    def get_model_args(self):
+        model_args = []
+
+        model_args += ["commands_grouped", "args_grouped"] if self.encode_stages <= 1 else ["commands", "args"]
+
+        if self.rel_targets:
+            model_args += ["commands_grouped", "args_rel_grouped"] if self.decode_stages == 1 else ["commands", "args_rel"]
+        else:
+            model_args += ["commands_grouped", "args_grouped"] if self.decode_stages == 1 else ["commands", "args"]
+
+        if self.label_condition:
+            model_args.append("label")
+
+        return model_args
+
+
+class SketchRNN(_DefaultConfig):
+    # LSTM - Autoregressive - One-stage
+    def __init__(self):
+        super().__init__()
+
+        self.model_type = "lstm"
+
+        self.pred_mode = "autoregressive"
+        self.rel_targets = True
+
+
+class Sketchformer(_DefaultConfig):
+    # Transformer - Autoregressive - One-stage
+    def __init__(self):
+        super().__init__()
+
+        self.pred_mode = "autoregressive"
+        self.rel_targets = True
+
+
+class OneStageOneShot(_DefaultConfig):
+    # Transformer - One-shot - One-stage
+    def __init__(self):
+        super().__init__()
+
+        self.encode_stages = 1
+        self.decode_stages = 1
+
+
+class Hierarchical(_DefaultConfig):
+    # Transformer - One-shot - Two-stage - Ordered
+    def __init__(self):
+        super().__init__()
+
+        self.encode_stages = 2
+        self.decode_stages = 2
+
+
+class HierarchicalSelfMatching(_DefaultConfig):
+    # Transformer - One-shot - Two-stage - Hungarian
+    def __init__(self):
+        super().__init__()
+
+        self.encode_stages = 2
+        self.decode_stages = 2
+        self.self_match = True

src/preprocessing/deepsvg/deepsvg_models/model_utils.py

@@ -0,0 +1,89 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch
+from src.preprocessing.deepsvg.deepsvg_difflib.tensor import SVGTensor
+from torch.distributions.categorical import Categorical
+import torch.nn.functional as F
+
+
+def _get_key_padding_mask(commands, seq_dim=0):
+    """
+    Args:
+        commands: Shape [S, ...]
+    """
+    with torch.no_grad():
+        key_padding_mask = (commands == SVGTensor.COMMANDS_SIMPLIFIED.index("EOS")).cumsum(dim=seq_dim) > 0
+
+        if seq_dim == 0:
+            return key_padding_mask.transpose(0, 1)
+        return key_padding_mask
+
+
+def _get_padding_mask(commands, seq_dim=0, extended=False):
+    with torch.no_grad():
+        padding_mask = (commands == SVGTensor.COMMANDS_SIMPLIFIED.index("EOS")).cumsum(dim=seq_dim) == 0
+        padding_mask = padding_mask.float()
+
+        if extended:
+            # padding_mask doesn't include the final EOS, extend by 1 position to include it in the loss
+            S = commands.size(seq_dim)
+            torch.narrow(padding_mask, seq_dim, 3, S-3).add_(torch.narrow(padding_mask, seq_dim, 0, S-3)).clamp_(max=1)
+
+        if seq_dim == 0:
+            return padding_mask.unsqueeze(-1)
+        return padding_mask
+
+
+def _get_group_mask(commands, seq_dim=0):
+    """
+    Args:
+        commands: Shape [S, ...]
+    """
+    with torch.no_grad():
+        group_mask = (commands == SVGTensor.COMMANDS_SIMPLIFIED.index("m")).cumsum(dim=seq_dim)
+        return group_mask
+
+
+def _get_visibility_mask(commands, seq_dim=0):
+    """
+    Args:
+        commands: Shape [S, ...]
+    """
+    S = commands.size(seq_dim)
+    with torch.no_grad():
+        visibility_mask = (commands == SVGTensor.COMMANDS_SIMPLIFIED.index("EOS")).sum(dim=seq_dim) < S - 1
+
+        if seq_dim == 0:
+            return visibility_mask.unsqueeze(-1)
+        return visibility_mask
+
+
+def _get_key_visibility_mask(commands, seq_dim=0):
+    S = commands.size(seq_dim)
+    with torch.no_grad():
+        key_visibility_mask = (commands == SVGTensor.COMMANDS_SIMPLIFIED.index("EOS")).sum(dim=seq_dim) >= S - 1
+
+        if seq_dim == 0:
+            return key_visibility_mask.transpose(0, 1)
+        return key_visibility_mask
+
+
+def _generate_square_subsequent_mask(sz):
+    mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
+    mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
+    return mask
+
+
+def _sample_categorical(temperature=0.0001, *args_logits):
+    if len(args_logits) == 1:
+        arg_logits, = args_logits
+        return Categorical(logits=arg_logits / temperature).sample()
+    return (*(Categorical(logits=arg_logits / temperature).sample() for arg_logits in args_logits),)
+
+
+def _threshold_sample(arg_logits, threshold=0.5, temperature=1.0):
+    scores = F.softmax(arg_logits / temperature, dim=-1)[..., 1]
+    return scores > threshold

src/preprocessing/deepsvg/deepsvg_schedulers/warmup.py

@@ -0,0 +1,68 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from torch.optim.lr_scheduler import _LRScheduler
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+
+
+class GradualWarmupScheduler(_LRScheduler):
+    """ Gradually warm-up(increasing) learning rate in optimizer.
+    Proposed in 'Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour'.
+    Args:
+        optimizer (Optimizer): Wrapped optimizer.
+        multiplier: target learning rate = base lr * multiplier if multiplier > 1.0. if multiplier = 1.0, lr starts from 0 and ends up with the base_lr.
+        total_epoch: target learning rate is reached at total_epoch, gradually
+        after_scheduler: after target_epoch, use this scheduler(eg. ReduceLROnPlateau)
+    """
+
+    def __init__(self, optimizer, multiplier, total_epoch, after_scheduler=None):
+        self.multiplier = multiplier
+        if self.multiplier < 1.:
+            raise ValueError('multiplier should be greater thant or equal to 1.')
+        self.total_epoch = total_epoch
+        self.after_scheduler = after_scheduler
+        self.finished = False
+        super(GradualWarmupScheduler, self).__init__(optimizer)
+
+    def get_lr(self):
+        if self.last_epoch > self.total_epoch:
+            if self.after_scheduler:
+                if not self.finished:
+                    self.after_scheduler.base_lrs = [base_lr * self.multiplier for base_lr in self.base_lrs]
+                    self.finished = True
+                return self.after_scheduler.get_last_lr()
+            return [base_lr * self.multiplier for base_lr in self.base_lrs]
+
+        if self.multiplier == 1.0:
+            return [base_lr * (float(self.last_epoch) / self.total_epoch) for base_lr in self.base_lrs]
+        else:
+            return [base_lr * ((self.multiplier - 1.) * self.last_epoch / self.total_epoch + 1.) for base_lr in self.base_lrs]
+
+    def step_ReduceLROnPlateau(self, metrics, epoch=None):
+        if epoch is None:
+            epoch = self.last_epoch + 1
+        self.last_epoch = epoch if epoch != 0 else 1  # ReduceLROnPlateau is called at the end of epoch, whereas others are called at beginning
+        if self.last_epoch <= self.total_epoch:
+            warmup_lr = [base_lr * ((self.multiplier - 1.) * self.last_epoch / self.total_epoch + 1.) for base_lr in self.base_lrs]
+            for param_group, lr in zip(self.optimizer.param_groups, warmup_lr):
+                param_group['lr'] = lr
+        else:
+            if epoch is None:
+                self.after_scheduler.step(metrics, None)
+            else:
+                self.after_scheduler.step(metrics, epoch - self.total_epoch)
+
+    def step(self, epoch=None, metrics=None):
+        if type(self.after_scheduler) != ReduceLROnPlateau:
+            if self.finished and self.after_scheduler:
+                if epoch is None:
+                    self.after_scheduler.step(None)
+                else:
+                    self.after_scheduler.step(epoch - self.total_epoch)
+                self._last_lr = self.after_scheduler.get_last_lr()
+            else:
+                return super(GradualWarmupScheduler, self).step(epoch)
+        else:
+            self.step_ReduceLROnPlateau(metrics, epoch)

src/preprocessing/deepsvg/deepsvg_svglib/geom.py

@@ -0,0 +1,493 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from __future__ import annotations
+import numpy as np
+from enum import Enum
+import torch
+from typing import List, Union
+Num = Union[int, float]
+float_type = (int, float, np.float32)
+
+
+def det(a: Point, b: Point):
+    return a.pos[0] * b.pos[1] - a.pos[1] * b.pos[0]
+
+
+def get_rotation_matrix(angle: Union[Angle, float]):
+    if isinstance(angle, Angle):
+        theta = angle.rad
+    else:
+        theta = angle
+    c, s = np.cos(theta), np.sin(theta)
+    rot_m = np.array([[c, -s],
+                      [s, c]], dtype=np.float32)
+    return rot_m
+
+
+def union_bbox(bbox_list: List[Bbox]):
+    res = None
+    for bbox in bbox_list:
+        res = bbox.union(res)
+    return res
+
+
+class Geom:
+    def copy(self):
+        raise NotImplementedError
+
+    def to_str(self):
+        raise NotImplementedError
+
+    def to_tensor(self):
+        raise NotImplementedError
+
+    @staticmethod
+    def from_tensor(vector: torch.Tensor):
+        raise NotImplementedError
+
+    def scale(self, factor):
+        pass
+
+    def translate(self, vec):
+        pass
+
+    def rotate(self, angle: Union[Angle, float]):
+        pass
+
+    def numericalize(self, n=256):
+        raise NotImplementedError
+
+
+######### Point
+class Point(Geom):
+    num_args = 2
+
+    def __init__(self, x=None, y=None):
+        if isinstance(x, np.ndarray):
+            self.pos = x.astype(np.float32)
+        elif x is None and y is None:
+            self.pos = np.array([0., 0.], dtype=np.float32)
+        elif (isinstance(x, float_type) or x is None) and (isinstance(y, float_type) or y is None):
+            if x is None:
+                x = y
+            if y is None:
+                y = x
+            self.pos = np.array([x, y], dtype=np.float32)
+        else:
+            raise ValueError()
+
+    def copy(self):
+        return Point(self.pos.copy())
+
+    @property
+    def x(self):
+        return self.pos[0]
+
+    @property
+    def y(self):
+        return self.pos[1]
+
+    def xproj(self):
+        return Point(self.x, 0.)
+
+    def yproj(self):
+        return Point(0., self.y)
+
+    def __add__(self, other):
+        return Point(self.pos + other.pos)
+
+    def __sub__(self, other):
+        return self + other.__neg__()
+
+    def __mul__(self, lmbda):
+        if isinstance(lmbda, Point):
+            return Point(self.pos * lmbda.pos)
+
+        assert isinstance(lmbda, float_type)
+        return Point(lmbda * self.pos)
+
+    def __rmul__(self, lmbda):
+        return self * lmbda
+
+    def __truediv__(self, lmbda):
+        if isinstance(lmbda, Point):
+            return Point(self.pos / lmbda.pos)
+
+        assert isinstance(lmbda, float_type)
+        return self * (1 / lmbda)
+
+    def __neg__(self):
+        return self * -1
+
+    def __repr__(self):
+        return f"P({self.x}, {self.y})"
+
+    def to_str(self):
+        return f"{self.x} {self.y}"
+
+    def tolist(self):
+        return self.pos.tolist()
+
+    def to_tensor(self):
+        return torch.tensor(self.pos)
+
+    @staticmethod
+    def from_tensor(vector: torch.Tensor):
+        return Point(*vector.tolist())
+
+    def translate(self, vec: Point):
+        self.pos += vec.pos
+
+    def matmul(self, m):
+        return Point(m @ self.pos)
+
+    def rotate(self, angle: Union[Angle, float]):
+        rot_m = get_rotation_matrix(angle)
+        return self.matmul(rot_m)
+
+    def rotate_(self, angle: Union[Angle, float]):
+        rot_m = get_rotation_matrix(angle)
+        self.pos = rot_m @ self.pos
+
+    def scale(self, factor):
+        self.pos *= factor
+
+    def dot(self, other: Point):
+        return self.pos.dot(other.pos)
+
+    def norm(self):
+        return float(np.linalg.norm(self.pos))
+
+    def cross(self, other: Point):
+        return np.cross(self.pos, other.pos)
+
+    def dist(self, other: Point):
+        return (self - other).norm()
+
+    def angle(self, other: Point, signed=False):
+        rad = np.arccos(np.clip(self.normalize().dot(other.normalize()), -1., 1.))
+
+        if signed:
+            sign = 1 if det(self, other) >= 0 else -1
+            rad *= sign
+        return Angle.Rad(rad)
+
+    def distToLine(self, p1: Point, p2: Point):
+        if p1.isclose(p2):
+            return self.dist(p1)
+
+        return abs((p2 - p1).cross(p1 - self)) / (p2 - p1).norm()
+
+    def normalize(self):
+        return self / self.norm()
+
+    def numericalize(self, n=256):
+        self.pos = self.pos.round().clip(min=0, max=n-1)
+
+    def isclose(self, other: Point):
+        return np.allclose(self.pos, other.pos)
+
+    def iszero(self):
+        return np.all(self.pos == 0)
+
+    def pointwise_min(self, other: Point):
+        return Point(min(self.x, other.x), min(self.y, other.y))
+
+    def pointwise_max(self, other: Point):
+        return Point(max(self.x, other.x), max(self.y, other.y))
+
+
+class Radius(Point):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def copy(self):
+        return Radius(self.pos.copy())
+
+    def __repr__(self):
+        return f"Rad({self.pos[0]}, {self.pos[1]})"
+
+    def translate(self, vec: Point):
+        pass
+
+
+class Size(Point):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def copy(self):
+        return Size(self.pos.copy())
+
+    def __repr__(self):
+        return f"Size({self.pos[0]}, {self.pos[1]})"
+
+    def max(self):
+        return self.pos.max()
+
+    def min(self):
+        return self.pos.min()
+
+    def translate(self, vec: Point):
+        pass
+
+
+######### Coord
+class Coord(Geom):
+    num_args = 1
+
+    class XY(Enum):
+        X = "x"
+        Y = "y"
+
+    def __init__(self, coord, xy: XY = XY.X):
+        self.coord = coord
+        self.xy = xy
+
+    def __repr__(self):
+        return f"{self.xy.value}({self.coord})"
+
+    def to_str(self):
+        return str(self.coord)
+
+    def to_tensor(self):
+        return torch.tensor([self.coord])
+
+    def __add__(self, other):
+        if isinstance(other, float_type):
+            return Coord(self.coord + other, self.xy)
+        elif isinstance(other, Coord):
+            if self.xy != other.xy:
+                raise ValueError()
+            return Coord(self.coord + other.coord, self.xy)
+        elif isinstance(other, Point):
+            return Coord(self.coord + getattr(other, self.xy.value), self.xy)
+        else:
+            raise ValueError()
+
+    def __sub__(self, other):
+        return self + other.__neg__()
+
+    def __mul__(self, lmbda):
+        assert isinstance(lmbda, float_type)
+        return Coord(lmbda * self.coord)
+
+    def __neg__(self):
+        return self * -1
+
+    def scale(self, factor):
+        self.coord *= factor
+
+    def translate(self, vec: Point):
+        self.coord += getattr(vec, self.xy.value)
+
+    def to_point(self, pos: Point, is_absolute=True):
+        point = pos.copy() if is_absolute else Point(0.)
+        point.pos[int(self.xy == Coord.XY.Y)] = self.coord
+        return point
+
+
+class XCoord(Coord):
+    def __init__(self, coord):
+        super().__init__(coord, xy=Coord.XY.X)
+
+    def copy(self):
+        return XCoord(self.coord)
+
+
+class YCoord(Coord):
+    def __init__(self, coord):
+        super().__init__(coord, xy=Coord.XY.Y)
+
+    def copy(self):
+        return YCoord(self.coord)
+
+
+######### Bbox
+class Bbox(Geom):
+    num_args = 4
+
+    def __init__(self, x=None, y=None, w=None, h=None):
+        if isinstance(x, Point) and isinstance(y, Point):
+            self.xy = x
+            wh = y - x
+            self.wh = Size(wh.x, wh.y)
+        elif (isinstance(x, float_type) or x is None) and (isinstance(y, float_type) or y is None):
+            if x is None:
+                x = 0.
+            if y is None:
+                y = float(x)
+
+            if w is None and h is None:
+                w, h = float(x), float(y)
+                x, y = 0., 0.
+            self.xy = Point(x, y)
+            self.wh = Size(w, h)
+        else:
+            raise ValueError()
+
+    @property
+    def xy2(self):
+        return self.xy + self.wh
+
+    def copy(self):
+        bbox = Bbox()
+        bbox.xy = self.xy.copy()
+        bbox.wh = self.wh.copy()
+        return bbox
+
+    @property
+    def size(self):
+        return self.wh
+
+    @property
+    def center(self):
+        return self.xy + self.wh / 2
+
+    def __repr__(self):
+        return f"Bbox({self.xy.to_str()} {self.wh.to_str()})"
+
+    def to_str(self):
+        return f"{self.xy.to_str()} {self.wh.to_str()}"
+
+    def to_tensor(self):
+        return torch.tensor([*self.xy.to_tensor(), *self.wh.to_tensor()])
+
+    def make_square(self, min_size=None):
+        center = self.center
+        size = self.wh.max()
+
+        if min_size is not None:
+            size = max(size, min_size)
+
+        self.wh = Size(size, size)
+        self.xy = center - self.wh / 2
+
+        return self
+
+    def translate(self, vec):
+        self.xy.translate(vec)
+
+    def scale(self, factor):
+        self.xy.scale(factor)
+        self.wh.scale(factor)
+
+    def union(self, other: Bbox):
+        if other is None:
+            return self
+        return Bbox(self.xy.pointwise_min(other.xy), self.xy2.pointwise_max(other.xy2))
+
+    def intersect(self, other: Bbox):
+        if other is None:
+            return self
+
+        bbox = Bbox(self.xy.pointwise_max(other.xy), self.xy2.pointwise_min(other.xy2))
+        if bbox.wh.x < 0 or bbox.wh.y < 0:
+            return None
+
+        return bbox
+
+    @staticmethod
+    def from_points(points: List[Point]):
+        if not points:
+            return None
+        xy = xy2 = points[0]
+        for p in points[1:]:
+            xy = xy.pointwise_min(p)
+            xy2 = xy2.pointwise_max(p)
+        return Bbox(xy, xy2)
+
+    def to_rectangle(self, *args, **kwargs):
+        from .svg_primitive import SVGRectangle
+        return SVGRectangle(self.xy, self.wh, *args, **kwargs)
+
+    def area(self):
+        return self.wh.pos.prod()
+
+    def overlap(self, other):
+        inter = self.intersect(other)
+        if inter is None:
+            return 0.
+        return inter.area() / self.area()
+
+
+######### Angle
+class Angle(Geom):
+    num_args = 1
+
+    def __init__(self, deg):
+        self.deg = deg
+
+    @property
+    def rad(self):
+        return np.deg2rad(self.deg)
+
+    def copy(self):
+        return Angle(self.deg)
+
+    def __repr__(self):
+        return f"α({self.deg})"
+
+    def to_str(self):
+        return str(self.deg)
+
+    def to_tensor(self):
+        return torch.tensor([self.deg])
+
+    @staticmethod
+    def from_tensor(vector: torch.Tensor):
+        return Angle(vector.item())
+
+    @staticmethod
+    def Rad(rad):
+        return Angle(np.rad2deg(rad))
+
+    def __add__(self, other: Angle):
+        return Angle(self.deg + other.deg)
+
+    def __sub__(self, other: Angle):
+        return self + other.__neg__()
+
+    def __mul__(self, lmbda):
+        assert isinstance(lmbda, float_type)
+        return Angle(lmbda * self.deg)
+
+    def __rmul__(self, lmbda):
+        assert isinstance(lmbda, float_type)
+        return self * lmbda
+
+    def __truediv__(self, lmbda):
+        assert isinstance(lmbda, float_type)
+        return self * (1 / lmbda)
+
+    def __neg__(self):
+        return self * -1
+
+
+######### Flag
+class Flag(Geom):
+    num_args = 1
+
+    def __init__(self, flag):
+        self.flag = int(flag)
+
+    def copy(self):
+        return Flag(self.flag)
+
+    def __repr__(self):
+        return f"flag({self.flag})"
+
+    def to_str(self):
+        return str(self.flag)
+
+    def to_tensor(self):
+        return torch.tensor([self.flag])
+
+    def __invert__(self):
+        return Flag(1 - self.flag)
+
+    @staticmethod
+    def from_tensor(vector: torch.Tensor):
+        return Flag(vector.item())

src/preprocessing/deepsvg/deepsvg_svglib/svg.py

@@ -0,0 +1,579 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from __future__ import annotations
+from .geom import *
+from xml.dom import expatbuilder
+import torch
+from typing import List, Union
+import IPython.display as ipd
+import cairosvg
+from PIL import Image
+import io
+import os
+from moviepy.editor import ImageClip, concatenate_videoclips, ipython_display
+import math
+import random
+import networkx as nx
+
+Num = Union[int, float]
+
+from .svg_command import SVGCommandBezier
+from .svg_path import SVGPath, Filling, Orientation
+from .svg_primitive import SVGPathGroup, SVGRectangle, SVGCircle, SVGEllipse, SVGLine, SVGPolyline, SVGPolygon
+from .geom import union_bbox
+
+
+class SVG:
+    def __init__(self, svg_path_groups: List[SVGPathGroup], viewbox: Bbox = None):
+        if viewbox is None:
+            viewbox = Bbox(24)
+
+        self.svg_path_groups = svg_path_groups
+        self.viewbox = viewbox
+
+    def __add__(self, other: SVG):
+        svg = self.copy()
+        svg.svg_path_groups.extend(other.svg_path_groups)
+        return svg
+
+    @property
+    def paths(self):
+        for path_group in self.svg_path_groups:
+            for path in path_group.svg_paths:
+                yield path
+
+    def __getitem__(self, idx):
+        if isinstance(idx, tuple):
+            assert len(idx) == 2, "Dimension out of range"
+            i, j = idx
+            return self.svg_path_groups[i][j]
+
+        return self.svg_path_groups[idx]
+
+    def __len__(self):
+        return len(self.svg_path_groups)
+
+    def total_length(self):
+        return sum([path_group.total_len() for path_group in self.svg_path_groups])
+
+    @property
+    def start_pos(self):
+        return Point(0.)
+
+    @property
+    def end_pos(self):
+        if not self.svg_path_groups:
+            return Point(0.)
+
+        return self.svg_path_groups[-1].end_pos
+
+    def copy(self):
+        return SVG([svg_path_group.copy() for svg_path_group in self.svg_path_groups], self.viewbox.copy())
+
+    @staticmethod
+    def load_svg(file_path):
+        with open(file_path, "r") as f:
+            return SVG.from_str(f.read())
+
+    @staticmethod
+    def load_splineset(spline_str: str, width, height, add_closing=True):
+        if "SplineSet" not in spline_str:
+            raise ValueError("Not a SplineSet")
+
+        spline = spline_str[spline_str.index('SplineSet') + 10:spline_str.index('EndSplineSet')]
+        svg_str = SVG._spline_to_svg_str(spline, height)
+
+        if not svg_str:
+            raise ValueError("Empty SplineSet")
+
+        svg_path_group = SVGPath.from_str(svg_str, add_closing=add_closing)
+        return SVG([svg_path_group], viewbox=Bbox(width, height))
+
+    @staticmethod
+    def _spline_to_svg_str(spline_str: str, height, replace_with_prev=False):
+        path = []
+        prev_xy = []
+        for line in spline_str.splitlines():
+            if not line:
+                continue
+            tokens = line.split(' ')
+            cmd = tokens[-2]
+            if cmd not in 'cml':
+                raise ValueError(f"Command not recognized: {cmd}")
+            args = tokens[:-2]
+            args = [float(x) for x in args if x]
+
+            if replace_with_prev and cmd in 'c':
+                args[:2] = prev_xy
+            prev_xy = args[-2:]
+
+            new_y_args = []
+            for i, a in enumerate(args):
+                if i % 2 == 1:
+                    new_y_args.append(str(height - a))
+                else:
+                    new_y_args.append(str(a))
+
+            path.extend([cmd.upper()] + new_y_args)
+        return " ".join(path)
+
+    @staticmethod
+    def from_str(svg_str: str):
+        svg_path_groups = []
+        svg_dom = expatbuilder.parseString(svg_str, False)
+        svg_root = svg_dom.getElementsByTagName('svg')[0]
+
+        viewbox_list = list(map(float, svg_root.getAttribute("viewBox").split(" ")))
+        view_box = Bbox(*viewbox_list)
+
+        primitives = {
+            "path": SVGPath,
+            "rect": SVGRectangle,
+            "circle": SVGCircle, "ellipse": SVGEllipse,
+            "line": SVGLine,
+            "polyline": SVGPolyline, "polygon": SVGPolygon
+        }
+
+        for tag, Primitive in primitives.items():
+            for x in svg_dom.getElementsByTagName(tag):
+                svg_path_groups.append(Primitive.from_xml(x))
+
+        return SVG(svg_path_groups, view_box)
+
+    def to_tensor(self, concat_groups=True, PAD_VAL=-1):
+        group_tensors = [p.to_tensor(PAD_VAL=PAD_VAL) for p in self.svg_path_groups]
+
+        if concat_groups:
+            return torch.cat(group_tensors, dim=0)
+
+        return group_tensors
+
+    def to_fillings(self):
+        return [p.path.filling for p in self.svg_path_groups]
+
+    @staticmethod
+    def from_tensor(tensor: torch.Tensor, viewbox: Bbox = None, allow_empty=False):
+        if viewbox is None:
+            viewbox = Bbox(24)
+
+        svg = SVG([SVGPath.from_tensor(tensor, allow_empty=allow_empty)], viewbox=viewbox)
+        return svg
+
+    @staticmethod
+    def from_tensors(tensors: List[torch.Tensor], viewbox: Bbox = None, allow_empty=False):
+        if viewbox is None:
+            viewbox = Bbox(24)
+
+        svg = SVG([SVGPath.from_tensor(t, allow_empty=allow_empty) for t in tensors], viewbox=viewbox)
+        return svg
+
+    def save_svg(self, file_path):
+        with open(file_path, "w") as f:
+            f.write(self.to_str())
+
+    def save_png(self, file_path):
+        cairosvg.svg2png(bytestring=self.to_str(), write_to=file_path)
+
+    def draw(self, fill=False, file_path=None, do_display=True, return_png=False,
+             with_points=False, with_handles=False, with_bboxes=False, with_markers=False, color_firstlast=False,
+             with_moves=True):
+        if file_path is not None:
+            _, file_extension = os.path.splitext(file_path)
+            if file_extension == ".svg":
+                self.save_svg(file_path)
+            elif file_extension == ".png":
+                self.save_png(file_path)
+            else:
+                raise ValueError(f"Unsupported file_path extension {file_extension}")
+
+        svg_str = self.to_str(fill=fill, with_points=with_points, with_handles=with_handles, with_bboxes=with_bboxes,
+                              with_markers=with_markers, color_firstlast=color_firstlast, with_moves=with_moves)
+
+        if do_display:
+            ipd.display(ipd.SVG(svg_str))
+
+        if return_png:
+            if file_path is None:
+                img_data = cairosvg.svg2png(bytestring=svg_str)
+                return Image.open(io.BytesIO(img_data))
+            else:
+                _, file_extension = os.path.splitext(file_path)
+
+                if file_extension == ".svg":
+                    img_data = cairosvg.svg2png(url=file_path)
+                    return Image.open(io.BytesIO(img_data))
+                else:
+                    return Image.open(file_path)
+
+    def draw_colored(self, *args, **kwargs):
+        self.copy().normalize().split_paths().set_color("random").draw(*args, **kwargs)
+
+    def __repr__(self):
+        return "SVG[{}](\n{}\n)".format(self.viewbox,
+                                        ",\n".join([f"\t{svg_path_group}" for svg_path_group in self.svg_path_groups]))
+
+    def _get_viz_elements(self, with_points=False, with_handles=False, with_bboxes=False, color_firstlast=False,
+                          with_moves=True):
+        viz_elements = []
+        for svg_path_group in self.svg_path_groups:
+            viz_elements.extend(
+                svg_path_group._get_viz_elements(with_points, with_handles, with_bboxes, color_firstlast, with_moves))
+        return viz_elements
+
+    def _markers(self):
+        return ('<defs>'
+                '<marker id="arrow" viewBox="0 0 10 10" markerWidth="4" markerHeight="4" refX="0" refY="3" orient="auto" markerUnits="strokeWidth">'
+                '<path d="M0,0 L0,6 L9,3 z" fill="#f00" />'
+                '</marker>'
+                '</defs>')
+
+    def to_str(self, fill=False, with_points=False, with_handles=False, with_bboxes=False, with_markers=False,
+               color_firstlast=False, with_moves=True) -> str:
+        viz_elements = self._get_viz_elements(with_points, with_handles, with_bboxes, color_firstlast, with_moves)
+        newline = "\n"
+        return (
+            f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="{self.viewbox.to_str()}" height="200px" width="200px">'
+            f'{self._markers() if with_markers else ""}'
+            f'{newline.join(svg_path_group.to_str(fill=fill, with_markers=with_markers) for svg_path_group in [*self.svg_path_groups, *viz_elements])}'
+            '</svg>')
+
+    def _apply_to_paths(self, method, *args, **kwargs):
+        for path_group in self.svg_path_groups:
+            getattr(path_group, method)(*args, **kwargs)
+        return self
+
+    def split_paths(self):
+        path_groups = []
+        for path_group in self.svg_path_groups:
+            path_groups.extend(path_group.split_paths())
+        self.svg_path_groups = path_groups
+        return self
+
+    def merge_groups(self):
+        path_group = self.svg_path_groups[0]
+        for path_group in self.svg_path_groups[1:]:
+            path_group.svg_paths.extend(path_group.svg_paths)
+        self.svg_path_groups = [path_group]
+        return self
+
+    def empty(self):
+        return len(self.svg_path_groups) == 0
+
+    def drop_z(self):
+        return self._apply_to_paths("drop_z")
+
+    def filter_empty(self):
+        self._apply_to_paths("filter_empty")
+        self.svg_path_groups = [path_group for path_group in self.svg_path_groups if path_group.svg_paths]
+        return self
+
+    def translate(self, vec: Point):
+        return self._apply_to_paths("translate", vec)
+
+    def rotate(self, angle: Angle, center: Point = None):
+        if center is None:
+            center = self.viewbox.center
+
+        self.translate(-self.viewbox.center)
+        self._apply_to_paths("rotate", angle)
+        self.translate(center)
+
+        return self
+
+    def zoom(self, factor, center: Point = None):
+        if center is None:
+            center = self.viewbox.center
+
+        self.translate(-self.viewbox.center)
+        self._apply_to_paths("scale", factor)
+        self.translate(center)
+
+        return self
+
+    def normalize(self, viewbox: Bbox = None):
+        if viewbox is None:
+            viewbox = Bbox(24)
+
+        size = self.viewbox.size
+        scale_factor = viewbox.size.min() / size.max()
+        self.zoom(scale_factor, viewbox.center)
+        self.viewbox = viewbox
+
+        return self
+
+    def compute_filling(self):
+        return self._apply_to_paths("compute_filling")
+
+    def recompute_origins(self):
+        origin = self.start_pos
+
+        for path_group in self.svg_path_groups:
+            path_group.set_origin(origin.copy())
+            origin = path_group.end_pos
+
+    def canonicalize_new(self, normalize=False):
+        self.to_path().simplify_arcs()
+
+        self.compute_filling()
+
+        if normalize:
+            self.normalize()
+
+        self.split_paths()
+
+        self.filter_consecutives()
+        self.filter_empty()
+        self._apply_to_paths("reorder")
+        self.svg_path_groups = sorted(self.svg_path_groups, key=lambda x: x.start_pos.tolist()[::-1])
+        self._apply_to_paths("canonicalize")
+        self.recompute_origins()
+
+        self.drop_z()
+
+        return self
+
+    def canonicalize(self, normalize=False):
+        self.to_path().simplify_arcs()
+
+        if normalize:
+            self.normalize()
+
+        self.split_paths()
+        self.filter_consecutives()
+        self.filter_empty()
+        self._apply_to_paths("reorder")
+        self.svg_path_groups = sorted(self.svg_path_groups, key=lambda x: x.start_pos.tolist()[::-1])
+        self._apply_to_paths("canonicalize")
+        self.recompute_origins()
+
+        self.drop_z()
+
+        return self
+
+    def reorder(self):
+        return self._apply_to_paths("reorder")
+
+    def canonicalize_old(self):
+        self.filter_empty()
+        self._apply_to_paths("reorder")
+        self.svg_path_groups = sorted(self.svg_path_groups, key=lambda x: x.start_pos.tolist()[::-1])
+        self._apply_to_paths("canonicalize")
+        self.split_paths()
+        self.recompute_origins()
+
+        self.drop_z()
+
+        return self
+
+    def to_video(self, wrapper, color="grey"):
+        clips, svg_commands = [], []
+
+        im = SVG([]).draw(do_display=False, return_png=True)
+        clips.append(wrapper(np.array(im)))
+
+        for svg_path in self.paths:
+            clips, svg_commands = svg_path.to_video(wrapper, clips, svg_commands, color=color)
+
+        im = self.draw(do_display=False, return_png=True)
+        clips.append(wrapper(np.array(im)))
+
+        return clips
+
+    def animate(self, file_path=None, frame_duration=0.1, do_display=True):
+        clips = self.to_video(lambda img: ImageClip(img).set_duration(frame_duration))
+
+        clip = concatenate_videoclips(clips, method="compose", bg_color=(255, 255, 255))
+
+        if file_path is not None:
+            clip.write_gif(file_path, fps=24, verbose=False, logger=None)
+
+        if do_display:
+            src = clip if file_path is None else file_path
+            ipd.display(ipython_display(src, fps=24, rd_kwargs=dict(logger=None), autoplay=1, loop=1))
+
+    def numericalize(self, n=256):
+        self.normalize(viewbox=Bbox(n))
+        return self._apply_to_paths("numericalize", n)
+
+    def simplify(self, tolerance=0.1, epsilon=0.1, angle_threshold=179., force_smooth=False):
+        self._apply_to_paths("simplify", tolerance=tolerance, epsilon=epsilon, angle_threshold=angle_threshold,
+                             force_smooth=force_smooth)
+        self.recompute_origins()
+        return self
+
+    def reverse(self):
+        self._apply_to_paths("reverse")
+        return self
+
+    def reverse_non_closed(self):
+        self._apply_to_paths("reverse_non_closed")
+        return self
+
+    def duplicate_extremities(self):
+        self._apply_to_paths("duplicate_extremities")
+        return self
+
+    def simplify_heuristic(self, tolerance=0.1, force_smooth=False):
+        return self.copy().split(max_dist=2, include_lines=False) \
+            .simplify(tolerance=tolerance, epsilon=0.2, angle_threshold=150, force_smooth=force_smooth) \
+            .split(max_dist=7.5)
+
+    def simplify_heuristic2(self):
+        return self.copy().split(max_dist=2, include_lines=False) \
+            .simplify(tolerance=0.2, epsilon=0.2, angle_threshold=150) \
+            .split(max_dist=7.5)
+
+    def split(self, n=None, max_dist=None, include_lines=True):
+        return self._apply_to_paths("split", n=n, max_dist=max_dist, include_lines=include_lines)
+
+    @staticmethod
+    def unit_circle():
+        d = 2 * (math.sqrt(2) - 1) / 3
+
+        circle = SVGPath([
+            SVGCommandBezier(Point(.5, 0.), Point(.5 + d, 0.), Point(1., .5 - d), Point(1., .5)),
+            SVGCommandBezier(Point(1., .5), Point(1., .5 + d), Point(.5 + d, 1.), Point(.5, 1.)),
+            SVGCommandBezier(Point(.5, 1.), Point(.5 - d, 1.), Point(0., .5 + d), Point(0., .5)),
+            SVGCommandBezier(Point(0., .5), Point(0., .5 - d), Point(.5 - d, 0.), Point(.5, 0.))
+        ]).to_group()
+
+        return SVG([circle], viewbox=Bbox(1))
+
+    @staticmethod
+    def unit_square():
+        square = SVGPath.from_str("m 0,0 h1 v1 h-1 v-1")
+        return SVG([square], viewbox=Bbox(1))
+
+    def add_path_group(self, path_group: SVGPathGroup):
+        path_group.set_origin(self.end_pos.copy())
+        self.svg_path_groups.append(path_group)
+
+        return self
+
+    def add_path_groups(self, path_groups: List[SVGPathGroup]):
+        for path_group in path_groups:
+            self.add_path_group(path_group)
+
+        return self
+
+    def simplify_arcs(self):
+        return self._apply_to_paths("simplify_arcs")
+
+    def to_path(self):
+        for i, path_group in enumerate(self.svg_path_groups):
+            self.svg_path_groups[i] = path_group.to_path()
+        return self
+
+    def filter_consecutives(self):
+        return self._apply_to_paths("filter_consecutives")
+
+    def filter_duplicates(self):
+        return self._apply_to_paths("filter_duplicates")
+
+    def set_color(self, color):
+        colors = ["deepskyblue", "lime", "deeppink", "gold", "coral", "darkviolet", "royalblue", "darkmagenta", "teal",
+                  "gold",
+                  "green", "maroon", "aqua", "grey", "steelblue", "lime", "orange"]
+
+        if color == "random_random":
+            random.shuffle(colors)
+
+        if isinstance(color, list):
+            colors = color
+
+        for i, path_group in enumerate(self.svg_path_groups):
+            if color == "random" or color == "random_random" or isinstance(color, list):
+                c = colors[i % len(colors)]
+            else:
+                c = color
+            path_group.color = c
+        return self
+
+    def bbox(self):
+        return union_bbox([path_group.bbox() for path_group in self.svg_path_groups])
+
+    def overlap_graph(self, threshold=0.95, draw=False):
+        G = nx.DiGraph()
+        shapes = [group.to_shapely() for group in self.svg_path_groups]
+
+        for i, group1 in enumerate(shapes):
+            G.add_node(i)
+
+            if self.svg_path_groups[i].path.filling != Filling.OUTLINE:
+
+                for j, group2 in enumerate(shapes):
+                    if i != j and self.svg_path_groups[j].path.filling == Filling.FILL:
+                        overlap = group1.intersection(group2).area / group1.area
+                        if overlap > threshold:
+                            G.add_edge(j, i, weight=overlap)
+
+        if draw:
+            pos = nx.spring_layout(G)
+            nx.draw_networkx(G, pos, with_labels=True)
+            labels = nx.get_edge_attributes(G, 'weight')
+            nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
+        return G
+
+    def group_overlapping_paths(self):
+        G = self.overlap_graph()
+
+        path_groups = []
+        root_nodes = [i for i, d in G.in_degree() if d == 0]
+
+        for root in root_nodes:
+            if self[root].path.filling == Filling.FILL:
+                current = [root]
+
+                while current:
+                    n = current.pop(0)
+
+                    fill_neighbors, erase_neighbors = [], []
+                    for m in G.neighbors(n):
+                        if G.in_degree(m) == 1:
+                            if self[m].path.filling == Filling.ERASE:
+                                erase_neighbors.append(m)
+                            else:
+                                fill_neighbors.append(m)
+                    G.remove_node(n)
+
+                    path_group = SVGPathGroup([self[n].path.copy().set_orientation(Orientation.CLOCKWISE)], fill=True)
+                    if erase_neighbors:
+                        for n in erase_neighbors:
+                            neighbor = self[n].path.copy().set_orientation(Orientation.COUNTER_CLOCKWISE)
+                            path_group.append(neighbor)
+                        G.remove_nodes_from(erase_neighbors)
+
+                    path_groups.append(path_group)
+
+                    current.extend(fill_neighbors)
+
+        # Add outlines in the end
+        for path_group in self.svg_path_groups:
+            if path_group.path.filling == Filling.OUTLINE:
+                path_groups.append(path_group)
+
+        return SVG(path_groups)
+
+    def to_points(self, sort=True):
+        points = np.concatenate([path_group.to_points() for path_group in self.svg_path_groups])
+
+        if sort:
+            ind = np.lexsort((points[:, 0], points[:, 1]))
+            points = points[ind]
+
+            # Remove duplicates
+            row_mask = np.append([True], np.any(np.diff(points, axis=0), 1))
+            points = points[row_mask]
+
+        return points
+
+    def permute(self, indices=None):
+        if indices is not None:
+            self.svg_path_groups = [self.svg_path_groups[i] for i in indices]
+        return self
+
+    def fill_(self, fill=True):
+        return self._apply_to_paths("fill_", fill)

src/preprocessing/deepsvg/deepsvg_svglib/svg_command.py

@@ -0,0 +1,531 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from __future__ import annotations
+from .geom import *
+from src.preprocessing.deepsvg.deepsvg_difflib.tensor import SVGTensor
+from .util_fns import get_roots
+from enum import Enum
+import torch
+import math
+from typing import List, Union
+Num = Union[int, float]
+
+
+class SVGCmdEnum(Enum):
+    MOVE_TO = "m"
+    LINE_TO = "l"
+    CUBIC_BEZIER = "c"
+    CLOSE_PATH = "z"
+    ELLIPTIC_ARC = "a"
+    QUAD_BEZIER = "q"
+    LINE_TO_HORIZONTAL = "h"
+    LINE_TO_VERTICAL = "v"
+    CUBIC_BEZIER_REFL = "s"
+    QUAD_BEZIER_REFL = "t"
+
+
+svgCmdArgTypes = {
+    SVGCmdEnum.MOVE_TO.value: [Point],
+    SVGCmdEnum.LINE_TO.value: [Point],
+    SVGCmdEnum.CUBIC_BEZIER.value: [Point, Point, Point],
+    SVGCmdEnum.CLOSE_PATH.value: [],
+    SVGCmdEnum.ELLIPTIC_ARC.value: [Radius, Angle, Flag, Flag, Point],
+    SVGCmdEnum.QUAD_BEZIER.value: [Point, Point],
+    SVGCmdEnum.LINE_TO_HORIZONTAL.value: [XCoord],
+    SVGCmdEnum.LINE_TO_VERTICAL.value: [YCoord],
+    SVGCmdEnum.CUBIC_BEZIER_REFL.value: [Point, Point],
+    SVGCmdEnum.QUAD_BEZIER_REFL.value: [Point],
+}
+
+
+class SVGCommand:
+    def __init__(self, command: SVGCmdEnum, args: List[Geom], start_pos: Point, end_pos: Point):
+        self.command = command
+        self.args = args
+
+        self.start_pos = start_pos
+        self.end_pos = end_pos
+
+    def copy(self):
+        raise NotImplementedError
+
+    @staticmethod
+    def from_str(cmd_str: str, args_str: List[Num], pos=None, initial_pos=None, prev_command: SVGCommand = None):
+        if pos is None:
+            pos = Point(0.)
+        if initial_pos is None:
+            initial_pos = Point(0.)
+
+        cmd = SVGCmdEnum(cmd_str.lower())
+
+        # Implicit MoveTo commands are treated as LineTo
+        if cmd is SVGCmdEnum.MOVE_TO and len(args_str) > 2:
+            l_cmd_str = SVGCmdEnum.LINE_TO.value
+            if cmd_str.isupper():
+                l_cmd_str = l_cmd_str.upper()
+
+            l1, pos, initial_pos = SVGCommand.from_str(cmd_str, args_str[:2], pos, initial_pos)
+            l2, pos, initial_pos = SVGCommand.from_str(l_cmd_str, args_str[2:], pos, initial_pos)
+            return [*l1, *l2], pos, initial_pos
+
+        nb_args = len(args_str)
+
+        if cmd is SVGCmdEnum.CLOSE_PATH:
+            assert nb_args == 0, f"Expected no argument for command {cmd_str}: {nb_args} given"
+            return [SVGCommandClose(pos, initial_pos)], initial_pos, initial_pos
+
+        expected_nb_args = sum([ArgType.num_args for ArgType in svgCmdArgTypes[cmd.value]])
+        assert nb_args % expected_nb_args == 0, f"Expected {expected_nb_args} arguments for command {cmd_str}: {nb_args} given"
+
+        l = []
+        i = 0
+        for _ in range(nb_args // expected_nb_args):
+            args = []
+            for ArgType in svgCmdArgTypes[cmd.value]:
+                num_args = ArgType.num_args
+                arg = ArgType(*args_str[i:i+num_args])
+
+                if cmd_str.islower():
+                    arg.translate(pos)
+                if isinstance(arg, Coord):
+                    arg = arg.to_point(pos)
+
+                args.append(arg)
+                i += num_args
+
+            if cmd is SVGCmdEnum.LINE_TO or cmd is SVGCmdEnum.LINE_TO_VERTICAL or cmd is SVGCmdEnum.LINE_TO_HORIZONTAL:
+                cmd_parsed = SVGCommandLine(pos, *args)
+            elif cmd is SVGCmdEnum.MOVE_TO:
+                cmd_parsed = SVGCommandMove(pos, *args)
+            elif cmd is SVGCmdEnum.ELLIPTIC_ARC:
+                cmd_parsed = SVGCommandArc(pos, *args)
+            elif cmd is SVGCmdEnum.CUBIC_BEZIER:
+                cmd_parsed = SVGCommandBezier(pos, *args)
+            elif cmd is SVGCmdEnum.QUAD_BEZIER:
+                cmd_parsed = SVGCommandBezier(pos, args[0], args[0], args[1])
+            elif cmd is SVGCmdEnum.QUAD_BEZIER_REFL or cmd is SVGCmdEnum.CUBIC_BEZIER_REFL:
+                if isinstance(prev_command, SVGCommandBezier):
+                    control1 = pos * 2 - prev_command.control2
+                else:
+                    control1 = pos
+                control2 = args[0] if cmd is SVGCmdEnum.CUBIC_BEZIER_REFL else control1
+                cmd_parsed = SVGCommandBezier(pos, control1, control2, args[-1])
+
+            prev_command = cmd_parsed
+            pos = cmd_parsed.end_pos
+
+            if cmd is SVGCmdEnum.MOVE_TO:
+                initial_pos = pos
+
+            l.append(cmd_parsed)
+
+        return l, pos, initial_pos
+
+    def __repr__(self):
+        cmd = self.command.value.upper()
+        return f"{cmd}{self.get_geoms()}"
+
+    def to_str(self):
+        cmd = self.command.value.upper()
+        return f"{cmd}{' '.join([arg.to_str() for arg in self.args])}"
+
+    def to_tensor(self, PAD_VAL=-1):
+        raise NotImplementedError
+
+    @staticmethod
+    def from_tensor(vector: torch.Tensor):
+        cmd_index, args = int(vector[0]), vector[1:]
+
+        cmd = SVGCmdEnum(SVGTensor.COMMANDS_SIMPLIFIED[cmd_index])
+        radius = Radius(*args[:2].tolist())
+        x_axis_rotation = Angle(*args[2:3].tolist())
+        large_arc_flag = Flag(args[3].item())
+        sweep_flag = Flag(args[4].item())
+        start_pos = Point(*args[5:7].tolist())
+        control1 = Point(*args[7:9].tolist())
+        control2 = Point(*args[9:11].tolist())
+        end_pos = Point(*args[11:].tolist())
+
+        return SVGCommand.from_args(cmd, radius, x_axis_rotation, large_arc_flag, sweep_flag, start_pos, control1, control2, end_pos)
+
+    @staticmethod
+    def from_args(command: SVGCmdEnum, radius: Radius, x_axis_rotation: Angle, large_arc_flag: Flag,
+                  sweep_flag: Flag, start_pos: Point, control1: Point, control2: Point, end_pos: Point):
+        if command is SVGCmdEnum.MOVE_TO:
+            return SVGCommandMove(start_pos, end_pos)
+        elif command is SVGCmdEnum.LINE_TO:
+            return SVGCommandLine(start_pos, end_pos)
+        elif command is SVGCmdEnum.CUBIC_BEZIER:
+            return SVGCommandBezier(start_pos, control1, control2, end_pos)
+        elif command is SVGCmdEnum.CLOSE_PATH:
+            return SVGCommandClose(start_pos, end_pos)
+        elif command is SVGCmdEnum.ELLIPTIC_ARC:
+            return SVGCommandArc(start_pos, radius, x_axis_rotation, large_arc_flag, sweep_flag, end_pos)
+
+    def draw(self, *args, **kwargs):
+        from .svg_path import SVGPath
+        return SVGPath([self]).draw(*args, **kwargs)
+
+    def reverse(self):
+        raise NotImplementedError
+
+    def is_left_to(self, other: SVGCommand):
+        p1, p2 = self.start_pos, other.start_pos
+
+        if p1.y == p2.y:
+            return p1.x < p2.x
+
+        return p1.y < p2.y or (np.isclose(p1.norm(), p2.norm()) and p1.x < p2.x)
+
+    def numericalize(self, n=256):
+        raise NotImplementedError
+
+    def get_geoms(self):
+        return [self.start_pos, self.end_pos]
+
+    def get_points_viz(self, first=False, last=False):
+        from .svg_primitive import SVGCircle
+        color = "red" if first else "purple" if last else "deepskyblue"  # "#C4C4C4"
+        opacity = 0.75 if first or last else 1.0
+        return [SVGCircle(self.end_pos, radius=Radius(0.4), color=color, fill=True, stroke_width=".1", opacity=opacity)]
+
+    def get_handles_viz(self):
+        return []
+
+    def sample_points(self, n=10, return_array=False):
+        return []
+
+    def split(self, n=2):
+        raise NotImplementedError
+
+    def length(self):
+        raise NotImplementedError
+
+    def bbox(self):
+        raise NotImplementedError
+
+
+class SVGCommandLinear(SVGCommand):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def to_tensor(self, PAD_VAL=-1):
+        cmd_index = SVGTensor.COMMANDS_SIMPLIFIED.index(self.command.value)
+        return torch.tensor([cmd_index,
+                             *([PAD_VAL] * 5),
+                             *self.start_pos.to_tensor(),
+                             *([PAD_VAL] * 4),
+                             *self.end_pos.to_tensor()])
+
+    def numericalize(self, n=256):
+        self.start_pos.numericalize(n)
+        self.end_pos.numericalize(n)
+
+    def copy(self):
+        return self.__class__(self.start_pos.copy(), self.end_pos.copy())
+
+    def reverse(self):
+        return self.__class__(self.end_pos, self.start_pos)
+
+    def split(self, n=2):
+        return [self]
+
+    def bbox(self):
+        return Bbox(self.start_pos, self.end_pos)
+
+
+class SVGCommandMove(SVGCommandLinear):
+    def __init__(self, start_pos: Point, end_pos: Point=None):
+        if end_pos is None:
+            start_pos, end_pos = Point(0.), start_pos
+        super().__init__(SVGCmdEnum.MOVE_TO, [end_pos], start_pos, end_pos)
+
+    def get_points_viz(self, first=False, last=False):
+        from .svg_primitive import SVGLine
+        points_viz = super().get_points_viz(first, last)
+        points_viz.append(SVGLine(self.start_pos, self.end_pos, color="red", dasharray=0.5))
+        return points_viz
+
+    def bbox(self):
+        return Bbox(self.end_pos, self.end_pos)
+
+
+class SVGCommandLine(SVGCommandLinear):
+    def __init__(self, start_pos: Point, end_pos: Point):
+        super().__init__(SVGCmdEnum.LINE_TO, [end_pos], start_pos, end_pos)
+
+    def sample_points(self, n=10, return_array=False):
+        z = np.linspace(0., 1., n)
+
+        if return_array:
+            points = (1-z)[:, None] * self.start_pos.pos[None] + z[:, None] * self.end_pos.pos[None]
+            return points
+
+        points = [(1 - alpha) * self.start_pos + alpha * self.end_pos for alpha in z]
+        return points
+
+    def split(self, n=2):
+        points = self.sample_points(n+1)
+        return [SVGCommandLine(p1, p2) for p1, p2 in zip(points[:-1], points[1:])]
+
+    def length(self):
+        return self.start_pos.dist(self.end_pos)
+
+
+class SVGCommandClose(SVGCommandLinear):
+    def __init__(self, start_pos: Point, end_pos: Point):
+        super().__init__(SVGCmdEnum.CLOSE_PATH, [], start_pos, end_pos)
+
+    def get_points_viz(self, first=False, last=False):
+        return []
+
+
+class SVGCommandBezier(SVGCommand):
+    def __init__(self, start_pos: Point, control1: Point, control2: Point, end_pos: Point):
+        if control2 is None:
+            control2 = control1.copy()
+        super().__init__(SVGCmdEnum.CUBIC_BEZIER, [control1, control2, end_pos], start_pos, end_pos)
+
+        self.control1 = control1
+        self.control2 = control2
+
+    @property
+    def p1(self):
+        return self.start_pos
+
+    @property
+    def p2(self):
+        return self.end_pos
+
+    @property
+    def q1(self):
+        return self.control1
+
+    @property
+    def q2(self):
+        return self.control2
+
+    def copy(self):
+        return SVGCommandBezier(self.start_pos.copy(), self.control1.copy(), self.control2.copy(), self.end_pos.copy())
+
+    def to_tensor(self, PAD_VAL=-1):
+        cmd_index = SVGTensor.COMMANDS_SIMPLIFIED.index(SVGCmdEnum.CUBIC_BEZIER.value)
+        return torch.tensor([cmd_index,
+                             *([PAD_VAL] * 5),
+                             *self.start_pos.to_tensor(),
+                             *self.control1.to_tensor(),
+                             *self.control2.to_tensor(),
+                             *self.end_pos.to_tensor()])
+
+    def to_vector(self):
+        return np.array([
+            self.start_pos.tolist(),
+            self.control1.tolist(),
+            self.control2.tolist(),
+            self.end_pos.tolist()
+        ])
+
+    @staticmethod
+    def from_vector(vector):
+        return SVGCommandBezier(Point(vector[0]), Point(vector[1]), Point(vector[2]), Point(vector[3]))
+
+    def reverse(self):
+        return SVGCommandBezier(self.end_pos, self.control2, self.control1, self.start_pos)
+
+    def numericalize(self, n=256):
+        self.start_pos.numericalize(n)
+        self.control1.numericalize(n)
+        self.control2.numericalize(n)
+        self.end_pos.numericalize(n)
+
+    def get_geoms(self):
+        return [self.start_pos, self.control1, self.control2, self.end_pos]
+
+    def get_handles_viz(self):
+        from .svg_primitive import SVGLine, SVGCircle
+        anchor_1 = SVGCircle(self.control1, radius=Radius(0.4), color="lime", fill=True, stroke_width=".1")
+        anchor_2 = SVGCircle(self.control2, radius=Radius(0.4), color="lime", fill=True, stroke_width=".1")
+
+        handle_1 = SVGLine(self.start_pos, self.control1, color="grey", dasharray=0.5, stroke_width=".1")
+        handle_2 = SVGLine(self.end_pos, self.control2, color="grey", dasharray=0.5, stroke_width=".1")
+        return [handle_1, handle_2, anchor_1, anchor_2]
+
+    def eval(self, t):
+        return (1 - t)**3 * self.start_pos + 3 * (1 - t)**2 * t * self.control1 + 3 * (1 - t) * t**2 * self.control2 + t**3 * self.end_pos
+
+    def derivative(self, t, n=1):
+        if n == 1:
+            return 3 * (1 - t)**2 * (self.control1 - self.start_pos) + 6 * (1 - t) * t * (self.control2 - self.control1) + 3 * t**2 * (self.end_pos - self.control2)
+        elif n == 2:
+            return 6 * (1 - t) * (self.control2 - 2 * self.control1 + self.start_pos) + 6 * t * (self.end_pos - 2 * self.control2 + self.control1)
+
+        raise NotImplementedError
+
+    def angle(self, other: SVGCommandBezier):
+        t1, t2 = self.derivative(1.), -other.derivative(0.)
+        if np.isclose(t1.norm(), 0.) or np.isclose(t2.norm(), 0.):
+            return 0.
+        angle = np.arccos(np.clip(t1.normalize().dot(t2.normalize()), -1., 1.))
+        return np.rad2deg(angle)
+
+    def sample_points(self, n=10, return_array=False):
+        b = self.to_vector()
+
+        z = np.linspace(0., 1., n)
+        Z = np.stack([np.ones_like(z), z, z**2, z**3], axis=1)
+        Q = np.array([[1., 0., 0., 0.],
+                      [-3, 3., 0., 0.],
+                      [3., -6, 3., 0.],
+                      [-1, 3., -3, 1]])
+
+        points = Z @ Q @ b
+
+        if return_array:
+            return points
+
+        return [Point(p) for p in points]
+
+    def _split_two(self, z=.5):
+        b = self.to_vector()
+
+        Q1 = np.array([[1, 0, 0, 0],
+                       [-(z - 1), z, 0, 0],
+                       [(z - 1) ** 2, -2 * (z - 1) * z, z ** 2, 0],
+                       [-(z - 1) ** 3, 3 * (z - 1) ** 2 * z, -3 * (z - 1) * z ** 2, z ** 3]])
+        Q2 = np.array([[-(z - 1) ** 3, 3 * (z - 1) ** 2 * z, -3 * (z - 1) * z ** 2, z ** 3],
+                       [0, (z - 1) ** 2, -2 * (z - 1) * z, z ** 2],
+                       [0, 0, -(z - 1), z],
+                       [0, 0, 0, 1]])
+
+        return SVGCommandBezier.from_vector(Q1 @ b), SVGCommandBezier.from_vector(Q2 @ b)
+
+    def split(self, n=2):
+        b_list = []
+        b = self
+
+        for i in range(n - 1):
+            z = 1. / (n - i)
+            b1, b = b._split_two(z)
+            b_list.append(b1)
+        b_list.append(b)
+        return b_list
+
+    def length(self):
+        p = self.sample_points(n=100, return_array=True)
+        return np.linalg.norm(p[1:] - p[:-1], axis=-1).sum()
+
+    def bbox(self):
+        return Bbox.from_points(self.find_extrema())
+
+    def find_roots(self):
+        a = 3 * (-self.p1 + 3 * self.q1 - 3 * self.q2 + self.p2)
+        b = 6 * (self.p1 - 2 * self.q1 + self.q2)
+        c = 3 * (self.q1 - self.p1)
+
+        x_roots, y_roots = get_roots(a.x, b.x, c.x), get_roots(a.y, b.y, c.y)
+        roots_cat = [*x_roots, *y_roots]
+        roots = [root for root in roots_cat if 0 <= root <= 1]
+        return roots
+
+    def find_extrema(self):
+        points = [self.start_pos, self.end_pos]
+        points.extend([self.eval(root) for root in self.find_roots()])
+        return points
+
+
+class SVGCommandArc(SVGCommand):
+    def __init__(self, start_pos: Point, radius: Radius, x_axis_rotation: Angle, large_arc_flag: Flag, sweep_flag: Flag, end_pos: Point):
+        super().__init__(SVGCmdEnum.ELLIPTIC_ARC, [radius, x_axis_rotation, large_arc_flag, sweep_flag, end_pos], start_pos, end_pos)
+
+        self.radius = radius
+        self.x_axis_rotation = x_axis_rotation
+        self.large_arc_flag = large_arc_flag
+        self.sweep_flag = sweep_flag
+
+    def copy(self):
+        return SVGCommandArc(self.start_pos.copy(), self.radius.copy(), self.x_axis_rotation.copy(), self.large_arc_flag.copy(),
+                             self.sweep_flag.copy(), self.end_pos.copy())
+
+    def to_tensor(self, PAD_VAL=-1):
+        cmd_index = SVGTensor.COMMANDS_SIMPLIFIED.index(SVGCmdEnum.ELLIPTIC_ARC.value)
+        return torch.tensor([cmd_index,
+                             *self.radius.to_tensor(),
+                             *self.x_axis_rotation.to_tensor(),
+                             *self.large_arc_flag.to_tensor(),
+                             *self.sweep_flag.to_tensor(),
+                             *self.start_pos.to_tensor(),
+                             *([PAD_VAL] * 4),
+                             *self.end_pos.to_tensor()])
+
+    def _get_center_parametrization(self):
+        r = self.radius
+        p1, p2 = self.start_pos, self.end_pos
+
+        h, m = 0.5 * (p1 - p2), 0.5 * (p1 + p2)
+        p1_trans = h.rotate(-self.x_axis_rotation)
+
+        sign = -1 if self.large_arc_flag.flag == self.sweep_flag.flag else 1
+        x2, y2, rx2, ry2 = p1_trans.x**2, p1_trans.y**2, r.x**2, r.y**2
+        sqrt = math.sqrt(max((rx2*ry2 - rx2*y2 - ry2*x2) / (rx2*y2 + ry2*x2), 0.))
+        c_trans = sign * sqrt * Point(r.x * p1_trans.y / r.y, -r.y * p1_trans.x / r.x)
+
+        c = c_trans.rotate(self.x_axis_rotation) + m
+
+        d, ns = (p1_trans - c_trans) / r, -(p1_trans + c_trans) / r
+
+        theta_1 = Point(1, 0).angle(d, signed=True)
+
+        delta_theta = d.angle(ns, signed=True)
+        delta_theta.deg %= 360
+        if self.sweep_flag.flag == 0 and delta_theta.deg > 0:
+            delta_theta = delta_theta - Angle(360)
+        if self.sweep_flag == 1 and delta_theta.deg < 0:
+            delta_theta = delta_theta + Angle(360)
+
+        return c, theta_1, delta_theta
+
+    def _get_point(self, c: Point, t: float_type):
+        r = self.radius
+        return c + Point(r.x * np.cos(t), r.y * np.sin(t)).rotate(self.x_axis_rotation)
+
+    def _get_derivative(self, t: float_type):
+        r = self.radius
+        return Point(-r.x * np.sin(t), r.y * np.cos(t)).rotate(self.x_axis_rotation)
+
+    def to_beziers(self):
+        """ References:
+        https://www.w3.org/TR/2018/CR-SVG2-20180807/implnote.html
+        https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/
+        http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf """
+        beziers = []
+
+        c, theta_1, delta_theta = self._get_center_parametrization()
+        nb_curves = max(int(abs(delta_theta.deg) // 45), 1)
+        etas = [theta_1 + i * delta_theta / nb_curves for i in range(nb_curves+1)]
+        for eta_1, eta_2 in zip(etas[:-1], etas[1:]):
+            e1, e2 = eta_1.rad, eta_2.rad
+            alpha = np.sin(e2 - e1) * (math.sqrt(4 + 3 * np.tan(0.5 * (e2 - e1))**2) - 1) / 3
+            p1, p2 = self._get_point(c, e1), self._get_point(c, e2)
+            q1 = p1 + alpha * self._get_derivative(e1)
+            q2 = p2 - alpha * self._get_derivative(e2)
+            beziers.append(SVGCommandBezier(p1, q1, q2, p2))
+
+        return beziers
+
+    def reverse(self):
+        return SVGCommandArc(self.end_pos, self.radius, self.x_axis_rotation, self.large_arc_flag, ~self.sweep_flag, self.start_pos)
+
+    def numericalize(self, n=256):
+        raise NotImplementedError
+
+    def get_geoms(self):
+        return [self.start_pos, self.radius, self.x_axis_rotation, self.large_arc_flag, self.sweep_flag, self.end_pos]
+
+    def split(self, n=2):
+        raise NotImplementedError
+
+    def sample_points(self, n=10, return_array=False):
+        raise NotImplementedError

src/preprocessing/deepsvg/deepsvg_svglib/svg_path.py

@@ -0,0 +1,659 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from __future__ import annotations
+from .geom import *
+import src.preprocessing.deepsvg.deepsvg_svglib.geom as geom
+import re
+import torch
+from typing import List, Union
+from xml.dom import minidom
+import math
+#import shapely.geometry
+import numpy as np
+
+from .geom import union_bbox
+from .svg_command import SVGCommand, SVGCommandMove, SVGCommandClose, SVGCommandBezier, SVGCommandLine, SVGCommandArc
+
+
+COMMANDS = "MmZzLlHhVvCcSsQqTtAa"
+COMMAND_RE = re.compile(r"([MmZzLlHhVvCcSsQqTtAa])")
+FLOAT_RE = re.compile(r"[-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?")
+
+
+empty_command = SVGCommandMove(Point(0.))
+
+
+class Orientation:
+    COUNTER_CLOCKWISE = 0
+    CLOCKWISE = 1
+
+
+class Filling:
+    OUTLINE = 0
+    FILL = 1
+    ERASE = 2
+
+
+class SVGPath:
+    def __init__(self, path_commands: List[SVGCommand] = None, origin: Point = None, closed=False, filling=Filling.OUTLINE):
+        self.origin = origin or Point(0.)
+        self.path_commands = path_commands
+        self.closed = closed
+
+        self.filling = filling
+
+    @property
+    def start_command(self):
+        return SVGCommandMove(self.origin, self.start_pos)
+
+    @property
+    def start_pos(self):
+        return self.path_commands[0].start_pos
+
+    @property
+    def end_pos(self):
+        return self.path_commands[-1].end_pos
+
+    def to_group(self, *args, **kwargs):
+        from .svg_primitive import SVGPathGroup
+        return SVGPathGroup([self], *args, **kwargs)
+
+    def set_filling(self, filling=True):
+        self.filling = Filling.FILL if filling else Filling.ERASE
+        return self
+
+    def __len__(self):
+        return 1 + len(self.path_commands)
+
+    def __getitem__(self, idx):
+        if idx == 0:
+            return self.start_command
+        return self.path_commands[idx-1]
+
+    def all_commands(self, with_close=True):
+        close_cmd = [SVGCommandClose(self.path_commands[-1].end_pos.copy(), self.start_pos.copy())] if self.closed and self.path_commands and with_close \
+                    else ()
+        return [self.start_command, *self.path_commands, *close_cmd]
+
+    def copy(self):
+        return SVGPath([path_command.copy() for path_command in self.path_commands], self.origin.copy(), self.closed, filling=self.filling)
+
+    @staticmethod
+    def _tokenize_path(path_str):
+        cmd = None
+        for x in COMMAND_RE.split(path_str):
+            if x and x in COMMANDS:
+                cmd = x
+            elif cmd is not None:
+                yield cmd, list(map(float, FLOAT_RE.findall(x)))
+
+    @staticmethod
+    def from_xml(x: minidom.Element):
+        stroke = x.getAttribute('stroke')
+        dasharray = x.getAttribute('dasharray')
+        stroke_width = x.getAttribute('stroke-width')
+
+        fill = not x.hasAttribute("fill") or not x.getAttribute("fill") == "none"
+
+        filling = Filling.OUTLINE if not x.hasAttribute("filling") else int(x.getAttribute("filling"))
+
+        s = x.getAttribute('d')
+        return SVGPath.from_str(s, fill=fill, filling=filling)
+
+    @staticmethod
+    def from_str(s: str, fill=False, filling=Filling.OUTLINE, add_closing=False):
+        path_commands = []
+        pos = initial_pos = Point(0.)
+        prev_command = None
+        for cmd, args in SVGPath._tokenize_path(s):
+            cmd_parsed, pos, initial_pos = SVGCommand.from_str(cmd, args, pos, initial_pos, prev_command)
+            prev_command = cmd_parsed[-1]
+            path_commands.extend(cmd_parsed)
+
+        return SVGPath.from_commands(path_commands, fill=fill, filling=filling, add_closing=add_closing)
+
+    @staticmethod
+    def from_tensor(tensor: torch.Tensor, allow_empty=False):
+        return SVGPath.from_commands([SVGCommand.from_tensor(row) for row in tensor], allow_empty=allow_empty)
+
+    @staticmethod
+    def from_commands(path_commands: List[SVGCommand], fill=False, filling=Filling.OUTLINE, add_closing=False, allow_empty=False):
+        from .svg_primitive import SVGPathGroup
+
+        if not path_commands:
+            return SVGPathGroup([])
+
+        svg_paths = []
+        svg_path = None
+
+        for command in path_commands:
+            if isinstance(command, SVGCommandMove):
+                if svg_path is not None and (allow_empty or svg_path.path_commands):  # SVGPath contains at least one command
+                    if add_closing:
+                        svg_path.closed = True
+                    if not svg_path.path_commands:
+                        svg_path.path_commands.append(empty_command)
+                    svg_paths.append(svg_path)
+
+                svg_path = SVGPath([], command.start_pos.copy(), filling=filling)
+            else:
+                if svg_path is None:
+                    # Ignore commands until the first moveTo commands
+                    continue
+
+                if isinstance(command, SVGCommandClose):
+                    if allow_empty or svg_path.path_commands:  # SVGPath contains at least one command
+                        svg_path.closed = True
+                        if not svg_path.path_commands:
+                            svg_path.path_commands.append(empty_command)
+                        svg_paths.append(svg_path)
+                    svg_path = None
+                else:
+                    svg_path.path_commands.append(command)
+        if svg_path is not None and (allow_empty or svg_path.path_commands):  # SVGPath contains at least one command
+            if add_closing:
+                svg_path.closed = True
+            if not svg_path.path_commands:
+                svg_path.path_commands.append(empty_command)
+            svg_paths.append(svg_path)
+        return SVGPathGroup(svg_paths, fill=fill)
+
+    def __repr__(self):
+        return "SVGPath({})".format(" ".join(command.__repr__() for command in self.all_commands()))
+
+    def to_str(self, fill=False):
+        return " ".join(command.to_str() for command in self.all_commands())
+
+    def to_tensor(self, PAD_VAL=-1):
+        return torch.stack([command.to_tensor(PAD_VAL=PAD_VAL) for command in self.all_commands()])
+
+    def _get_viz_elements(self, with_points=False, with_handles=False, with_bboxes=False, color_firstlast=False, with_moves=True):
+        points = self._get_points_viz(color_firstlast, with_moves) if with_points else ()
+        handles = self._get_handles_viz() if with_handles else ()
+        return [*points, *handles]
+
+    def draw(self, viewbox=Bbox(24), *args, **kwargs):
+        from .svg import SVG
+        return SVG([self.to_group()], viewbox=viewbox).draw(*args, **kwargs)
+
+    def _get_points_viz(self, color_firstlast=True, with_moves=True):
+        points = []
+        commands = self.all_commands(with_close=False)
+        n = len(commands)
+        for i, command in enumerate(commands):
+            if not isinstance(command, SVGCommandMove) or with_moves:
+                points_viz = command.get_points_viz(first=(color_firstlast and i <= 1), last=(color_firstlast and i >= n-2))
+                points.extend(points_viz)
+        return points
+
+    def _get_handles_viz(self):
+        handles = []
+        for command in self.path_commands:
+            handles.extend(command.get_handles_viz())
+        return handles
+
+    def _get_unique_geoms(self):
+        geoms = []
+        for command in self.all_commands():
+            geoms.extend(command.get_geoms())
+        return list(set(geoms))
+
+    def translate(self, vec):
+        for geom in self._get_unique_geoms():
+            geom.translate(vec)
+        return self
+
+    def rotate(self, angle):
+        for geom in self._get_unique_geoms():
+            geom.rotate_(angle)
+        return self
+
+    def scale(self, factor):
+        for geom in self._get_unique_geoms():
+            geom.scale(factor)
+        return self
+
+    def filter_consecutives(self):
+        path_commands = []
+        for command in self.path_commands:
+            if not command.start_pos.isclose(command.end_pos):
+                path_commands.append(command)
+        self.path_commands = path_commands
+        return self
+
+    def filter_duplicates(self, min_dist=0.2):
+        path_commands = []
+        current_command = None
+        for command in self.path_commands:
+            if current_command is None:
+                path_commands.append(command)
+                current_command = command
+
+            if command.end_pos.dist(current_command.end_pos) >= min_dist:
+                command.start_pos = current_command.end_pos
+                path_commands.append(command)
+                current_command = command
+
+        self.path_commands = path_commands
+        return self
+
+    def duplicate_extremities(self):
+        self.path_commands = [SVGCommandLine(self.start_pos, self.start_pos),
+                              *self.path_commands,
+                              SVGCommandLine(self.end_pos, self.end_pos)]
+        return self
+
+    def is_clockwise(self):
+        if len(self.path_commands) == 1:
+            cmd = self.path_commands[0]
+            return cmd.start_pos.tolist() <= cmd.end_pos.tolist()
+
+        det_total = 0.
+        for cmd in self.path_commands:
+            det_total += geom.det(cmd.start_pos, cmd.end_pos)
+        return det_total >= 0.
+
+    def set_orientation(self, orientation):
+        """
+        orientation: 1 (clockwise), 0 (counter-clockwise)
+        """
+        if orientation == self.is_clockwise():
+            return self
+        return self.reverse()
+
+    def set_closed(self, closed=True):
+        self.closed = closed
+        return self
+
+    def reverse(self):
+        path_commands = []
+
+        for command in reversed(self.path_commands):
+            path_commands.append(command.reverse())
+
+        self.path_commands = path_commands
+        return self
+
+    def reverse_non_closed(self):
+        if not self.start_pos.isclose(self.end_pos):
+            return self.reverse()
+        return self
+
+    def simplify_arcs(self):
+        path_commands = []
+        for command in self.path_commands:
+            if isinstance(command, SVGCommandArc):
+                if command.radius.iszero():
+                    continue
+                if command.start_pos.isclose(command.end_pos):
+                    continue
+                path_commands.extend(command.to_beziers())
+            else:
+                path_commands.append(command)
+
+        self.path_commands = path_commands
+        return self
+
+    def _get_topleftmost_command(self):
+        topleftmost_cmd = None
+        topleftmost_idx = 0
+
+        for i, cmd in enumerate(self.path_commands):
+            if topleftmost_cmd is None or cmd.is_left_to(topleftmost_cmd):
+                topleftmost_cmd = cmd
+                topleftmost_idx = i
+
+        return topleftmost_cmd, topleftmost_idx
+
+    def reorder(self):
+        if self.closed:
+            topleftmost_cmd, topleftmost_idx = self._get_topleftmost_command()
+
+            self.path_commands = [
+                *self.path_commands[topleftmost_idx:],
+                *self.path_commands[:topleftmost_idx]
+            ]
+
+        return self
+
+    def to_video(self, wrapper, clips=None, svg_commands=None, color="grey"):
+        from .svg import SVG
+        from .svg_primitive import SVGLine, SVGCircle
+
+        if clips is None:
+            clips = []
+        if svg_commands is None:
+            svg_commands = []
+        svg_dots, svg_moves = [], []
+
+        for command in self.all_commands():
+            start_pos, end_pos = command.start_pos, command.end_pos
+
+            if isinstance(command, SVGCommandMove):
+                move = SVGLine(start_pos, end_pos, color="teal", dasharray=0.5)
+                svg_moves.append(move)
+
+            dot = SVGCircle(end_pos, radius=Radius(0.1), color="red")
+            svg_dots.append(dot)
+
+            svg_path = SVGPath(svg_commands).to_group(color=color)
+            svg_new_path = SVGPath([SVGCommandMove(start_pos), command]).to_group(color="red")
+
+            svg_paths = [svg_path, svg_new_path]  if svg_commands else [svg_new_path]
+            im = SVG([*svg_paths, *svg_moves, *svg_dots]).draw(do_display=False, return_png=True, with_points=False)
+            clips.append(wrapper(np.array(im)))
+
+            svg_dots[-1].color = "grey"
+            svg_commands.append(command)
+            svg_moves = []
+
+        return clips, svg_commands
+
+    def numericalize(self, n=256):
+        for command in self.all_commands():
+            command.numericalize(n)
+
+    def smooth(self):
+        # https://github.com/paperjs/paper.js/blob/c7d85b663edb728ec78fffa9f828435eaf78d9c9/src/path/Path.js#L1288
+        n = len(self.path_commands)
+        knots = [self.start_pos, *(path_commmand.end_pos for path_commmand in self.path_commands)]
+        r = [knots[0] + 2 * knots[1]]
+        f = [2]
+        p = [Point(0.)] * (n + 1)
+
+        # Solve with the Thomas algorithm
+        for i in range(1, n):
+            internal = i < n - 1
+            a = 1
+            b = 4 if internal else 2
+            u = 4 if internal else 3
+            v = 2 if internal else 0
+            m = a / f[i-1]
+
+            f.append(b-m)
+            r.append(u * knots[i] + v * knots[i + 1] - m * r[i-1])
+
+        p[n-1] = r[n-1] / f[n-1]
+        for i in range(n-2, -1, -1):
+            p[i] = (r[i] - p[i+1]) / f[i]
+        p[n] = (3 * knots[n] - p[n-1]) / 2
+
+        for i in range(n):
+            p1, p2 = knots[i], knots[i+1]
+            c1, c2 = p[i], 2 * p2 - p[i+1]
+            self.path_commands[i] = SVGCommandBezier(p1, c1, c2, p2)
+
+        return self
+
+    def simplify_heuristic(self):
+        return self.copy().split(max_dist=2, include_lines=False) \
+            .simplify(tolerance=0.1, epsilon=0.2, angle_threshold=150) \
+            .split(max_dist=7.5)
+
+    def simplify(self, tolerance=0.1, epsilon=0.1, angle_threshold=179., force_smooth=False):
+        # https://github.com/paperjs/paper.js/blob/c044b698c6b224c10a7747664b2a4cd00a416a25/src/path/PathFitter.js#L44
+        points = [self.start_pos, *(path_command.end_pos for path_command in self.path_commands)]
+
+        def subdivide_indices():
+            segments_list = []
+            current_segment = []
+            prev_command = None
+
+            for i, command in enumerate(self.path_commands):
+                if isinstance(command, SVGCommandLine):
+                    if current_segment:
+                        segments_list.append(current_segment)
+                        current_segment = []
+                    prev_command = None
+
+                    continue
+
+                if prev_command is not None and prev_command.angle(command) < angle_threshold:
+                    if current_segment:
+                        segments_list.append(current_segment)
+                        current_segment = []
+
+                current_segment.append(i)
+                prev_command = command
+
+            if current_segment:
+                segments_list.append(current_segment)
+
+            return segments_list
+
+        path_commands = []
+
+        def computeMaxError(first, last, curve: SVGCommandBezier, u):
+            maxDist = 0.
+            index = (last - first + 1) // 2
+            for i in range(1, last - first):
+                dist = curve.eval(u[i]).dist(points[first + i]) ** 2
+                if dist >= maxDist:
+                    maxDist = dist
+                    index = first + i
+            return maxDist, index
+
+        def chordLengthParametrize(first, last):
+            u = [0.]
+            for i in range(1, last - first + 1):
+                u.append(u[i-1] + points[first + i].dist(points[first + i-1]))
+
+            for i, _ in enumerate(u[1:], 1):
+                u[i] /= u[-1]
+
+            return u
+
+        def isMachineZero(val):
+            MACHINE_EPSILON = 1.12e-16
+            return val >= -MACHINE_EPSILON and val <= MACHINE_EPSILON
+
+        def findRoot(curve: SVGCommandBezier, point, u):
+            """
+               Newton's root finding algorithm calculates f(x)=0 by reiterating
+               x_n+1 = x_n - f(x_n)/f'(x_n)
+               We are trying to find curve parameter u for some point p that minimizes
+               the distance from that point to the curve. Distance point to curve is d=q(u)-p.
+               At minimum distance the point is perpendicular to the curve.
+               We are solving
+               f = q(u)-p * q'(u) = 0
+               with
+               f' = q'(u) * q'(u) + q(u)-p * q''(u)
+               gives
+               u_n+1 = u_n - |q(u_n)-p * q'(u_n)| / |q'(u_n)**2 + q(u_n)-p * q''(u_n)|
+            """
+            diff = curve.eval(u) - point
+            d1, d2 = curve.derivative(u, n=1), curve.derivative(u, n=2)
+            numerator = diff.dot(d1)
+            denominator = d1.dot(d1) + diff.dot(d2)
+
+            return u if isMachineZero(denominator) else u - numerator / denominator
+
+        def reparametrize(first, last, u, curve: SVGCommandBezier):
+            for i in range(0, last - first + 1):
+                u[i] = findRoot(curve, points[first + i], u[i])
+
+            for i in range(1, len(u)):
+                if u[i] <= u[i-1]:
+                    return False
+
+            return True
+
+        def generateBezier(first, last, uPrime, tan1, tan2):
+            epsilon = 1e-12
+            p1, p2 = points[first], points[last]
+            C = np.zeros((2, 2))
+            X = np.zeros(2)
+
+            for i in range(last - first + 1):
+                u = uPrime[i]
+                t = 1 - u
+                b = 3 * u * t
+                b0 = t**3
+                b1 = b * t
+                b2 = b * u
+                b3 = u**3
+                a1 = tan1 * b1
+                a2 = tan2 * b2
+                tmp = points[first + i] - p1 * (b0 + b1) - p2 * (b2 + b3)
+
+                C[0, 0] += a1.dot(a1)
+                C[0, 1] += a1.dot(a2)
+                C[1, 0] = C[0, 1]
+                C[1, 1] += a2.dot(a2)
+                X[0] += a1.dot(tmp)
+                X[1] += a2.dot(tmp)
+
+            detC0C1 = C[0, 0] * C[1, 1] - C[1, 0] * C[0, 1]
+            if abs(detC0C1) > epsilon:
+                detC0X = C[0, 0] * X[1] - C[1, 0] * X[0]
+                detXC1 = X[0] * C[1, 1] - X[1] * C[0, 1]
+                alpha1 = detXC1 / detC0C1
+                alpha2 = detC0X / detC0C1
+            else:
+                c0 = C[0, 0] + C[0, 1]
+                c1 = C[1, 0] + C[1, 1]
+                alpha1 = alpha2 = X[0] / c0 if abs(c0) > epsilon else (X[1] / c1 if abs(c1) > epsilon else 0)
+
+            segLength = p2.dist(p1)
+            eps = epsilon * segLength
+            handle1 = handle2 = None
+
+            if alpha1 < eps or alpha2 < eps:
+                alpha1 = alpha2 = segLength / 3
+            else:
+                line = p2 - p1
+                handle1 = tan1 * alpha1
+                handle2 = tan2 * alpha2
+
+                if handle1.dot(line) - handle2.dot(line) > segLength**2:
+                    alpha1 = alpha2 = segLength / 3
+                    handle1 = handle2 = None
+
+            if handle1 is None or handle2 is None:
+                handle1 = tan1 * alpha1
+                handle2 = tan2 * alpha2
+
+            return SVGCommandBezier(p1, p1 + handle1, p2 + handle2, p2)
+
+        def computeLinearMaxError(first, last):
+            maxDist = 0.
+            index = (last - first + 1) // 2
+
+            p1, p2 = points[first], points[last]
+            for i in range(first + 1, last):
+                dist = points[i].distToLine(p1, p2)
+                if dist >= maxDist:
+                    maxDist = dist
+                    index = i
+            return maxDist, index
+
+        def ramerDouglasPeucker(first, last, epsilon):
+            max_error, split_index = computeLinearMaxError(first, last)
+
+            if max_error > epsilon:
+                ramerDouglasPeucker(first, split_index, epsilon)
+                ramerDouglasPeucker(split_index, last, epsilon)
+            else:
+                p1, p2 = points[first], points[last]
+                path_commands.append(SVGCommandLine(p1, p2))
+
+        def fitCubic(error, first, last, tan1=None, tan2=None):
+            # For convenience, compute extremity tangents if not provided
+            if tan1 is None and tan2 is None:
+                tan1 = (points[first + 1] - points[first]).normalize()
+                tan2 = (points[last - 1] - points[last]).normalize()
+
+            if last - first == 1:
+                p1, p2 = points[first], points[last]
+                dist = p1.dist(p2) / 3
+                path_commands.append(SVGCommandBezier(p1, p1 + dist * tan1, p2 + dist * tan2, p2))
+                return
+
+            uPrime = chordLengthParametrize(first, last)
+            maxError = max(error, error**2)
+            parametersInOrder = True
+
+            for i in range(5):
+                curve = generateBezier(first, last, uPrime, tan1, tan2)
+
+                max_error, split_index = computeMaxError(first, last, curve, uPrime)
+
+                if max_error < error and parametersInOrder:
+                    path_commands.append(curve)
+                    return
+
+                if max_error >= maxError:
+                    break
+
+                parametersInOrder = reparametrize(first, last, uPrime, curve)
+                maxError = max_error
+
+            tanCenter = (points[split_index-1] - points[split_index+1]).normalize()
+            fitCubic(error, first, split_index, tan1, tanCenter)
+            fitCubic(error, split_index, last, -tanCenter, tan2)
+
+        segments_list = subdivide_indices()
+        if force_smooth:
+            fitCubic(tolerance, 0, len(points) - 1)
+        else:
+            if segments_list:
+                seg = segments_list[0]
+                ramerDouglasPeucker(0, seg[0], epsilon)
+
+                for seg, seg_next in zip(segments_list[:-1], segments_list[1:]):
+                    fitCubic(tolerance, seg[0], seg[-1] + 1)
+                    ramerDouglasPeucker(seg[-1] + 1, seg_next[0], epsilon)
+
+                seg = segments_list[-1]
+                fitCubic(tolerance, seg[0], seg[-1] + 1)
+                ramerDouglasPeucker(seg[-1] + 1, len(points) - 1, epsilon)
+            else:
+                ramerDouglasPeucker(0, len(points) - 1, epsilon)
+
+        self.path_commands = path_commands
+
+        return self
+
+    def split(self, n=None, max_dist=None, include_lines=True):
+        path_commands = []
+
+        for command in self.path_commands:
+            if isinstance(command, SVGCommandLine) and not include_lines:
+                path_commands.append(command)
+            else:
+                l = command.length()
+                if max_dist is not None:
+                    n = max(math.ceil(l / max_dist), 1)
+
+                path_commands.extend(command.split(n=n))
+
+        self.path_commands = path_commands
+
+        return self
+
+    def bbox(self):
+        return union_bbox([cmd.bbox() for cmd in self.path_commands])
+
+    def sample_points(self, max_dist=0.4):
+        points = []
+
+        for command in self.path_commands:
+            l = command.length()
+            n = max(math.ceil(l / max_dist), 1)
+            points.extend(command.sample_points(n=n, return_array=True)[None])
+        points = np.concatenate(points, axis=0)
+        return points
+
+    def to_shapely(self):
+        polygon = shapely.geometry.Polygon(self.sample_points())
+
+        if not polygon.is_valid:
+            polygon = polygon.buffer(0)
+
+        return polygon
+
+    def to_points(self):
+        return np.array([self.start_pos.pos, *(cmd.end_pos.pos for cmd in self.path_commands)])

src/preprocessing/deepsvg/deepsvg_svglib/svg_primitive.py

@@ -0,0 +1,452 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+from __future__ import annotations
+from .geom import *
+import torch
+import re
+from typing import List, Union
+from xml.dom import minidom
+from .svg_path import SVGPath
+from .svg_command import SVGCommandLine, SVGCommandArc, SVGCommandBezier, SVGCommandClose
+import shapely as shapely
+import shapely.ops
+import shapely.geometry
+import networkx as nx
+
+
+FLOAT_RE = re.compile(r"[-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?")
+
+
+def extract_args(args):
+    return list(map(float, FLOAT_RE.findall(args)))
+
+
+class SVGPrimitive:
+    """
+    Reference: https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Basic_Shapes
+    """
+    def __init__(self, color="black", fill=False, dasharray=None, stroke_width=".3", opacity=1.0):
+        self.color = color
+        self.dasharray = dasharray
+        self.stroke_width = stroke_width
+        self.opacity = opacity
+
+        self.fill = fill
+
+    def _get_fill_attr(self):
+        fill_attr = f'fill="{self.color}" fill-opacity="{self.opacity}"' if self.fill else f'fill="none" stroke="{self.color}" stroke-width="{self.stroke_width}" stroke-opacity="{self.opacity}"'
+        if self.dasharray is not None and not self.fill:
+            fill_attr += f' stroke-dasharray="{self.dasharray}"'
+        return fill_attr
+
+    @classmethod
+    def from_xml(cls, x: minidom.Element):
+        raise NotImplementedError
+
+    def draw(self, viewbox=Bbox(24), *args, **kwargs):
+        from .svg import SVG
+        return SVG([self], viewbox=viewbox).draw(*args, **kwargs)
+
+    def _get_viz_elements(self, with_points=False, with_handles=False, with_bboxes=False, color_firstlast=True, with_moves=True):
+        return []
+
+    def to_path(self):
+        raise NotImplementedError
+
+    def copy(self):
+        raise NotImplementedError
+
+    def bbox(self):
+        raise NotImplementedError
+
+    def fill_(self, fill=True):
+        self.fill = fill
+        return self
+
+
+class SVGEllipse(SVGPrimitive):
+    def __init__(self, center: Point, radius: Radius, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.center = center
+        self.radius = radius
+
+    def __repr__(self):
+        return f'SVGEllipse(c={self.center} r={self.radius})'
+
+    def to_str(self, *args, **kwargs):
+        fill_attr = self._get_fill_attr()
+        return f'<ellipse {fill_attr} cx="{self.center.x}" cy="{self.center.y}" rx="{self.radius.x}" ry="{self.radius.y}"/>'
+
+    @classmethod
+    def from_xml(_, x: minidom.Element):
+        fill = not x.hasAttribute("fill") or not x.getAttribute("fill") == "none"
+
+        center = Point(float(x.getAttribute("cx")), float(x.getAttribute("cy")))
+        radius = Radius(float(x.getAttribute("rx")), float(x.getAttribute("ry")))
+        return SVGEllipse(center, radius, fill=fill)
+
+    def to_path(self):
+        p0, p1 = self.center + self.radius.xproj(), self.center + self.radius.yproj()
+        p2, p3 = self.center - self.radius.xproj(), self.center - self.radius.yproj()
+        commands = [
+            SVGCommandArc(p0, self.radius, Angle(0.), Flag(0.), Flag(1.), p1),
+            SVGCommandArc(p1, self.radius, Angle(0.), Flag(0.), Flag(1.), p2),
+            SVGCommandArc(p2, self.radius, Angle(0.), Flag(0.), Flag(1.), p3),
+            SVGCommandArc(p3, self.radius, Angle(0.), Flag(0.), Flag(1.), p0),
+        ]
+        return SVGPath(commands, closed=True).to_group(fill=self.fill)
+
+
+class SVGCircle(SVGEllipse):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        return f'SVGCircle(c={self.center} r={self.radius})'
+
+    def to_str(self, *args, **kwargs):
+        fill_attr = self._get_fill_attr()
+        return f'<circle {fill_attr} cx="{self.center.x}" cy="{self.center.y}" r="{self.radius.x}"/>'
+
+    @classmethod
+    def from_xml(_, x: minidom.Element):
+        fill = not x.hasAttribute("fill") or not x.getAttribute("fill") == "none"
+
+        center = Point(float(x.getAttribute("cx")), float(x.getAttribute("cy")))
+        radius = Radius(float(x.getAttribute("r")))
+        return SVGCircle(center, radius, fill=fill)
+
+
+class SVGRectangle(SVGPrimitive):
+    def __init__(self, xy: Point, wh: Size, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.xy = xy
+        self.wh = wh
+
+    def __repr__(self):
+        return f'SVGRectangle(xy={self.xy} wh={self.wh})'
+
+    def to_str(self, *args, **kwargs):
+        fill_attr = self._get_fill_attr()
+        return f'<rect {fill_attr} x="{self.xy.x}" y="{self.xy.y}" width="{self.wh.x}" height="{self.wh.y}"/>'
+
+    @classmethod
+    def from_xml(_, x: minidom.Element):
+        fill = not x.hasAttribute("fill") or not x.getAttribute("fill") == "none"
+
+        xy = Point(0.)
+        if x.hasAttribute("x"):
+            xy.pos[0] = float(x.getAttribute("x"))
+        if x.hasAttribute("y"):
+            xy.pos[1] = float(x.getAttribute("y"))
+        wh = Size(float(x.getAttribute("width")), float(x.getAttribute("height")))
+        return SVGRectangle(xy, wh, fill=fill)
+
+    def to_path(self):
+        p0, p1, p2, p3 = self.xy, self.xy + self.wh.xproj(), self.xy + self.wh, self.xy + self.wh.yproj()
+        commands = [
+            SVGCommandLine(p0, p1),
+            SVGCommandLine(p1, p2),
+            SVGCommandLine(p2, p3),
+            SVGCommandLine(p3, p0)
+        ]
+        return SVGPath(commands, closed=True).to_group(fill=self.fill)
+
+
+class SVGLine(SVGPrimitive):
+    def __init__(self, start_pos: Point, end_pos: Point, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.start_pos = start_pos
+        self.end_pos = end_pos
+
+    def __repr__(self):
+        return f'SVGLine(xy1={self.start_pos} xy2={self.end_pos})'
+
+    def to_str(self, *args, **kwargs):
+        fill_attr = self._get_fill_attr()
+        return f'<line {fill_attr} x1="{self.start_pos.x}" y1="{self.start_pos.y}" x2="{self.end_pos.x}" y2="{self.end_pos.y}"/>'
+
+    @classmethod
+    def from_xml(_, x: minidom.Element):
+        fill = not x.hasAttribute("fill") or not x.getAttribute("fill") == "none"
+
+        start_pos = Point(float(x.getAttribute("x1") or 0.), float(x.getAttribute("y1") or 0.))
+        end_pos = Point(float(x.getAttribute("x2") or 0.), float(x.getAttribute("y2") or 0.))
+        return SVGLine(start_pos, end_pos, fill=fill)
+
+    def to_path(self):
+        return SVGPath([SVGCommandLine(self.start_pos, self.end_pos)]).to_group(fill=self.fill)
+
+
+class SVGPolyline(SVGPrimitive):
+    def __init__(self, points: List[Point], *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.points = points
+
+    def __repr__(self):
+        return f'SVGPolyline(points={self.points})'
+
+    def to_str(self, *args, **kwargs):
+        fill_attr = self._get_fill_attr()
+        return '<polyline {} points="{}"/>'.format(fill_attr, ' '.join([p.to_str() for p in self.points]))
+
+    @classmethod
+    def from_xml(cls, x: minidom.Element):
+        fill = not x.hasAttribute("fill") or not x.getAttribute("fill") == "none"
+
+        args = extract_args(x.getAttribute("points"))
+        assert len(args) % 2 == 0, f"Expected even number of arguments for SVGPolyline: {len(args)} given"
+        points = [Point(x, args[2*i+1]) for i, x in enumerate(args[::2])]
+        return cls(points, fill=fill)
+
+    def to_path(self):
+        commands = [SVGCommandLine(p1, p2) for p1, p2 in zip(self.points[:-1], self.points[1:])]
+        is_closed = self.__class__.__name__ == "SVGPolygon"
+        return SVGPath(commands, closed=is_closed).to_group(fill=self.fill)
+
+
+class SVGPolygon(SVGPolyline):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        return f'SVGPolygon(points={self.points})'
+
+    def to_str(self, *args, **kwargs):
+        fill_attr = self._get_fill_attr()
+        return '<polygon {} points="{}"/>'.format(fill_attr, ' '.join([p.to_str() for p in self.points]))
+
+
+class SVGPathGroup(SVGPrimitive):
+    def __init__(self, svg_paths: List[SVGPath] = None, origin=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.svg_paths = svg_paths
+
+        if origin is None:
+            origin = Point(0.)
+        self.origin = origin
+
+    # Alias
+    @property
+    def paths(self):
+        return self.svg_paths
+
+    @property
+    def path(self):
+        return self.svg_paths[0]
+
+    def __getitem__(self, idx):
+        return self.svg_paths[idx]
+
+    def __len__(self):
+        return len(self.paths)
+
+    def total_len(self):
+        return sum([len(path) for path in self.svg_paths])
+
+    @property
+    def start_pos(self):
+        return self.svg_paths[0].start_pos
+
+    @property
+    def end_pos(self):
+        last_path = self.svg_paths[-1]
+        if last_path.closed:
+            return last_path.start_pos
+        return last_path.end_pos
+
+    def set_origin(self, origin: Point):
+        self.origin = origin
+        if self.svg_paths:
+            self.svg_paths[0].origin = origin
+        self.recompute_origins()
+
+    def append(self, path: SVGPath):
+        self.svg_paths.append(path)
+
+    def copy(self):
+        return SVGPathGroup([svg_path.copy() for svg_path in self.svg_paths], self.origin.copy(),
+                            self.color, self.fill, self.dasharray, self.stroke_width, self.opacity)
+
+    def __repr__(self):
+        return "SVGPathGroup({})".format(", ".join(svg_path.__repr__() for svg_path in self.svg_paths))
+
+    def _get_viz_elements(self, with_points=False, with_handles=False, with_bboxes=False, color_firstlast=True, with_moves=True):
+        viz_elements = []
+        for svg_path in self.svg_paths:
+            viz_elements.extend(svg_path._get_viz_elements(with_points, with_handles, with_bboxes, color_firstlast, with_moves))
+
+        if with_bboxes:
+            viz_elements.append(self._get_bbox_viz())
+
+        return viz_elements
+
+    def _get_bbox_viz(self):
+        color = "red" if self.color == "black" else self.color
+        bbox = self.bbox().to_rectangle(color=color)
+        return bbox
+
+    def to_path(self):
+        return self
+
+    def to_str(self, with_markers=False, *args, **kwargs):
+        fill_attr = self._get_fill_attr()
+        marker_attr = 'marker-start="url(#arrow)"' if with_markers else ''
+        return '<path {} {} filling="{}" d="{}"></path>'.format(fill_attr, marker_attr, self.path.filling,
+                                                   " ".join(svg_path.to_str() for svg_path in self.svg_paths))
+
+    def to_tensor(self, PAD_VAL=-1):
+        return torch.cat([p.to_tensor(PAD_VAL=PAD_VAL) for p in self.svg_paths], dim=0)
+
+    def _apply_to_paths(self, method, *args, **kwargs):
+        for path in self.svg_paths:
+            getattr(path, method)(*args, **kwargs)
+        return self
+
+    def translate(self, vec):
+        return self._apply_to_paths("translate", vec)
+
+    def rotate(self, angle: Angle):
+        return self._apply_to_paths("rotate", angle)
+
+    def scale(self, factor):
+        return self._apply_to_paths("scale", factor)
+
+    def numericalize(self, n=256):
+        return self._apply_to_paths("numericalize", n)
+
+    def drop_z(self):
+        return self._apply_to_paths("set_closed", False)
+
+    def recompute_origins(self):
+        origin = self.origin
+        for path in self.svg_paths:
+            path.origin = origin.copy()
+            origin = path.end_pos
+        return self
+
+    def reorder(self):
+        self._apply_to_paths("reorder")
+        self.recompute_origins()
+        return self
+
+    def filter_empty(self):
+        self.svg_paths = [path for path in self.svg_paths if path.path_commands]
+        return self
+
+    def canonicalize(self):
+        self.svg_paths = sorted(self.svg_paths, key=lambda x: x.start_pos.tolist()[::-1])
+        if not self.svg_paths[0].is_clockwise():
+            self._apply_to_paths("reverse")
+
+        self.recompute_origins()
+        return self
+
+    def reverse(self):
+        self._apply_to_paths("reverse")
+
+        self.recompute_origins()
+        return self
+
+    def duplicate_extremities(self):
+        self._apply_to_paths("duplicate_extremities")
+        return self
+
+    def reverse_non_closed(self):
+        self._apply_to_paths("reverse_non_closed")
+
+        self.recompute_origins()
+        return self
+
+    def simplify(self, tolerance=0.1, epsilon=0.1, angle_threshold=179., force_smooth=False):
+        self._apply_to_paths("simplify", tolerance=tolerance, epsilon=epsilon, angle_threshold=angle_threshold,
+                             force_smooth=force_smooth)
+        self.recompute_origins()
+        return self
+
+    def split_paths(self):
+        return [SVGPathGroup([svg_path], self.origin,
+                             self.color, self.fill, self.dasharray, self.stroke_width, self.opacity)
+                for svg_path in self.svg_paths]
+
+    def split(self, n=None, max_dist=None, include_lines=True):
+        return self._apply_to_paths("split", n=n, max_dist=max_dist, include_lines=include_lines)
+
+    def simplify_arcs(self):
+        return self._apply_to_paths("simplify_arcs")
+
+    def filter_consecutives(self):
+        return self._apply_to_paths("filter_consecutives")
+
+    def filter_duplicates(self):
+        return self._apply_to_paths("filter_duplicates")
+
+    def bbox(self):
+        return union_bbox([path.bbox() for path in self.svg_paths])
+
+    def to_shapely(self):
+        return shapely.ops.unary_union([path.to_shapely() for path in self.svg_paths])
+
+    def compute_filling(self):
+        if self.fill:
+            G = self.overlap_graph()
+
+            root_nodes = [i for i, d in G.in_degree() if d == 0]
+
+            for root in root_nodes:
+                if not self.svg_paths[root].closed:
+                    continue
+
+                current = [(1, root)]
+
+                while current:
+                    visited = set()
+                    neighbors = set()
+                    for d, n in current:
+                        self.svg_paths[n].set_filling(d != 0)
+
+                        for n2 in G.neighbors(n):
+                            if not n2 in visited:
+                                d2 = d + (self.svg_paths[n2].is_clockwise() == self.svg_paths[n].is_clockwise()) * 2 - 1
+                                visited.add(n2)
+                                neighbors.add((d2, n2))
+
+                    G.remove_nodes_from([n for d, n in current])
+
+                    current = [(d, n) for d, n in neighbors if G.in_degree(n) == 0]
+
+        return self
+
+    def overlap_graph(self, threshold=0.9, draw=False):
+        G = nx.DiGraph()
+        shapes = [path.to_shapely() for path in self.svg_paths]
+
+        for i, path1 in enumerate(shapes):
+            G.add_node(i)
+
+            if self.svg_paths[i].closed:
+                for j, path2 in enumerate(shapes):
+                    if i != j and self.svg_paths[j].closed:
+                        overlap = path1.intersection(path2).area / path1.area
+                        if overlap > threshold:
+                            G.add_edge(j, i, weight=overlap)
+
+        if draw:
+            pos = nx.spring_layout(G)
+            nx.draw_networkx(G, pos, with_labels=True)
+            labels = nx.get_edge_attributes(G, 'weight')
+            nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
+        return G
+
+    def bbox_overlap(self, other: SVGPathGroup):
+        return self.bbox().overlap(other.bbox())
+
+    def to_points(self):
+        return np.concatenate([path.to_points() for path in self.svg_paths])

src/preprocessing/deepsvg/deepsvg_svglib/svglib_utils.py

@@ -0,0 +1,95 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import src.preprocessing.deepsvg.deepsvg_svglib.svg as svg_lib
+from .geom import Bbox, Point
+import math
+import numpy as np
+import IPython.display as ipd
+from moviepy.editor import ImageClip, concatenate_videoclips, ipython_display
+
+
+def make_grid(svgs, num_cols=3, grid_width=24):
+    """
+        svgs: List[svg_lib.SVG]
+    """
+    nb_rows = math.ceil(len(svgs) / num_cols)
+    grid = svg_lib.SVG([], viewbox=Bbox(grid_width * num_cols, grid_width * nb_rows))
+
+    for i, svg in enumerate(svgs):
+        row, col = i // num_cols, i % num_cols
+        svg = svg.copy().translate(Point(grid_width * col, grid_width * row))
+
+        grid.add_path_groups(svg.svg_path_groups)
+
+    return grid
+
+
+def make_grid_grid(svg_grid, grid_width=24):
+    """
+        svg_grid: List[List[svg_lib.SVG]]
+    """
+    nb_rows = len(svg_grid)
+    num_cols = len(svg_grid[0])
+    grid = svg_lib.SVG([], viewbox=Bbox(grid_width * num_cols, grid_width * nb_rows))
+
+    for i, row in enumerate(svg_grid):
+        for j, svg in enumerate(row):
+            svg = svg.copy().translate(Point(grid_width * j, grid_width * i))
+
+            grid.add_path_groups(svg.svg_path_groups)
+
+    return grid
+
+
+def make_grid_lines(svg_grid, grid_width=24):
+    """
+        svg_grid: List[List[svg_lib.SVG]]
+    """
+    nb_rows = len(svg_grid)
+    num_cols = max(len(r) for r in svg_grid)
+    grid = svg_lib.SVG([], viewbox=Bbox(grid_width * num_cols, grid_width * nb_rows))
+
+    for i, row in enumerate(svg_grid):
+        for j, svg in enumerate(row):
+            j_shift = (num_cols - len(row)) // 2
+            svg = svg.copy().translate(Point(grid_width * (j + j_shift), grid_width * i))
+
+            grid.add_path_groups(svg.svg_path_groups)
+
+    return grid
+
+
+COLORS = ["aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", "bisque", "black", "blanchedalmond",
+          "blue", "blueviolet", "brown", "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue",
+          "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod", "darkgray", "darkgreen", "darkgrey",
+          "darkkhaki", "darkmagenta", "darkolivegreen", "darkorange", "darkorchid", "darkred", "darksalmon",
+          "darkseagreen", "darkslateblue", "darkslategray", "darkslategrey", "darkturquoise", "darkviolet", "deeppink",
+          "deepskyblue", "dimgray", "dimgrey", "dodgerblue", "firebrick", "floralwhite", "forestgreen", "fuchsia",
+          "gainsboro", "ghostwhite", "gold", "goldenrod", "gray", "green", "greenyellow", "grey", "honeydew", "hotpink",
+          "indianred", "indigo", "ivory", "khaki", "lavender", "lavenderblush", "lawngreen", "lemonchiffon",
+          "lightblue", "lightcoral", "lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen", "lightgrey",
+          "lightpink", "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray", "lightslategrey",
+          "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta", "maroon", "mediumaquamarine",
+          "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen", "mediumslateblue", "mediumspringgreen",
+          "mediumturquoise", "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin", "navajowhite",
+          "navy", "oldlace", "olive", "olivedrab", "orange", "orangered", "orchid", "palegoldenrod", "palegreen",
+          "paleturquoise", "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple",
+          "red", "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen", "seashell", "sienna",
+          "silver", "skyblue", "slateblue", "slategray", "slategrey", "snow", "springgreen", "steelblue", "tan", "teal",
+          "thistle", "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke", "yellow", "yellowgreen"]
+
+
+def to_gif(img_list, file_path=None, frame_duration=0.1, do_display=True):
+    clips = [ImageClip(np.array(img)).set_duration(frame_duration) for img in img_list]
+
+    clip = concatenate_videoclips(clips, method="compose", bg_color=(255, 255, 255))
+
+    if file_path is not None:
+        clip.write_gif(file_path, fps=24, verbose=False, logger=None)
+
+    if do_display:
+        src = clip if file_path is None else file_path
+        ipd.display(ipython_display(src, fps=24, rd_kwargs=dict(logger=None), autoplay=1, loop=1))

src/preprocessing/deepsvg/deepsvg_svglib/util_fns.py

@@ -0,0 +1,22 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import math
+
+
+def get_roots(a, b, c):
+    if a == 0:
+        if b == 0:
+            return []
+        return [-c / b]
+    r = b * b - 4 * a * c
+    if r < 0:
+        return []
+    elif r == 0:
+        x0 = -b / (2 * a)
+        return [x0]
+
+    x1, x2 = (-b - math.sqrt(r)) / (2 * a), (-b + math.sqrt(r)) / (2 * a)
+    return x1, x2

src/preprocessing/deepsvg/deepsvg_utils/train_utils.py

@@ -0,0 +1,241 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import shutil
+import torch
+import torch.nn as nn
+import os
+import random
+import numpy as np
+import glob
+
+
+def save_ckpt(checkpoint_dir, model, cfg=None, optimizer=None, scheduler_lr=None, scheduler_warmup=None,
+              stats=None, train_vars=None):
+    if is_multi_gpu(model):
+        model = model.module
+
+    state = {
+        "model": model.state_dict()
+    }
+
+    if optimizer is not None:
+        state["optimizer"] = optimizer.state_dict()
+    if scheduler_lr is not None:
+        state["scheduler_lr"] = scheduler_lr.state_dict()
+    if scheduler_warmup is not None:
+        state["scheduler_warmup"] = scheduler_warmup.state_dict()
+    if cfg is not None:
+        state["cfg"] = cfg.to_dict()
+    if stats is not None:
+        state["stats"] = stats.to_dict()
+    if train_vars is not None:
+        state["train_vars"] = train_vars.to_dict()
+
+    checkpoint_path = os.path.join(checkpoint_dir, "{:06d}.pth.tar".format(stats.step))
+
+    if not os.path.exists(checkpoint_dir):
+        os.makedirs(checkpoint_dir)
+    torch.save(state, checkpoint_path)
+
+    if stats.is_best():
+        best_model_path = os.path.join(checkpoint_dir, "best.pth.tar")
+        shutil.copyfile(checkpoint_path, best_model_path)
+
+
+def save_ckpt_list(checkpoint_dir, model, cfg=None, optimizers=None, scheduler_lrs=None, scheduler_warmups=None,
+              stats=None, train_vars=None):
+    if is_multi_gpu(model):
+        model = model.module
+
+    state = {
+        "model": model.state_dict()
+    }
+
+    if optimizers is not None:
+        state["optimizers"] = [optimizer.state_dict() if optimizer is not None else optimizer for optimizer in optimizers]
+    if scheduler_lrs is not None:
+        state["scheduler_lrs"] = [scheduler_lr.state_dict() if scheduler_lr is not None else scheduler_lr for scheduler_lr in scheduler_lrs]
+    if scheduler_warmups is not None:
+        state["scheduler_warmups"] = [scheduler_warmup.state_dict() if scheduler_warmup is not None else None for scheduler_warmup in scheduler_warmups]
+    if cfg is not None:
+        state["cfg"] = cfg.to_dict()
+    if stats is not None:
+        state["stats"] = stats.to_dict()
+    if train_vars is not None:
+        state["train_vars"] = train_vars.to_dict()
+
+    checkpoint_path = os.path.join(checkpoint_dir, "{:06d}.pth.tar".format(stats.step))
+
+    if not os.path.exists(checkpoint_dir):
+        os.makedirs(checkpoint_dir)
+    torch.save(state, checkpoint_path)
+
+    if stats.is_best():
+        best_model_path = os.path.join(checkpoint_dir, "best.pth.tar")
+        shutil.copyfile(checkpoint_path, best_model_path)
+
+
+def load_ckpt(checkpoint_dir, model, cfg=None, optimizer=None, scheduler_lr=None, scheduler_warmup=None,
+              stats=None, train_vars=None):
+    if not os.path.exists(checkpoint_dir):
+        return False
+
+    if os.path.isfile(checkpoint_dir):
+        checkpoint_path = checkpoint_dir
+    else:
+        ckpts_paths = sorted(glob.glob(os.path.join(checkpoint_dir, "./[0-9]*.pth.tar")))
+        if not ckpts_paths:
+            return False
+        checkpoint_path = ckpts_paths[-1]
+
+    state = torch.load(checkpoint_path, map_location=torch.device('cpu'))
+
+    if is_multi_gpu(model):
+        model = model.module
+    model.load_state_dict(state["model"], strict=False)
+
+    if optimizer is not None:
+        optimizer.load_state_dict(state["optimizer"])
+    if scheduler_lr is not None:
+        scheduler_lr.load_state_dict(state["scheduler_lr"])
+    if scheduler_warmup is not None:
+        scheduler_warmup.load_state_dict(state["scheduler_warmup"])
+    if cfg is not None:
+        cfg.load_dict(state["cfg"])
+    if stats is not None:
+        stats.load_dict(state["stats"])
+    if train_vars is not None:
+        train_vars.load_dict(state["train_vars"])
+
+    return True
+
+
+def load_ckpt_list(checkpoint_dir, model, cfg=None, optimizers=None, scheduler_lrs=None, scheduler_warmups=None,
+              stats=None, train_vars=None):
+    if not os.path.exists(checkpoint_dir):
+        return False
+
+    if os.path.isfile(checkpoint_dir):
+        checkpoint_path = checkpoint_dir
+    else:
+        ckpts_paths = sorted(glob.glob(os.path.join(checkpoint_dir, "./[0-9]*.pth.tar")))
+        if not ckpts_paths:
+            return False
+        checkpoint_path = ckpts_paths[-1]
+
+    state = torch.load(checkpoint_path, map_location=torch.device('cpu'))
+
+    if is_multi_gpu(model):
+        model = model.module
+    model.load_state_dict(state["model"], strict=False)
+
+    for optimizer, scheduler_lr, scheduler_warmup, optimizer_sd, scheduler_lr_sd, scheduler_warmups_sd in zip(optimizers, scheduler_lrs, scheduler_warmups, state["optimizers"], state["scheduler_lrs"], state["scheduler_warmups"]):
+        if optimizer is not None and optimizer_sd is not None:
+            optimizer.load_state_dict(optimizer_sd)
+        if scheduler_lr is not None and scheduler_lr_sd is not None:
+            scheduler_lr.load_state_dict(scheduler_lr_sd)
+        if scheduler_warmup is not None and scheduler_warmups_sd is not None:
+            scheduler_warmup.load_state_dict(scheduler_warmups_sd)
+    if cfg is not None and state["cfg"] is not None:
+        cfg.load_dict(state["cfg"])
+    if stats is not None and state["stats"] is not None:
+        stats.load_dict(state["stats"])
+    if train_vars is not None and state["train_vars"] is not None:
+        train_vars.load_dict(state["train_vars"])
+
+    return True
+
+
+def load_model(checkpoint_path, model):
+    state = torch.load(checkpoint_path, map_location=torch.device('cpu'))
+
+    if is_multi_gpu(model):
+        model = model.module
+    model.load_state_dict(state["model"], strict=False)
+
+
+def is_multi_gpu(model):
+    return isinstance(model, nn.DataParallel)
+
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+def pad_sequence(sequences, batch_first=False, padding_value=0, max_len=None):
+    r"""Pad a list of variable length Tensors with ``padding_value``
+
+    ``pad_sequence`` stacks a list of Tensors along a new dimension,
+    and pads them to equal length. For example, if the input is list of
+    sequences with size ``L x *`` and if batch_first is False, and ``T x B x *``
+    otherwise.
+
+    `B` is batch size. It is equal to the number of elements in ``sequences``.
+    `T` is length of the longest sequence.
+    `L` is length of the sequence.
+    `*` is any number of trailing dimensions, including none.
+
+    Example:
+        >>> from torch.nn.utils.rnn import pad_sequence
+        >>> a = torch.ones(25, 300)
+        >>> b = torch.ones(22, 300)
+        >>> c = torch.ones(15, 300)
+        >>> pad_sequence([a, b, c]).size()
+        torch.Size([25, 3, 300])
+
+    Note:
+        This function returns a Tensor of size ``T x B x *`` or ``B x T x *``
+        where `T` is the length of the longest sequence. This function assumes
+        trailing dimensions and type of all the Tensors in sequences are same.
+
+    Arguments:
+        sequences (list[Tensor]): list of variable length sequences.
+        batch_first (bool, optional): output will be in ``B x T x *`` if True, or in
+            ``T x B x *`` otherwise
+        padding_value (float, optional): value for padded elements. Default: 0.
+
+    Returns:
+        Tensor of size ``T x B x *`` if :attr:`batch_first` is ``False``.
+        Tensor of size ``B x T x *`` otherwise
+    """
+
+    # assuming trailing dimensions and type of all the Tensors
+    # in sequences are same and fetching those from sequences[0]
+    max_size = sequences[0].size()
+    trailing_dims = max_size[1:]
+
+    if max_len is None:
+        max_len = max([s.size(0) for s in sequences])
+    if batch_first:
+        out_dims = (len(sequences), max_len) + trailing_dims
+    else:
+        out_dims = (max_len, len(sequences)) + trailing_dims
+
+    out_tensor = sequences[0].data.new(*out_dims).fill_(padding_value)
+    for i, tensor in enumerate(sequences):
+        length = tensor.size(0)
+        # use index notation to prevent duplicate references to the tensor
+        if batch_first:
+            out_tensor[i, :length, ...] = tensor
+        else:
+            out_tensor[:length, i, ...] = tensor
+
+    return out_tensor
+
+
+def set_seed(_seed=42):
+    random.seed(_seed)
+    np.random.seed(_seed)
+    torch.manual_seed(_seed)
+    torch.cuda.manual_seed(_seed)
+    torch.cuda.manual_seed_all(_seed)
+    os.environ['PYTHONHASHSEED'] = str(_seed)
+
+
+def infinite_range(start_idx=0):
+    while True:
+        yield start_idx
+        start_idx += 1

src/preprocessing/deepsvg/deepsvg_utils/utils.py

@@ -0,0 +1,54 @@
+"""This code is taken from <https://github.com/alexandre01/deepsvg>
+by Alexandre Carlier, Martin Danelljan, Alexandre Alahi and Radu Timofte
+from the paper >https://arxiv.org/pdf/2007.11301.pdf>
+"""
+
+import torch
+
+
+def linear(a, b, x, min_x, max_x):
+    """
+    b             ___________
+                /|
+               / |
+    a  _______/  |
+              |  |
+           min_x max_x
+    """
+    return a + min(max((x - min_x) / (max_x - min_x), 0), 1) * (b - a)
+
+
+def batchify(data, device):
+    return (d.unsqueeze(0).to(device) for d in data)
+
+
+def _make_seq_first(*args):
+    # N, G, S, ... -> S, G, N, ...
+    if len(args) == 1:
+        arg, = args
+        return arg.permute(2, 1, 0, *range(3, arg.dim())) if arg is not None else None
+    return (*(arg.permute(2, 1, 0, *range(3, arg.dim())) if arg is not None else None for arg in args),)
+
+
+def _make_batch_first(*args):
+    # S, G, N, ... -> N, G, S, ...
+    if len(args) == 1:
+        arg, = args
+        return arg.permute(2, 1, 0, *range(3, arg.dim())) if arg is not None else None
+    return (*(arg.permute(2, 1, 0, *range(3, arg.dim())) if arg is not None else None for arg in args),)
+
+
+def _pack_group_batch(*args):
+    # S, G, N, ... -> S, G * N, ...
+    if len(args) == 1:
+        arg, = args
+        return arg.reshape(arg.size(0), arg.size(1) * arg.size(2), *arg.shape[3:]) if arg is not None else None
+    return (*(arg.reshape(arg.size(0), arg.size(1) * arg.size(2), *arg.shape[3:]) if arg is not None else None for arg in args),)
+
+
+def _unpack_group_batch(N, *args):
+    # S, G * N, ... -> S, G, N, ...
+    if len(args) == 1:
+        arg, = args
+        return arg.reshape(arg.size(0), -1, N, *arg.shape[2:]) if arg is not None else None
+    return (*(arg.reshape(arg.size(0), -1, N, *arg.shape[2:]) if arg is not None else None for arg in args),)

src/preprocessing/preprocessing.py

@@ -0,0 +1,157 @@
+# Imports
+import os
+import copy
+import torch
+import glob
+import pandas as pd
+import pickle
+from xml.dom import minidom
+from svgpathtools import svg2paths2
+from svgpathtools import wsvg
+import sys
+sys.path.append(os.getcwd())
+from src.preprocessing.deepsvg.deepsvg_svglib.svg import SVG
+from src.preprocessing.deepsvg.deepsvg_config import config_hierarchical_ordered
+from src.preprocessing.deepsvg.deepsvg_utils import train_utils
+from src.preprocessing.deepsvg.deepsvg_utils import utils
+from src.preprocessing.deepsvg.deepsvg_dataloader import svg_dataset
+
+# ---- Methods for embedding logos ----
+
+def compute_embedding_folder(folder_path: str, model_path: str, save: str = None) -> pd.DataFrame:
+    data_list = []
+    for file in os.listdir(folder_path):
+        print('File: ' + file)
+        try:
+            embedding = compute_embedding(os.path.join(folder_path, file), model_path)
+            embedding['filename'] = file
+            data_list.append(embedding)
+        except:
+            print('Embedding failed')
+    print('Concatenating')
+    data = pd.concat(data_list)
+    if not save == None:
+        output = open(os.path.join(save, 'svg_embedding_5000.pkl'), 'wb')
+        pickle.dump(data, output)
+        output.close()
+    return data
+    
+
+def compute_embedding(path: str, model_path: str, save: str = None) -> pd.DataFrame:
+    # Convert all primitives to SVG paths - TODO text
+    paths, attributes, svg_attributes = svg2paths2(path) # In previous project, this is performed at the end
+    wsvg(paths, attributes=attributes, svg_attributes=svg_attributes, filename=path)
+    
+    svg = SVG.load_svg(path)
+    svg.normalize() # Using DeepSVG normalize instead of expanding viewbox - TODO check is this equal?
+    svg_str = svg.to_str()
+    
+    # Assign animation id to every path - TODO this changes the original logo!
+    document = minidom.parseString(svg_str)
+    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'))
+
+    # Decompose SVGs
+
+    decomposed_svgs = {}
+    
+    for i in range(len(paths)):
+        doc_temp = copy.deepcopy(document)
+        paths_temp = doc_temp.getElementsByTagName('path')
+        current_path = paths_temp[i]
+        # Iteratively choose path i and remove all others
+        remove_temp = paths_temp[:i] + paths_temp[i+1:]
+        for path in remove_temp:
+            if not path.parentNode.nodeName == 'clipPath':
+                path.parentNode.removeChild(path)
+        # Check for style attributes; add in case there are none
+        if len(current_path.getAttribute('style')) <= 0:
+            current_path.setAttribute('stroke', 'black')
+            current_path.setAttribute('stroke-width', '2')
+        id = current_path.getAttribute('animation_id')
+        decomposed_svgs[id] = doc_temp.toprettyxml(encoding='iso-8859-1')
+        doc_temp.unlink()
+    #print(decomposed_svgs)
+    meta = {}
+    for id in decomposed_svgs:
+        svg_d_str = decomposed_svgs[id]
+        # Load into SVG and canonicalize
+        current_svg = SVG.from_str(svg_d_str)
+        # Canonicalize
+        current_svg.canonicalize() # Applies DeepSVG canonicalize; previously custom methods were used
+        decomposed_svgs[id] = current_svg.to_str()
+        if not os.path.exists('data/temp_svg'):
+            os.mkdir('data/temp_svg')
+        with open(('data/temp_svg/path_' + str(id)) + '.svg', 'w') as svg_file:
+            svg_file.write(decomposed_svgs[id])
+
+        # Collect metadata
+        len_groups = [path_group.total_len() for path_group in current_svg.svg_path_groups]
+        start_pos = [path_group.svg_paths[0].start_pos for path_group in current_svg.svg_path_groups]
+        try:
+            total_len = sum(len_groups)
+            nb_groups = len(len_groups)
+            max_len_group = max(len_groups)
+        except:
+            total_len = 0
+            nb_groups = 0
+            max_len_group = 0
+        
+        meta[id] = {
+            'id': id,
+            'total_len': total_len,
+            'nb_groups': nb_groups,
+            'len_groups': len_groups,
+            'max_len_group': max_len_group,
+            'start_pos': start_pos
+        }
+    metadata = pd.DataFrame(meta.values())
+    #print(metadata)
+    if not os.path.exists('data/metadata'):
+        os.mkdir('data/metadata')
+    metadata.to_csv('data/metadata/metadata.csv', index=False)
+    # Load pretrained DeepSVG model
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    cfg = config_hierarchical_ordered.Config()
+    model = cfg.make_model().to(device)
+    train_utils.load_model(model_path, model)
+    model.eval()
+    # Load dataset
+    cfg.data_dir = 'data/temp_svg/'
+    cfg.meta_filepath = 'data/metadata/metadata.csv'
+    dataset = svg_dataset.load_dataset(cfg)
+    svg_files = glob.glob('data/temp_svg/*.svg')
+    #print(svg_files)
+    svg_list = []
+    for svg_file in svg_files:
+        id = svg_file.split('\\')[1].split('_')[1].split('.')[0]
+        # Preprocessing
+        svg = SVG.load_svg(svg_file)
+        svg = dataset.simplify(svg)
+        svg = dataset.preprocess(svg, augment=False)
+        data = dataset.get(svg=svg)
+        # Get embedding
+        model_args = utils.batchify((data[key] for key in cfg.model_args), device)
+        with torch.no_grad():
+            z = model(*model_args, encode_mode=True).cpu().numpy()[0][0][0]
+        dict_data = {
+            'animation_id': id,
+            'embedding': z
+        }
+        svg_list.append(dict_data)
+    data = pd.DataFrame.from_records(svg_list, index='animation_id')['embedding'].apply(pd.Series)
+    data.reset_index(level=0, inplace=True)
+    data.dropna(inplace=True)
+    data.reset_index(drop=True, inplace=True)
+    if not save == None:
+        output = open(os.path.join(save, 'svg_embedding_5000.pkl'), 'wb')
+        pickle.dump(data, output)
+        output.close()
+    print('Embedding computed')
+    return data
+
+
+#compute_embedding_folder('data/raw_dataset', 'src/preprocessing/deepsvg/deepsvg_models/deepSVG_hierarchical_ordered.pth.tar', 'data/embedding')