lib

def backwards_id_conversion(data_by_layer_id):
    """Convert layer ids to strings from integers."""
    for key in tuple(data_by_layer_id.keys()):
        if not isinstance(key, str):
            data_by_layer_id[str(key)] = data_by_layer_id.pop(key)

def calculate_layer_frame_references(
    range_start, range_end,
    layer_frame_start,
    layer_frame_end,
    exposure_frames,
    pre_beh, post_beh
):
    """Calculate frame references for one layer based on it's data.

    Output is dictionary where key is frame index referencing to rendered frame
    index. If frame index should be rendered then is referencing to self.

    ```
    // Example output
    {
        1: 1, // Reference to self - will be rendered
        2: 1, // Reference to frame 1 - will be copied
        3: 1, // Reference to frame 1 - will be copied
        4: 4, // Reference to self - will be rendered
        ...
        20: 4 // Reference to frame 4 - will be copied
        21: None // Has reference to None - transparent image
    }
    ```

    Args:
        range_start(int): First frame of range which should be rendered.
        range_end(int): Last frame of range which should be rendered.
        layer_frame_start(int)L First frame of layer.
        layer_frame_end(int): Last frame of layer.
        exposure_frames(list): List of all exposure frames on layer.
        pre_beh(str): Pre behavior of layer (enum of 4 strings).
        post_beh(str): Post behavior of layer (enum of 4 strings).
    """
    # Output variable
    output_idx_by_frame_idx = {}
    # Skip if layer does not have any exposure frames
    if not exposure_frames:
        return output_idx_by_frame_idx

    # First calculate in range frames
    _calculate_in_range_frames(
        range_start, range_end,
        exposure_frames, layer_frame_end,
        output_idx_by_frame_idx
    )
    # Calculate frames by pre behavior of layer
    _calculate_pre_behavior_copy(
        range_start, exposure_frames, pre_beh,
        layer_frame_start, layer_frame_end,
        output_idx_by_frame_idx
    )
    # Calculate frames by post behavior of layer
    _calculate_post_behavior_copy(
        range_end, exposure_frames, post_beh,
        layer_frame_start, layer_frame_end,
        output_idx_by_frame_idx
    )
    # Cleanup of referenced frames
    _cleanup_frame_references(output_idx_by_frame_idx)

    # Remove frames out of range
    _cleanup_out_range_frames(output_idx_by_frame_idx, range_start, range_end)

    return output_idx_by_frame_idx

def calculate_layers_extraction_data(
    layers_data,
    exposure_frames_by_layer_id,
    behavior_by_layer_id,
    range_start,
    range_end,
    skip_not_visible=True,
    filename_prefix=None,
    ext=None
):
    """Calculate extraction data for passed layers data.

    ```
    {
        <layer_id>: {
            "frame_references": {...},
            "filenames_by_frame_index": {...}
        },
        ...
    }
    ```

    Frame references contains frame index reference to rendered frame index.

    Filename by frame index represents filename under which should be frame
    stored. Directory is not handled here because each usage may need different
    approach.

    Args:
        layers_data(list): Layers data loaded from TVPaint.
        exposure_frames_by_layer_id(dict): Exposure frames of layers stored by
            layer id.
        behavior_by_layer_id(dict): Pre and Post behavior of layers stored by
            layer id.
        range_start(int): First frame of rendered range.
        range_end(int): Last frame of rendered range.
        skip_not_visible(bool): Skip calculations for hidden layers (Skipped
            by default).
        filename_prefix(str): Prefix before filename.
        ext(str): Extension which filenames will have ('.png' is default).

    Returns:
        dict: Prepared data for rendering by layer position.
    """
    # Make sure layer ids are strings
    #   backwards compatibility when layer ids were integers
    backwards_id_conversion(exposure_frames_by_layer_id)
    backwards_id_conversion(behavior_by_layer_id)

    layer_template = get_layer_pos_filename_template(
        range_end, filename_prefix, ext
    )
    output = {}
    for layer_data in layers_data:
        if skip_not_visible and not layer_data["visible"]:
            continue

        orig_layer_id = layer_data["layer_id"]
        layer_id = str(orig_layer_id)

        # Skip if does not have any exposure frames (empty layer)
        exposure_frames = exposure_frames_by_layer_id[layer_id]
        if not exposure_frames:
            continue

        layer_position = layer_data["position"]
        layer_frame_start = layer_data["frame_start"]
        layer_frame_end = layer_data["frame_end"]

        layer_behavior = behavior_by_layer_id[layer_id]

        pre_behavior = layer_behavior["pre"]
        post_behavior = layer_behavior["post"]

        frame_references = calculate_layer_frame_references(
            range_start, range_end,
            layer_frame_start,
            layer_frame_end,
            exposure_frames,
            pre_behavior, post_behavior
        )
        # All values in 'frame_references' reference to a frame that must be
        #   rendered out
        frames_to_render = set(frame_references.values())
        # Remove 'None' reference (transparent image)
        if None in frames_to_render:
            frames_to_render.remove(None)

        # Skip layer if has nothing to render
        if not frames_to_render:
            continue

        # All filenames that should be as output (not final output)
        filename_frames = (
            set(range(range_start, range_end + 1))
            | frames_to_render
        )
        filenames_by_frame_index = {}
        for frame_idx in filename_frames:
            filenames_by_frame_index[frame_idx] = layer_template.format(
                pos=layer_position,
                frame=frame_idx
            )

        # Store objects under the layer id
        output[orig_layer_id] = {
            "frame_references": frame_references,
            "filenames_by_frame_index": filenames_by_frame_index
        }
    return output

def cleanup_rendered_layers(filepaths_by_layer_id):
    """Delete all files for each individual layer files after compositing."""
    # Collect all filepaths from data
    all_filepaths = []
    for filepaths_by_frame in filepaths_by_layer_id.values():
        all_filepaths.extend(filepaths_by_frame.values())

    # Loop over loop
    for filepath in set(all_filepaths):
        if filepath is not None and os.path.exists(filepath):
            os.remove(filepath)

def composite_images(input_image_paths, output_filepath):
    """Composite images in order from passed list.

    Raises:
        ValueError: When entered list is empty.
    """
    if not input_image_paths:
        raise ValueError("Nothing to composite.")

    img_obj = None
    for image_filepath in input_image_paths:
        _img_obj = Image.open(image_filepath)
        if img_obj is None:
            img_obj = _img_obj
        else:
            img_obj.alpha_composite(_img_obj)
    img_obj.save(output_filepath)

def composite_rendered_layers(
    layers_data, filepaths_by_layer_id,
    range_start, range_end,
    dst_filepaths_by_frame, cleanup=True
):
    """Composite multiple rendered layers by their position.

    Result is single frame sequence with transparency matching content
    created in TVPaint. Missing source filepaths are replaced with transparent
    images but at least one image must be rendered and exist.

    Function can be used even if single layer was created to fill transparent
    filepaths.

    Args:
        layers_data(list): Layers data loaded from TVPaint.
        filepaths_by_layer_id(dict): Rendered filepaths stored by frame index
            per layer id. Used as source for compositing.
        range_start(int): First frame of rendered range.
        range_end(int): Last frame of rendered range.
        dst_filepaths_by_frame(dict): Output filepaths by frame where final
            image after compositing will be stored. Path must not clash with
            source filepaths.
        cleanup(bool): Remove all source filepaths when done with compositing.
    """
    # Prepare layers by their position
    #   - position tells in which order will compositing happen
    layer_ids_by_position = {}
    for layer in layers_data:
        layer_position = layer["position"]
        layer_ids_by_position[layer_position] = layer["layer_id"]

    # Sort layer positions
    sorted_positions = tuple(reversed(sorted(layer_ids_by_position.keys())))
    # Prepare variable where filepaths without any rendered content
    #   - transparent will be created
    transparent_filepaths = set()
    # Store first final filepath
    first_dst_filepath = None
    for frame_idx in range(range_start, range_end + 1):
        dst_filepath = dst_filepaths_by_frame[frame_idx]
        src_filepaths = []
        for layer_position in sorted_positions:
            layer_id = layer_ids_by_position[layer_position]
            filepaths_by_frame = filepaths_by_layer_id[layer_id]
            src_filepath = filepaths_by_frame.get(frame_idx)
            if src_filepath is not None:
                src_filepaths.append(src_filepath)

        if not src_filepaths:
            transparent_filepaths.add(dst_filepath)
            continue

        # Store first destination filepath to be used for transparent images
        if first_dst_filepath is None:
            first_dst_filepath = dst_filepath

        if len(src_filepaths) == 1:
            src_filepath = src_filepaths[0]
            if cleanup:
                os.rename(src_filepath, dst_filepath)
            else:
                copy_render_file(src_filepath, dst_filepath)

        else:
            composite_images(src_filepaths, dst_filepath)

    # Store first transparent filepath to be able copy it
    transparent_filepath = None
    for dst_filepath in transparent_filepaths:
        if transparent_filepath is None:
            create_transparent_image_from_source(
                first_dst_filepath, dst_filepath
            )
            transparent_filepath = dst_filepath
        else:
            copy_render_file(transparent_filepath, dst_filepath)

    # Remove all files that were used as source for compositing
    if cleanup:
        cleanup_rendered_layers(filepaths_by_layer_id)

def copy_render_file(src_path, dst_path):
    """Create copy file of an image."""
    if hasattr(os, "link"):
        os.link(src_path, dst_path)
    else:
        shutil.copy(src_path, dst_path)

def create_transparent_image_from_source(src_filepath, dst_filepath):
    """Create transparent image of same type and size as source image."""
    img_obj = Image.open(src_filepath)
    painter = ImageDraw.Draw(img_obj)
    painter.rectangle((0, 0, *img_obj.size), fill=(0, 0, 0, 0))
    img_obj.save(dst_filepath)

def get_frame_filename_template(frame_end, filename_prefix=None, ext=None):
    """Get file template with frame key for rendered files.

    This is simple template contains `{frame}{ext}` for sequential outputs
    and `single_file{ext}` for single file output. Output is rendered to
    temporary folder so filename should not matter as integrator change
    them.
    """
    frame_padding = 4
    frame_end_str_len = len(str(frame_end))
    if frame_end_str_len > frame_padding:
        frame_padding = frame_end_str_len

    ext = ext or ".png"
    filename_prefix = filename_prefix or ""

    return "{}{{frame:0>{}}}{}".format(filename_prefix, frame_padding, ext)

def rename_filepaths_by_frame_start(
    filepaths_by_frame, range_start, range_end, new_frame_start
):
    """Change frames in filenames of finished images to new frame start."""

    # Calculate frame end
    new_frame_end = range_end + (new_frame_start - range_start)
    # Create filename template
    filename_template = get_frame_filename_template(
        max(range_end, new_frame_end)
    )

    # Use different ranges based on Mark In and output Frame Start values
    # - this is to make sure that filename renaming won't affect files that
    #   are not renamed yet
    if range_start < new_frame_start:
        source_range = range(range_end, range_start - 1, -1)
        output_range = range(new_frame_end, new_frame_start - 1, -1)
    else:
        # This is less possible situation as frame start will be in most
        #   cases higher than Mark In.
        source_range = range(range_start, range_end + 1)
        output_range = range(new_frame_start, new_frame_end + 1)

    # Skip if source first frame is same as destination first frame
    new_dst_filepaths = {}
    for src_frame, dst_frame in zip(source_range, output_range):
        src_filepath = os.path.normpath(filepaths_by_frame[src_frame])
        dirpath, src_filename = os.path.split(src_filepath)
        dst_filename = filename_template.format(frame=dst_frame)
        dst_filepath = os.path.join(dirpath, dst_filename)

        if src_filename != dst_filename:
            os.rename(src_filepath, dst_filepath)

        new_dst_filepaths[dst_frame] = dst_filepath

    return new_dst_filepaths