nolanlabs

Scripting

Sa page na ito
  1. I-set up
  2. Unang script
  3. Tumawag ng anumang op
  4. Ayon sa gusto mong gawin
  5. Gumawa ng media mula sa code
  6. Magtrabaho mula sa shell
  7. Abutin ang anumang bukas na project
  8. Magpalit ng mode at mag-update
  9. Ang laman ng bawat object
  10. Ang mga script ng agent

Gumamit ng script kapag mas madali ang trabaho bilang program: pag-cut sa bawat beat, paglalagay ng effect sa bawat hit, pagsukat bago ka mag-cut. Naaabot ng nolan Python client at ng nolan-cli ang parehong mga op gaya ng mga button at ng agent, kaya chine-check ang bawat pagbabago, at isang hakbang sa history ang pagbabagong ginawa ng script.

I-set up

Python 3.10 o mas bago lang ang kailangan ng client. Opsyonal ang OpenTimelineIO, para sa to_otio(). Dala ng app ang client sa resources nito, sa folder na python-client. Sa Mac, kapag nasa Applications ang app:

pip install /Applications/nolanlabs.app/Contents/Resources/python-client

Idagdag ang [otio] sa dulo ng path para sa OpenTimelineIO, o ilagay ang folder sa PYTHONPATH sa halip.

Kusang hinahanap ng client ang tumatakbong app. Nananaig ang NOLAN_URL kung i-set mo ito. Dala ng bawat request ang secret ng serbisyo: katabi ng tumatakbong app, sila mismo ang bumabasa nito, ang client at ang CLI, kaya walang kailangang i-set. Pinapangalanan ito ng NOLAN_TOKEN para sa serbisyo sa ibang lugar.

Unang script

import nolan

s = nolan.connect()                         # NOLAN_URL, or http://127.0.0.1:8790
tl = s.timeline()                           # NOLAN_TIMELINE, or the first timeline
music = s.sources("Music")[0]["id"]
beats = s.sound(music, fps=tl.fps)["beats"]

with tl.transaction("Cut to the beat"):     # one step in the history; dropped if the block raises
    for clip, beat in zip(tl.track("V1").items, beats[4::4]):
        if clip.end > beat:
            clip.trim("tail", beat - clip.end, ripple=True)
    tl.track("V1").items[0].effect("grain", 0.3)

print(tl.summary()["mean_shot_s"])

Sa labas ng transaction, napupunta sa timeline ang bawat batch bilang sarili nitong hakbang. Sa loob ng with tl.transaction(label), napupunta ang mga batch sa isang transaction na ipinapakita ng page gaya ng proposal ng agent, at pinapanatili ito ng dulo ng block bilang isang hakbang. Ang batch na tinanggihan ng engine ay nagre-raise ng nolan.NolanError, kasama ang op_index na tumutukoy sa command, at walang binabago.

Tumawag ng anumang op

Function ayon sa domain ang bawat op, ang mga field nito bilang mga argument at may docstring na nagsasabi ng unit at range ng bawat isa. Tinatanggihan ang field na hindi umiiral, kasama ang listahan ng mga field na mayroon. Ang session dito ay ang isinasagot ng nolan.connect().

nolan.ops.clip.trim(clip="c4", edge="tail", delta=-6, tl=tl)
nolan.ops.text.add(at=24, len=48, text="NEXT LEVEL", look="impact", y=0.2, in_="slam", in_len=6, tl=tl)
beats = nolan.analyse.sound("Rocket")["beats"]          # nolan.analyse and nolan.track are nolan.ops.analyse and .track
tl.edit([{"op": "clip.dissolve", "clip": "c5", "frames": 12},
         {"op": "grade.primary", "clip": "c5", "temp": 0.15}], name="Warmer")
tl.do("timeline.marker_add", at=96, name="Drop")
session.op("deliver.render", preset="prores", path="/out/master.mov")

Ang mga field na salita sa Python ay may _ sa dulo bilang mga argument (in_, from_). Sa tl.edit at tl.do, napapanatili nila ang pangalan nila. Nasa nolan.ops.CATALOGUE ang bawat op kasama ang mga field nito, at tinatanong ng nolan.ops.catalogue() ang editor, kasama ang mga plug-in.

Ayon sa gusto mong gawin

# Bring things in, and cut them
s.import_media(["/footage/a.mov", "/footage/b.mov"])
tl.insert("a", 0, length=48, overwrite=True)

# Grade with wheels and curves, and a LUT
clip.grade(lift=[0, 0, .02], gain=[.05, 0, -.03], curves={"m": [[0, 0], [.5, .55], [1, 1]]})
clip.grade(lut="film.cube", lut_mix=.6)  # in the project's LUTs folder, or a full path

# Read the frame from the originals, and check the numbers
print(tl.scopes(at=48)["luma"])

# Mask, track and move the mask with what it follows
clip.set(masks=[{"shape": "ellipse", "x": .5, "y": .4, "w": .3, "h": .5, "feather": .05, "invert": True}])
path = s.track(clip.src, clip.source_in, clip.source_in + clip.length, x=.5, y=.4, w=.3, h=.5, mode="move")
clip.track_apply(path, target="mask:0")

# Words on an arc, letter by letter
tl.title("STUNT SHOW", 0, 72, path=[[.2, .6], [.5, .4], [.8, .6]], by="char",
         per=[{"prop": "opacity", "stagger": 2, "keys": [{"f": 0, "v": 0}, {"f": 8, "v": 1}]}])

# Sound
clip.set(afx=[{"kind": "highpass", "freq": 80}, {"kind": "reverb", "size": .4, "mix": .15}], pan=-.2)

# Cameras
angles = s.sync(["cam_a", "cam_b"])
tl.multicam(angles, at=0, length=240)

# Deliver anything
tl.render("/out/master.mov", preset="prores", profile="hq", audio="pcm24", loudness=-16)
tl.render("/out/frames", sequence="exr", alpha=True)
tl.render("/out/hdr.mov", codec="prores", profile="hq", hdr="pq")   # cache=True does nothing for HDR or EXR
tl.export("fcpxml", "/out/cut.fcpxml")

Nagpapadala ang bawat method ng isang batch at binabasa pabalik ang timeline, kaya ipinapakita ng mga object ang timeline kung ano ito pagkatapos ng pagbabago. Napapanatili ng clip na hinati sa dalawa ang id nito sa kaliwang piraso.

Gumawa ng media mula sa code

Kayang gawin ng isang program ang inilalagay nito sa timeline. Isinusulat ng bawat isa rito ang file sa Media/Generated ng project, ini-import ito at inilalatag sa ibabaw ng nandoon, walang inililipat, bilang isang hakbang sa history. Inaalis ng undo ang clip, at nananatili sa pool ang source.

import numpy as np
from PIL import Image, ImageDraw

# A picture: an array or a Pillow image, for 5 seconds at the end of the track unless you say
picture = Image.new("RGBA", (tl.width, tl.height), (0, 0, 0, 0))
ImageDraw.Draw(picture).ellipse((200, 100, 600, 500), fill=(255, 80, 0, 255))
tl.add_image(picture, at=0, length=48, track="V2", name="Disc")

# Moving pictures: a generator is sent as it makes them, so length costs no memory
def noise():
    rng = np.random.default_rng(7)
    for i in range(96):
        yield rng.random((tl.height, tl.width, 3)) * (i / 96)
tl.add_frames(noise(), fps=tl.fps, at=48, name="Noise")

# Sound: float from -1 to 1, or int16; one channel or (samples, channels)
t = np.arange(96000) / 48000
tl.add_audio(np.sin(2 * np.pi * 110 * t) * 0.3, rate=48000, at=0, track="A2", name="Hum")
Call Tinatanggap Nagiging
tl.add_image(image, at, length, track, name) Array na (H, W), (H, W, 1), (H, W, 3) o (H, W, 4), sa uint8, uint16 o float 0 hanggang 1, o Pillow image PNG, 16-bit mula sa uint16 o float
tl.add_frames(frames, fps, at, length, track, name) Generator o listahan ng mga iyon, o array na (T, H, W[, C]) ProRes 422 HQ, o 4444 kapag may alpha
tl.add_audio(samples, rate, at, length, track, name) Array na (N,) o (N, channels), float o int16, o generator ng mga chunk 24-bit WAV

Sa program mo ang mga array at image, kaya ikaw ang mag-i-install ng NumPy at Pillow para sa mga ito.

Magtrabaho mula sa shell

nolan-cli [--url URL] [--project NAME|FOLDER|ID] [--timeline ID] COMMAND

projects | open PATH [--force] | close [NAME] [--stop]    the projects open at once
runs [--state S] | ask PROMPT [--thread T] [--wait]       the agent of --project (or the one the app shows)
answer RUN OPTION [--note N] | cancel RUN
host status | host restart|stop [--when idle|now] | host cancel

run [--label L] [--dry-run] script.py [-- args]    a script, in one transaction
summary | ops [WORDS] | lookup WORDS               read; ops lists every op with its fields
op NAME [FIELD=JSON ...] [--dry-run]               any op: op clip.trim clip=c4 edge=tail delta=-6
inspect WHAT [FIELD=JSON ...]                      the agent's inspect tool: inspect clips track=V1
look WHAT [FIELD=JSON ...] [--out DIR]             the agent's look tool; pictures saved to DIR, their paths printed
wait ID [--timeout S] | busy | background          wait for a script in the background (r1) or a render (j1); what still runs
apply '[{"op": "split", "at": 48}]' [--dry-run]    any engine commands
clip ID [FIELD=JSON ...]                           read or change a clip
render [--out F] [--preset P] [--from A] [--to B] [FIELD=JSON ...]    waits for it
export otio|fcpxml|edl|aaf [OUT] [--track V2]      import FILE
scopes [--at F] | cache [--from A --to B --wait]   sheet OUT.jpg [--count N]
fonts | font FILE | relink [--folder D | --src ID --path F]
add image|frames|audio [--name N] [--at F] [--length L] [--track V2]
    [--width W --height H --pix rgb24 --fps F | --rate R --channels C --format f32le] < RAW

Pinapatakbo ng run ang script mo na handa na ang nolan, session at tl, sa loob ng isang transaction: pinapanatili bilang isang hakbang kapag maayos itong natapos, itinatapon kapag nag-raise ito. Sinasabi ng --dry-run ang ginawa nito at itinatapon ito. Sa iyo ang mga script na pinapatakbo mo sa ganitong paraan at tumatakbo sila nang walang safe mode. Ang python -m nolan ay ang parehong command.

Mula sa anumang wika, nagbabasa ang nolan-cli add ng raw data mula sa pipe:

my_renderer | nolan-cli add frames --width 1920 --height 1080 --pix rgb24 --fps 24 --track V2 --name Sim
my_synth | nolan-cli add audio --rate 48000 --channels 2 --format f32le --at 96

Abutin ang anumang bukas na project

Gumagana ang nolan-cli --project NAME sa project na iyon nang hindi pinapalitan ang window ng app. Ganoon din ang nolan.project(name), sa Python:

import nolan
teaser = nolan.project("Launch Teaser")
teaser.timeline().marker(48, "From the script")         # edits that project, whatever the app's window shows
run = teaser.agent.ask("Tighten the second half")      # a Run: id, thread, status (running, paused, done, failed, cancelled), and what it waits on you for
run.wait()                                             # waits through a restart: a paused run carries on by itself
for r in nolan.runs(state="waiting"):                  # every open project's runs that wait for an answer
    print(r.project, r.title)
teaser.close(stop=False)                               # refused while its work goes, unless stop=True
nolan.host.status(); nolan.host.restart(when="idle")

Magpalit ng mode at mag-update

Ang s.mode ay ang mode ng app, "lite" o "pro", at pinapalitan ito ng s.set_mode("pro"). Ipini-print ito ng nolan-cli mode, at nagpapalit ang nolan-cli mode lite.

nolan-cli update          # or: update check, update install

Ang laman ng bawat object

Object Ang laman nito
Session project, timelines, timeline(id), new_timeline, new_project, open, import_media, add_media, sources(q), sound, sfx, sync(srcs, by), motion, track, shake, subject, key_colour, relink, fonts(), import_font(path), import_timeline(path), set_proxy(size), set_agent(access, ask_me), style(), set_style(user, project), plugins(), save_generator(name, code, params), op(name, **fields), run_script(code)
Timeline Pagbasa: fps, width, height, length, markers, tracks, track(id), clips, clip(id), at(frame, track), summary(), checks(), frame(at, path), still(at, path), contact_sheet(path), scopes(at, pictures, hdr), cache(frm, to, wait), mix(), watch(). Pagbabago: edit(ops, name), do(name, **fields), apply(commands), op(command, **fields), dry_run(commands), transaction(label), undo(), insert, lay, add_image, add_frames, add_audio, split, title, marker, add_track, compound(frm, to), decompose(clip), multicam(angles, at). Palabas: render(path, preset, frm, to, **deliver), export(kind, path, track), otio_json(), to_otio()
Track id, kind, name, items, set(**fields)
Clip id, track, src, at, end, length, source_in, title, anim, fx, speed; trim, roll, slip, slide, move, split, delete, set, keyframe, effect, motion, transition, grade, track_matte, track_apply, stabilize

Ang mga script ng agent

Nasa agent din ang client na ito. Gumagana sa isang draft, kopya ng proposal nito, ang script na pinapatakbo nito. Kapag maayos na natapos ang script, napupunta ang lahat sa proposal bilang isang batch. Kapag pumalya ito, walang pinapanatili, at nawawala rin ang media na ginawa nito.

Tumatakbo sa safe mode ang mga script ng agent: limitadong import, pagsulat lang sa loob ng sarili nilang pansamantalang folder, walang bagong process, at may limit sa oras, CPU at memory. Sa Windows, walang read-only view ng disk at walang memory limit. Panangga sa pagkakamali ang safe mode, hindi security boundary. Tingnan ang Mga kilalang limitasyon. May Panatilihin at Itapon ang proposal mula sa sarili mong script. Tingnan ang Mga proposal.

Docs

↑↓ Lumipat↵ Buksan