Okhsv Qt Colour Picker

Björn Ottosson's OkLab perceptual color space is fascinating and couldn't resist trying out some sort of implementation of it. After playing around with the interactive demo for Okhsv and Okhsl colour pickers, I set out to try and create a Qt colour picker based on Okhsv.

At the time of writing there are no existing Python implementations of Okhsv/OkHsv, so I've uploaded my translation to Github

As custom colour space support is limited in Qt I went with using a QRadialGradient and mapped the standard sRGB values to Okhsv based on the libraries by Björn.

Besides the radial offset compared to the demo, my Qt implementation seems to be working as expected. Looking to the future, I hope this prototype inspires people with more application support for OkLab on the way.

Interactive Nuke Viewport

Majority of the DCC apps let you render through the viewport camera or look through the current camera rendering so you can get that perfect position or just have that prettier viewport to use. Nuke doesn't have that option. There is a one off snap button or a limited interactive camera mode but those lose both the intuitive way Nuke's standard viewport works and all the hotkeys such as F to focus.

By mapping the nuke.activeViewer().getGLCameraMatrix() to same camera used for a ScanlineRender or other renderer node, this will give you this improved interactive viewport.

Rec. 2020 - Where are you?

Reading/Writing non-image based media has never been a Nuke strong point which is understandable for most part. However with things such as HDR containerization based media codecs becoming more commmon and will be only option in some scenarios.

Adding support for Rec. 2020 matrix coefficients and x265/HEVC so this kind of media can be loaded is the feature request I've logged. Not to work off but is useful for example when comparing against exr images to find the best quantization encoding parameters with minimal temporal artifacting. Which everyone would appreciate right, not just me?

Interactivity performance in a script

Nuke provides great tools to benchmark a large script to see what nodes are the computational heavy. However nothing can tell you what nodes are causing interactive slow downs, e.g "why does my script lock up every couple of seconds when I change knob values".

Likely many things are the cause but one of the big contributers usually is any Python/TCL expressions in the script on specific knobs that will evaluate anytime you change knob values, put down new nodes, anything affecting the DAG re-evalution to trigger.

How would you go about profiling that? With a little TCL trickery you can wrap every expression into a time command even Python based expressions (since they all go through TCL) while still allowing it to work as per normal in the script.

Doing the above automatically on every expression based knob on every node within a script, pulling all the data with some more fiddling, gives you a good idea which nodes are contributing the most to your Nuke script stickiness.

The time command would likely add some overhead to your script, so it should be removed after gathering the stats, but that doesn't change the overall timing relationships between nodes. So no more trial and error debugging scripts, just definitive results you can act on.

Accessing the status bar for temporary feedback

Nuke's status bar at the bottom of the app shows you information such as Channel Count, CPU usage, etc. What if you could use it to display temporary or permanent messages based on how you interacted with Nuke.

For the above proof of concept I've hooked up node selection to quickly show you information about which knobs you've changed without having to open the panel or polluting the node's label. This status bar could be used for a range of different things and it turns out this hidden feature is accessed through the Python API: hiero.ui.mainStatusBar.

QML inside Nuke

Nuke includes PySide2 which lets you make QWidgets to your hearts content which is great, however Qt includes a framework called QML. These modules allow you to create a UI using it's markup language and open more possiblities that QWidgets can't provide.

It turns out Nuke includes the modules to setup the framework such as QtQuick, but Foundry do not include the actual QML files/libs that are required to get it all working. Good news is if you have your own version of Qt complied, it will contain the missing qml folder which you can point your Nuke environment at giving you QML inside Nuke! If you'd like more information, here's a post that goes into a bit more detail.

Write node exr specification limitations

Writing out exr's in Nuke is quite good, many of the options are available, however there are a few that the exr specifications support but are not accessible through the UI. One example is different datatypes per layer. Let's say I want to write out an exr with RGB at 16 bit but a depth or motion pass at 32 bit to keep those data passes as accurate as possible.

This is currently not possible with the write node even though it's a fairly common practise while doing something like precomping parts of your tree. One option I've tried is to compile your own exrWriter with the additional options available. This works but now you have the additional overhead of maintaining this custom solution when it should be in vanilla Nuke.

Controlling monitor colour calibration from Nuke

Imagine you're in a DCC application such as Nuke and you switch the Display Output Transform. Wouldn't it be great if your monitor's hardware colourspace/luminance changed to what you just chose. A use case is you want to switch between SDR and HDR display based settings.

Using a tool such as ddcutil you can control your monitor from commandline in Linux. A working example would be hooking into Nuke's Display Output dropdown and on transform change, alter the monitor's settings to match. This frees up an artist having to mess with the monitor's OSD to change brightness/colourspace etc.

Soft Selection for Roto

With the release of Nuke 12, Foundry added soft selection to the 3D viewer. That's great but what about soft selection for 2D, specifically, the Roto node? I put together a quick proof of concept above of soft selection for Roto points.

It's quite early in development but has a lot of potential. If an artist needed to move multiple points at once with with control of a falloff, this would significantly speed up the workflow instead of individually moving each point.

Using Rotopaint to create images

A Nuke artist had an issue where they wanted to pass a simple script/tool around to others but had realised it was reading in a bokeh kernel image file that they rather not have to always bring alongside. Is there a way to remove a file dependency on a Nuke script? Yes, one way is using a RotoPaint node.

I put together this tool to analysis the incoming image and to use colored roto strokes to paint out the image one for one. There is now no need for the image file and can replace it with this RotoPaint node! It's pretty rough at the moment but I have quite a few ideas on how to optimize it and make it viable for all images and resolutions.

Attaching a Qt Widget to a node

Can you map DAG node position to global Qt coordinates? Seems like you can with this quick proof of concept I whipped up. The widget is attached to the node by calculating the offset of the node from the center for the DAG position space but also for the DAG Widget. From that you can map the position to global screen space and move the Widget to the node. The Widget shows on node selection, works with node movement and also with zooming/panning in the DAG.

Panning the viewer without Qt

As far as I know there is no viewer pan manipulation in Nuke without QT or the NDK. You could possibly use crops/reformats to mimic panning but my good friend Mitchell has found a more elegant way.

The Tracker node has a center_viewer button which also happens to be knob that can be invoked. So by creating a tracker point at the position you want to move to in conjunction with the viewer zoom API, you now have full control of panning the viewer, Awesome!

GLSL Node for Nuke

Thanks to Hendrik Proosa for open sourcing his GLSL node, we finally have a way create/view GLSL fragment code in a Nuke node. This opens up the possibilities for using shaders from places such as ShaderToy or from other applications that use GLSL.I hope to work closely with Hendrik in the coming future to push back my own bug fixes/new features.

See source code HERE

Light Mixer in Nuke

Recently I discovered 3Delight for Katana has quite a unique feature named the Light Mixer to interactively adjust light intensities in the render viewer (See an example GIF or Video).

I've made a quick prototype in Nuke which should match the same functionality, however in the example I only had access to different AOVs. If instead you render out separate light groups, this tool could be used to control intensity, color, etc. The logic under the hood, determines which light/channel is contributing the most for the current pixel you start at and alters it based on your up and down motions.

Nuke 11's drag and drop bug

It would seem Nuke 11 introduced a drag and drop bug by no longer allowing drop data with url type text to be dropped into the dag. All previous version's of Nuke allowed any type of data to be dropped in and you could use Nuke's drag and drop callback system to decide what would happen when you dropped that type of data in.

For the time being I've used Qt to hook into the drop event that will run Nuke's internal dragData call to workaround this bug. With this fix you can continue adding your drag and drop callbacks like usual.

  
class dragDropUrlFix(QtCore.QObject):
    def eventFilter(self, obj, event):
            if (event.type() == QtCore.QEvent.Type.Drop
                and event.mimeData().hasFormat("text/uri-list"):
                for url in event.mimeData().urls():
                    nukescripts.dropData(None, url.toString())
        return super(dragDropUrlFix, self).eventFilter(obj, event)
        
eventFilter = dragDropUrlFix()
dagWidget.installEventFilter(eventFilter)
  

Performance Profile Stylesheet

With my help from a close friend, I've got together a stylesheet that can be used to view Nuke's XML Performance profiles. For an interactive demo go: HERE

Fixing tablet dag issues with Qt

A lot of Nuke artists use a tablet like a Wacom to triverse Nuke's Dag. You hold the middle click button on the pen to move around, however you may accidently click instead of holding causing Nuke to recentre and frame on the entire Dag which is something a few people would rather not have.

As far as I know, there is no way to disable this framing using nuke's preferences and on some pens you are unable to remap the button. You can however use Qt to disable the middle mouse click event for the Dag's Qt widget.

  
class middleClickDisable(QtCore.QObject):
    def eventFilter(self, obj, event):
        if (event.type() == QtCore.QEvent.Type.MouseButtonRelease
            and event.button() == QtCore.Qt.MidButton):
            return True
        return super(middleClickDisable, self).eventFilter(obj, event)

eventFilter = middleClickDisable()
dagWidget.installEventFilter(eventFilter)
  

Camera Fustrum Detection

Someone had asked if you could detect if an object is in the camera's frustum. I had an idea of being able to tell by calculating the camera's field of view, using that and far/near clipping plane to get all points to then see if the object position is in sight or not. It's a pretty rough prototype but could be useful for other things such as culling.

Update on Profile Gui

The profiling gui is coming along, still a lot to go but it's coming together nicely, the next on this list is to make it live update.

Interactive Contact Sheet

I've been playing around with the idea of a interactive layer contact sheet that lets you select the layers/sheets you want in the viewer and perform an action on what you've selected. With the prototype above, I've got the script be able to tell where the layers are. Still needs work but seems promising.

The power of Qt in Nuke

There is a lot that can be done through Qt, I've started using it in a few Nuke Tools. For example, you can set up a simple eventFilter that listens for a QtCore.QEvents which can be a key press, a mouse click, etc. This gives way more flexibility than some of the callbacks such as KnobChanged

Deep nodes and their Metadata

For those of you who were wondering, you can't put a ModifyMetaData node in a deep stream. This is a bit frustrating and there doesn't seem to be a way to get around this even if you flatten the deep image then use a DeepRecolor to bring it back.

UPDATE: As of Nuke 11.2 deep nodes now work with Metadata nodes, hooray!

Performance Profiling GUI

I've got a rough GUI going for an interactive profiling gui. This lets you vizually see which nodes are taking the most resources and jump between them in realtime. I'll post up an image once it's in a hard decent state.

Worked on

Current Location

Sydney, Australia

Experience

July 2021 – Present

Animal Logic | Lead Imaging TD

February 2020 – July 2021

Animal Logic | Imaging TD

November 2016 – February 2020

Animal Logic | Compositing TD

April 2015 – November 2016

Animal Logic | Render Wrangler

August 2014 - November 2016

Freelance Compositor

Skills

Nuke

Python

Colour/ACES/OCIO

USD

VFX Pipeline

PyQt/PySide (UI/UX)

C++ (Basic)

Elasticsearch

Education

February 2013 – December 2014

Academy of Interactive Entertainment | Advanced Diploma of Screen and Media - Specialising in 3D & VFX

April 2014 – June 2014

CGSociety Workshops | Deep Compositing

November 2014

AFTRS | Nuke Short Course