scene-referred環境でのCDLと.cccファイル運用

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import re
import sys
import xml.etree.ElementTree as ET
from pathlib import Path

ASC_CDL_NS = "urn:ASC:CDL:v1.2"
ET.register_namespace("", ASC_CDL_NS)


def qname(tag):
    return f"{{{ASC_CDL_NS}}}{tag}"


def indent(elem, level=0):
    i = "\n" + level * "  "
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "  "
        for child in elem:
            indent(child, level + 1)
        if not child.tail or not child.tail.strip():
            child.tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i


def make_cccid(base_name, used_ids):
    stem = Path(base_name).stem
    cccid = re.sub(r"[^A-Za-z0-9_-]+", "_", stem)
    if not cccid:
        cccid = "SHOT"

    original = cccid
    index = 1
    while cccid in used_ids:
        cccid = f"{original}_{index:03d}"
        index += 1

    used_ids.add(cccid)
    return cccid


def parse_triplet_text(text):
    parts = text.replace(",", " ").split()
    if len(parts) != 3:
        raise ValueError(f"Expected 3 values, got: {text}")
    return tuple(float(x) for x in parts)


def parse_edl_cdl_events(edl_path):
    """
    Resolve EDL から ASC_SOP / ASC_SAT をイベント順で拾う
    """
    events = []
    current = None

    sop_re = re.compile(
        r"\*+\s*ASC_SOP\s*\(\s*([^)]+?)\s*\)\s*\(\s*([^)]+?)\s*\)\s*\(\s*([^)]+?)\s*\)",
        re.IGNORECASE
    )
    sat_re = re.compile(
        r"\*+\s*ASC_SAT\s+([^\s]+)",
        re.IGNORECASE
    )
    event_re = re.compile(r"^\s*\d+\s+\S+\s+[VA]\s+[CDWKMFB]")

    with open(edl_path, "r", encoding="utf-8", errors="ignore") as f:
        for raw_line in f:
            line = raw_line.rstrip("\n")

            if event_re.match(line):
                if current and "slope" in current and "saturation" in current:
                    events.append(current)
                current = {}
                continue

            if current is None:
                continue

            m = sop_re.search(line)
            if m:
                current["slope"] = parse_triplet_text(m.group(1))
                current["offset"] = parse_triplet_text(m.group(2))
                current["power"] = parse_triplet_text(m.group(3))
                continue

            m = sat_re.search(line)
            if m:
                current["saturation"] = float(m.group(1))
                continue

    if current and "slope" in current and "saturation" in current:
        events.append(current)

    return events


def text_or_none(elem, path):
    child = elem.find(path)
    if child is not None and child.text is not None:
        return child.text.strip()
    return None


def parse_xml_file_names(xml_path):
    """
    XML から clipitem 順の file name を拾う
    同じ file id の再利用があっても clipitem 順で並べる
    """
    tree = ET.parse(xml_path)
    root = tree.getroot()

    names = []

    for clipitem in root.findall(".//clipitem"):
        file_elem = clipitem.find("./file")
        if file_elem is None:
            continue

        file_name = text_or_none(file_elem, "./name")
        if file_name:
            names.append(file_name)

    return names


def add_cc(root, cccid, description, slope, offset, power, saturation):
    cc = ET.SubElement(root, qname("ColorCorrection"), {"id": cccid})

    desc = ET.SubElement(cc, qname("Description"))
    desc.text = description

    sop = ET.SubElement(cc, qname("SOPNode"))

    slope_node = ET.SubElement(sop, qname("Slope"))
    slope_node.text = f"{slope[0]:.10g} {slope[1]:.10g} {slope[2]:.10g}"

    offset_node = ET.SubElement(sop, qname("Offset"))
    offset_node.text = f"{offset[0]:.10g} {offset[1]:.10g} {offset[2]:.10g}"

    power_node = ET.SubElement(sop, qname("Power"))
    power_node.text = f"{power[0]:.10g} {power[1]:.10g} {power[2]:.10g}"

    sat = ET.SubElement(cc, qname("SATNode"))
    sat_node = ET.SubElement(sat, qname("Saturation"))
    sat_node.text = f"{saturation:.10g}"


def build_ccc_from_edl_and_xml(edl_path, xml_path, output_path):
    edl_events = parse_edl_cdl_events(edl_path)
    xml_names = parse_xml_file_names(xml_path)

    count = min(len(edl_events), len(xml_names))

    print(f"EDL CDL events : {len(edl_events)}")
    print(f"XML file names : {len(xml_names)}")
    print(f"Matched shots  : {count}")

    root = ET.Element(qname("ColorCorrectionCollection"))
    used_ids = set()

    for i in range(count):
        ev = edl_events[i]
        file_name = xml_names[i]
        cccid = make_cccid(file_name, used_ids)

        add_cc(
            root=root,
            cccid=cccid,
            description=file_name,
            slope=ev["slope"],
            offset=ev["offset"],
            power=ev["power"],
            saturation=ev["saturation"],
        )

    indent(root)
    ET.ElementTree(root).write(output_path, encoding="utf-8", xml_declaration=True)

    print("Done")
    print(f"EDL : {edl_path}")
    print(f"XML : {xml_path}")
    print(f"CCC : {output_path}")


def main():
    if len(sys.argv) != 4:
        print("Usage:")
        print("  ./edl_xml_to_ccc.py input.edl input.xml output.ccc")
        sys.exit(1)

    edl_path = sys.argv[1]
    xml_path = sys.argv[2]
    output_path = sys.argv[3]

    build_ccc_from_edl_and_xml(edl_path, xml_path, output_path)


if __name__ == "__main__":
    main()

<?xml version='1.0' encoding='utf-8'?>
<ColorCorrectionCollection xmlns="urn:ASC:CDL:v1.2">
  <ColorCorrection id="A001C002_0904242F_141603-141626_">
    <Description>A001C002_0904242F[141603-141626].exr</Description>
    <SOPNode>
      <Slope>1.628218 1.628218 1.628218</Slope>
      <Offset>-0.161355 -0.161355 -0.161355</Offset>
      <Power>1 1 1</Power>
    </SOPNode><SATNode>
      <Saturation>1.38</Saturation>
    </SATNode>
  </ColorCorrection><ColorCorrection id="B004C0023_106298-106321_">
    <Description>B004C0023.[106298-106321].exr</Description>
    <SOPNode>
      <Slope>1.401167 1.401167 1.401167</Slope>
      <Offset>-0.12273 -0.12273 -0.12273</Offset>
      <Power>1.102 1.102 1.102</Power>
    </SOPNode><SATNode>
      <Saturation>1</Saturation>
    </SATNode>
  </ColorCorrection><ColorCorrection id="A003C013_220415_R07B_261342-261365_">
    <Description>A003C013_220415_R07B[261342-261365].exr</Description>
    <SOPNode>
      <Slope>1.354002 1.354002 1.354002</Slope>
      <Offset>0 0 0</Offset>
      <Power>1.384 1.384 1.384</Power>
    </SOPNode><SATNode>
      <Saturation>1.4</Saturation>
    </SATNode>
  </ColorCorrection>
</ColorCorrectionCollection>

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys
import random
import re
import xml.etree.ElementTree as ET
from pathlib import Path

ASC_CDL_NS = "urn:ASC:CDL:v1.2"
ET.register_namespace("", ASC_CDL_NS)


def qname(tag):
    return f"{{{ASC_CDL_NS}}}{tag}"


def indent(elem, level=0):
    i = "\n" + level * "  "
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "  "
        for child in elem:
            indent(child, level + 1)
            if not child.tail or not child.tail.strip():
                child.tail = i + "  "
        if not elem[-1].tail or not elem[-1].tail.strip():
            elem[-1].tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i


def make_dummy_values(index):
    base = index * 0.01

    slope = (
        round(1.0 + base, 6),
        round(1.0 - base * 0.5, 6),
        round(1.0 + base * 0.3, 6)
    )

    offset = (
        round(base * 0.1, 6),
        round(-base * 0.05, 6),
        round(0.0, 6)
    )

    power = (
        1.0,
        round(1.0 + base * 0.2, 6),
        1.0
    )

    saturation = round(1.0 + base * 0.4, 6)

    return slope, offset, power, saturation


def make_cccid_from_description(description):
    stem = Path(description).stem
    cccid = re.sub(r"[^A-Za-z0-9_-]+", "_", stem)
    cccid = cccid.strip("_")
    if not cccid:
        cccid = "SHOT"
    return cccid


def make_unique_dummy_description(existing_descriptions):
    """
    既存Descriptionと絶対に重複しない名前を作る
    """
    while True:
        cam = random.choice(["A", "B", "C"])
        roll = random.randint(1, 999)
        cut = random.randint(1, 9999)
        start = random.randint(100000, 999999)
        end = start + random.randint(20, 40)

        description = f"{cam}{roll:03d}C{cut:04d}[{start}-{end}].exr"

        if description not in existing_descriptions:
            existing_descriptions.add(description)
            return description


def make_unique_cccid(description, existing_ids):
    """
    Descriptionベースでidを作り、既存idと重複しないようにする
    """
    base_id = make_cccid_from_description(description)
    cccid = base_id
    suffix = 1

    while cccid in existing_ids:
        cccid = f"{base_id}_{suffix:03d}"
        suffix += 1

    existing_ids.add(cccid)
    return cccid


def add_color_correction(root, cccid, description, slope, offset, power, saturation):
    cc = ET.SubElement(root, qname("ColorCorrection"), {"id": cccid})

    desc = ET.SubElement(cc, qname("Description"))
    desc.text = description

    sop = ET.SubElement(cc, qname("SOPNode"))

    slope_node = ET.SubElement(sop, qname("Slope"))
    slope_node.text = f"{slope[0]} {slope[1]} {slope[2]}"

    offset_node = ET.SubElement(sop, qname("Offset"))
    offset_node.text = f"{offset[0]} {offset[1]} {offset[2]}"

    power_node = ET.SubElement(sop, qname("Power"))
    power_node.text = f"{power[0]} {power[1]} {power[2]}"

    sat_parent = ET.SubElement(cc, qname("SATNode"))
    sat_node = ET.SubElement(sat_parent, qname("Saturation"))
    sat_node.text = f"{saturation}"


def add_dummy_entries(input_ccc, output_ccc, count):
    tree = ET.parse(input_ccc)
    root = tree.getroot()

    cc_path = f".//{qname('ColorCorrection')}"
    desc_path = f"./{qname('Description')}"

    existing_ids = set()
    existing_descriptions = set()

    for cc in root.findall(cc_path):
        cccid = cc.attrib.get("id")
        if cccid:
            existing_ids.add(cccid)

        desc = cc.find(desc_path)
        if desc is not None and desc.text:
            existing_descriptions.add(desc.text.strip())

    for i in range(1, count + 1):
        description = make_unique_dummy_description(existing_descriptions)
        cccid = make_unique_cccid(description, existing_ids)
        slope, offset, power, saturation = make_dummy_values(i)

        add_color_correction(
            root=root,
            cccid=cccid,
            description=description,
            slope=slope,
            offset=offset,
            power=power,
            saturation=saturation,
        )

    cc_list = root.findall(qname("ColorCorrection"))

    for cc in cc_list:
        root.remove(cc)

    random.shuffle(cc_list)

    for cc in cc_list:
        root.append(cc)

    indent(root)
    tree.write(output_ccc, encoding="utf-8", xml_declaration=True)

    print("Done")
    print(f"Input : {input_ccc}")
    print(f"Output: {output_ccc}")
    print(f"Added : {count} dummy entries")
    print(f"Total : {len(cc_list)} ColorCorrection entries")


def main():
    if len(sys.argv) != 3:
        print("Usage:")
        print("  ./add_dummy_ccc.py input.ccc output.ccc")
        sys.exit(1)

    input_ccc = sys.argv[1]
    output_ccc = sys.argv[2]

    add_dummy_entries(input_ccc, output_ccc, 30)


if __name__ == "__main__":
    main()