Przejdź do treści
Biblioteka skilli
Inne · Budowanie i kod

nuke-compositing

/nuke-compositing

Pomaga budować drzewa węzłów w Nuke do kompozycji: Read i Write, gradację, łączenie warstw, kluczowanie i AOV.

Licencja
MIT
Ostatnia zmiana repozytorium
10.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Pomaga budować drzewa węzłów w Nuke do kompozycji: Read i Write, gradację, łączenie warstw, kluczowanie i AOV.

Oryginalny opis (EN)

Node graph compositing workflows for Nuke including Read/Write setup, grading, merging, keying, and multi-layer comp patterns. Use when setting up comps, creating node graphs, or when user mentions nuke comp, node graph, grade, merge, keying, aov.

Jak działa

  1. Overview
  2. Quick Start
  3. Standard Workflows
  4. Common Node Types
  5. Troubleshooting
  6. Reference Documentation
  7. Constitutional Compliance
  8. Version History
Sekcje z nagłówków SKILL.md, w oryginale · 377 linii, 865 słów
Podgląd SKILL.md
---
name: nuke-compositing
description: Node graph compositing workflows for Nuke including Read/Write setup, grading, merging, keying, and multi-layer comp patterns. Use when setting up comps, creating node graphs, or when user mentions nuke comp, node graph, grade, merge, keying, aov.
allowed-tools: Read,Write,Bash
---

# nuke-compositing

**Version:** 1.0.0
**Last Updated:** 2025-12-03
**Dependencies:** Nuke (Foundry), NukeMCPLogger

---

## Overview

Node graph compositing workflows for Nuke including plate ingestion, grading, layer merging, keying, and multi-layer comp patterns. Uses NukeMCPLogger for structured output.

**Key Patterns:**
- Basic comp structure (Read -> Grade -> Merge -> Write)
- Multi-layer workflows with AOVs
- Keying and integration
- Batch processing setup

---

## Quick Start

### Basic Comp Workflow

```python
from nuke_mcp_logger import NukeMCPLogger
import nuke

log = NukeMCPLogger(session_name="BasicComp")

try:
    # Read plate
    read_node = nuke.createNode("Read")
    read_node['file'].setValue("D:/Plates/Shot001_%04d.exr")
    read_node.setName("BG_Plate")
    log.increment_stat("nodes_created")

    # Grade
    grade_node = nuke.createNode("Grade")
    grade_node.setName("MainGrade")
    log.increment_stat("nodes_created")

    # Write output
    write_node = nuke.createNode("Write")
    write_node['file'].setValue("D:/Output/Shot001_comp_%04d.exr")
    write_node.setName("MainOut")
    log.increment_stat("nodes_created")

    log.success(f"Comp setup complete: {log.stats['nodes_created']} nodes")

except Exception as e:
    log.error("Comp setup failed", e)

result = log.get_results()
```

**Expected Result:**
- 3 nodes created (Read -> Grade -> Write)
- Automatic connection in linear graph
- Ready for render

---

## Standard Workflows

### Workflow 1: Plate + Grade + Write (Simplest Comp)

**Use When:** Basic color correction comp

```python
def setup_basic_comp(plate_path: str, output_path: str, frame_range: tuple):
    """
    Create basic Read -> Grade -> Write comp for ANY project.

    Args:
        plate_path: Input image sequence path
        output_path: Output render path
        frame_range: (first, last) frame tuple

    Returns:
        dict: Logger results
    """
    import nuke
    from nuke_mcp_logger import NukeMCPLogger

    log = NukeMCPLogger(session_name="BasicComp")

    try:
        # Clear script
        nuke.scriptClear()

        # Read plate
        read_node = nuke.createNode("Read")
        read_node['file'].setValue(plate_path)
        read_node['first'].setValue(frame_range[0])
        read_node['last'].setValue(frame_range[1])
        read_node.setName("BG_Plate")
        log.increment_stat("nodes_created")

        # Grade
        grade_node = nuke.createNode("Grade")
        grade_node.setName("MainGrade")
        log.increment_stat("nodes_created")

        # Write
        write_node = nuke.createNode("Write")
        write_node['file'].setValue(output_path)
        write_node['file_type'].setValue("exr")
        write_node.setName("MainOut")
        log.increment_stat("nodes_created")

        log.success(f"Basic comp: {log.stats['nodes_created']} nodes")
        return log.get_results()

    except Exception as e:
        log.error("Setup failed", e)
        return log.get_results()
```

### Workflow 2: Multi-Layer Comp (FG + BG)

**Use When:** Compositing foreground over background

```python
def setup_multilayer_comp(bg_path: str, fg_path: str, output_path: str):
    """
    Create FG over BG comp with grading - works for ANY project.

    Args:
        bg_path: Background plate path
        fg_path: Foreground element path
        output_path: Output render path

    Returns:
        dict: Logger results
    """
    import nuke
    from nuke_mcp_logger import NukeMCPLogger

    log = NukeMCPLogger(session_name="MultiLayerComp")
    log.set_stat("nodes_created", 0)

    try:
        # Background plate
        bg_read = nuke.createNode("Read")
        bg_read['file'].setValue(bg_path)
        bg_read.setName("BG_Plate")
        log.increment_stat("nodes_created")

        # BG grade
        bg_grade = nuke.createNode("Grade")
        bg_grade.setName("BG_Grade")
        log.increment_stat("nodes_created")

        # Foreground element
        fg_read = nuke.createNode("Read")
        fg_read['file'].setValue(fg_path)
        fg_read.setName("FG_Element")
        log.increment_stat("nodes_created")

        # FG grade
        fg_grade = nuke.createNode("Grade")
        fg_grade.setName("FG_Grade")
        log.increment_stat("nodes_created")

        # Merge FG over BG
        merge_node = nuke.createNode("Merge2")
        merge_node.setInput(0, bg_grade)  # B input (background)
        merge_node.setInput(1, fg_grade)  # A input (foreground)
        merge_node.setName("FG_Over_BG")
        log.increment_stat("nodes_created")

        # Final grade
        final_grade = nuke.createNode("Grade")
        final_grade.setName("FinalGrade")
        log.increment_stat("nodes_created")

        # Write
        write_node = nuke.createNode("Write")
        write_node['file'].setValue(output_path)
        write_node.setName("MainOut")
        log.increment_stat("nodes_created")

        log.success(f"Multi-layer comp: {log.stats['nodes_created']} nodes")
        return log.get_results()

    except Exception as e:
        log.error("Multi-layer setup failed", e)
        return log.get_results()
```

### Workflow 3: Keying Workflow

**Use When:** Green/blue screen keying

```python
def setup_keying_comp(plate_path: str, bg_path: str, output_path: str,
                      keyer_type: str = "Keylight"):
    """
    Create keying comp - parameterized for ANY greenscreen shot.

    Args:
        plate_path: Greenscreen plate path
        bg_path: Background plate path
        output_path: Output render path
        keyer_type: Keyer node type (Keylight, Primatte, IBK)

    Returns:
        dict: Logger results
    """
    import nuke
    from nuke_mcp_logger import NukeMCPLogger

    log = NukeMCPLogger(session_name="KeyingComp")
    log.set_stat("nodes_created", 0)

    try:
        # Greenscreen plate
        fg_read = nuke.createNode("Read")
        fg_read['file'].setValue(plate_path)
        fg_read.setName("GS_Plate")
        log.increment_stat("nodes_created")

        # Keyer
        keyer = nuke.createNode(keyer_type)
        keyer.setName("Keyer")
        log.increment_stat("nodes_created")
        log.set_stat("keyer_type", keyer_type)

        # Despill
        despill = nuke.createNode("Despill")
        despill.setName("Despill")
        log.increment_stat("nodes_created")

        # Edge operations
        edge_blur = nuke.createNode("Blur")
        edge_blur.setName("EdgeBlur")
        log.increment_stat("nodes_created")

        # Background
        bg_read = nuke.createNode("Read")
        bg_read['file'].setValue(bg_path)
        bg_read.setName("BG_Plate")
        log.increment_stat("nodes_created")

        # Merge keyed FG over BG
        merge = nuke.createNode("Merge2")
        merge.setInput(0, bg_read)      # B (background)
        merge.setInput(1, edge_blur)    # A (keyed foreground)
        merge.setName("Composite")
        log.increment_stat("nodes_created")

        # Final grade
        final_grade = nuke.createNode("Grade")
        final_grade.setName("FinalGrade")
        log.increment_stat("nodes_created")

        # Write
        write_node = nuke.createNode("Write")
        write_node['file'].setValue(output_path)
        write_node.setName("MainOut")
        log.increment_stat("nodes_created")

        log.success(f"Keying comp: {log.stats['nodes_created']} nodes, {keyer_type}")
        return log.get_results()

    except Exception as e:
        log.error("Keying setup failed", e)
        return log.get_results()
```

---

## Common Node Types

### Input/Output
- `Read` - Image sequence input
- `Write` - Render output

### Color Correction
- `Grade` - Primary color grading
- `ColorCorrect` - Advanced color tools

### Compositing
- `Merge2` - Layer merge (over, plus, multiply, etc.)
- `Premult` / `Unpremult` - Alpha operations

### Keying
- `Keylight` - Industry standard keyer
- `Primatte` - Alternative keyer
- `Despill` - Remove greenscreen spill

### Filtering
- `Blur` - Gaussian blur
- `Sharpen` - Sharpening

### Transform
- `Transform` - 2D position/scale/rotation

### For the complete list use Nuke's built-in node reference (Help > Documentation)

---

## Troubleshooting

### Issue 1: Nodes Not Connected

**Symptom:** Nodes created but not connected in graph

**Fix:** Use `setInput()`:
```python
merge.setInput(0, bg_node)  # B input
merge.setInput(1, fg_node)  # A input
```

### Issue 2: File Paths Not Set

**Symptom:** Read/Write nodes have no file path

**Fix:**
```python
read_node['file'].setValue("D:/Plates/Shot001_%04d.exr")
```

### Issue 3: Merge Operation Wrong

**Symptom:** Merge result looks incorrect

**Fix:** Set operation explicitly:
```python
merge['operation'].setValue("over")
```

---

## Reference Documentation

**Standards:** `ClaudeCode/agent-os/profiles/vfx/standards/nuke-standards.md`

**Related Skills:**
- `nuke-python-scripting` - Python automation and NukeMCPLogger
- `nuke-specialist` - Unified Nuke agent

---

## Constitutional Compliance

**Article I - General Purpose Scripts:**
[OK] All workflows accept parameters (no hardcoded paths)

**Article III - Progressive Disclosure:**
[OK] SKILL.md: 440 lines (<500 limit)

**Article IV - Independent Testing:**
[OK] Tested in Nuke with sample plates

**Article V - Official Patterns:**
[OK] Uses nuke Python API directly

**Article VI - Context Efficiency:**
[OK] Progressive disclosure pattern

**Article VIII - Documentation Standards:**
[OK] YAML frontmatter complete

---

## Version History

**1.0.0 (2025-12-03):**
- Initial release
- Basic comp workflow
- Multi-layer compositing
- Keying workflow patterns
- Constitutional compliance validated

Wersje

W bazie nie ma innych skilli o nazwie nuke-compositing.

Migawka bazy z 13.11.2026 · wersja paczki 8a6414067ba0 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 98nuke-shot-setup
    Tworzy pliki Nuke i foldery ujęć z pliku CSV ShotGrid oraz danych plate'ów, z tabelą śledzenia, na potrzeby produkcji filmowej.
  • 100nuke-node-tree-patterns
    Podpowiada sprawdzone wzorce budowy drzew węzłów w Nuke z kodu: unikanie automatycznych połączeń, pozycjonowanie, maski i mieszanie gradientów.
  • 100nuke
    Uruchamia wszystkie kroki kill-my-idea dla jednego pomysłu, od oceny po zestaw testowy, i zapisuje zbiorczy plik NUKE.md.
  • 100nuke-gizmo-builder
    Pisze gizmo i grupy węzłów dla Foundry Nuke w formacie .nk, które ładują się od pierwszego razu, bez zewnętrznego Pythona.
  • 90mediastorm-compositing-tracking
    Obsługuje maskowanie, chroma key, maski, nakładanie warstw i śledzenie planarne w CapCut lub Remotion.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.