🎥 Natron Integration - Technical Breakthrough¶

# Script: natron_zigzag_save_project.py
def create_project():
    # Create nodes (Background, Text, Transform, Merge, Write)
    # Configure parameters (motion blur, colors, text)
    # Create animations (zigzag keyframes + rotations)
    # Connect complete pipeline
    app.saveProject("proyecto.ntp")  # CRITICAL: Save first

# Script: natron_zigzag_render_project.py
def render_project():
    app.loadProject("proyecto.ntp")  # Load saved project
    writer = app.getNode("RenderFinal")
    app.render(writer, 1, 120, 1)  # Render successfully

writer = app.createNode("fr.inria.built-in.Write")
writer.getParam("encodingPluginID").setValue("fr.inria.openfx.WriteFFmpeg")  # FIRST
writer.getParam("format").setValue(5)    # mp4
writer.getParam("codec").setValue(40)    # libx264  
writer.getParam("crf").setValue(3)       # crf20 (high quality)

class NatronProjectBuilder:
    def __init__(self):
        self.node_graph = {}
        self.composition_settings = {}

    def create_project(self, motion_timeline, output_specs):
        """Create complete Natron project from motion timeline"""

        # Configure Natron project
        project = {
            'format': output_specs.resolution,
            'frame_rate': output_specs.fps,
            'duration': motion_timeline.total_frames
        }

        # Build node graph
        node_graph = self.build_node_graph(motion_timeline)

        # Configure render settings
        render_settings = self.configure_render_settings(output_specs)

        # Generate .ntp file
        natron_project = self.generate_ntp_file(project, node_graph, render_settings)

        return natron_project

    def build_node_graph(self, timeline):
        """Build complete node graph from timeline"""
        nodes = {}

        # Input nodes (images, texts)
        for element in timeline.elements:
            if element.type == 'image':
                nodes[f"read_{element.id}"] = self.create_read_node(element)
            elif element.type == 'text':
                nodes[f"text_{element.id}"] = self.create_text_node(element)

        # Transformation and animation nodes
        for animation in timeline.animations:
            nodes[f"transform_{animation.id}"] = self.create_transform_node(animation)

        # Compositing nodes
        nodes['merge_base'] = self.create_merge_nodes(timeline.layers)

        # Output node
        nodes['write_output'] = self.create_write_node(timeline.output_settings)

        return nodes

    def render_via_cli(self, natron_project_path, output_path):
        """Render project via Natron CLI"""
        cmd = f"NatronRenderer -w {natron_project_path} -o {output_path}"
        return subprocess.run(cmd, shell=True, capture_output=True)

class AdaptiveRenderer:
    def __init__(self):
        self.natron_builder = NatronProjectBuilder()

    def render_for_platform(self, motion_graphic, platform_specs):
        """Render motion graphic adapted for specific platform"""

        # Adapt duration and resolution
        adapted_timeline = self.adapt_for_platform(motion_graphic, platform_specs)

        # Create Natron project
        natron_project = self.natron_builder.create_project(
            adapted_timeline, 
            platform_specs
        )

        # Render via Natron CLI
        output_path = self.natron_builder.render_via_cli(
            natron_project.file_path,
            platform_specs.output_path
        )

        return output_path

# Text node creation
text_node = app.createNode("net.fxarena.openfx.Text")
text_node.getParam("text").setValue("Hello World")
text_node.getParam("fontSize").setValue(48)
text_node.getParam("color").setValue([1.0, 1.0, 1.0, 1.0])

# Transform node with animation
transform_node = app.createNode("fr.inria.built-in.Transform")
transform_node.getParam("translate").setValue([960, 540, 0])
transform_node.getParam("motionBlur").setValue(1.5)

# Merge node for compositing
merge_node = app.createNode("fr.inria.built-in.Merge")
merge_node.connectInput(0, background_node)
merge_node.connectInput(1, text_node)

class JSONToNatronConverter:
    def convert_motion_timeline(self, json_timeline):
        """Convert JSON motion timeline to Natron project"""

        # Parse JSON structure
        timeline = self.parse_json_timeline(json_timeline)

        # Create Natron project
        project = self.create_natron_project(timeline)

        # Build node graph
        node_graph = self.build_node_graph(timeline)

        # Configure animations
        self.configure_animations(node_graph, timeline.animations)

        # Generate .ntp file
        ntp_file = self.generate_ntp_file(project, node_graph)

        return ntp_file

    def configure_animations(self, node_graph, animations):
        """Configure keyframe animations in Natron"""
        for animation in animations:
            node = node_graph[animation.node_id]
            param = node.getParam(animation.parameter)

            # Set keyframes
            for keyframe in animation.keyframes:
                param.setValueAtTime(keyframe.time, keyframe.value)