businessfinancing.co.uk/the-most-popular-consumer-brand-in-every-country/

www.artstation.com/artwork/5XaNYA

www.tiltbrush.com/

www.awn.com/news/loupe-simplifies-storytelling-technology-artists-artists

www.tangent-labs.com/loupe-aws

https://aws.amazon.com/marketplace/pp/B083XBSLV1

time-travel-rephotography.github.io/

bubble.io/

https://www.freecodecamp.org/news/python-code-examples-simple-python-program-example/

If the text does not load well, please download the pdf locally to your machine.
The pdf plugin may not work well under Linux os.

https://pharmapsychotic.com/tools.html

www.digitalinformationworld.com/2019/02/infographic-how-artificial-intelligence-is-changing-visual-arts.html

interestingengineering.com/7-of-the-most-important-ai-artists-that-are-defining-the-genre

https://us.rosco.com/en/products/family/gobos

code.visualstudio.com/

https://www.freecodecamp.org/news/how-to-set-up-vs-code-for-web-development/

https://twitter.com/Akiya_kageichi

creativeknowledgebroker.com/

www.awn.com/news/post-production-shake-streamland-media-acquire-technicolor-post

TIPS

Loop cut a selected face
1- select face
2- shift-H to hide all but the selection. Loop cut doesn’t work on hidden faces.
3- loop cut
4- Alt+H to unhide everything when you’re done.

www.foundry.com/insights/film-tv/pipeline-deployment-best-practice-katana

www.foundry.com/event/webinars/katana-deployment-essentials

www.andreageremia.it/tutorial_python_tcl.html

https://www.gatimedia.co.uk/list-of-knobs-2

https://learn.foundry.com/nuke/developers/63/ndkdevguide/knobs-and-handles/knobtypes.html

http://www.andreageremia.it/tutorial_python_tcl.html

http://thoughtvfx.blogspot.com/2012/12/nuke-tcl-tips.html

Check final image quality
https://www.compositingpro.com/tech-check-compositing-shot-in-nuke/

Local copy:
http://pixelsham.com/wp-content/uploads/2023/03/compositing_pro_tech_check_nuke_script.nk

Nuke tcl procedures
https://www.gatimedia.co.uk/nuke-tcl-procedures

Knobs
https://learn.foundry.com/nuke/developers/63/ndkdevguide/knobs-and-handles/knobtypes.html

# return to the top
nuke.Root().begin()
nuke.allNodes()
nuke.Root().end()



# check if Nuke is running in UI or batch mode
nuke.env['gui'] # True or False



# prformatted font to use in a text node:
liberation mono




# import node from a path
# Replace '/path/to/your/script.nk' with the actual path to your Nuke script
script_path = '/path/to/your/script.nk'
# Create the node in the script
mynode = nuke.nodePaste(script_path)
# or
mynode = nuke.scriptReadFile(script_path) #asynchronous so the code wont wait for its completion, mynode  is empty
# same as 
mynode = nuke.tcl('source "{}"'.format(script_path))
my node will be empty and it wont select the node either
# or synchronous
mynode = NukeUI.Scriptlets.loadScriptlet(script_path) 




# connect a knob on an internal node to a parent's knob
# add a python expression to the internal node's knob like:
nuke.thisNode().parent()['falseColors'].getValue()
# or the opposite
not nuke.thisNode().parent()['falseColors'].getValue()
# or as tcl expression
1- parent.thatNode.disable




# check session performance
Sebastian Schütt – Monitoring Nuke’s sessions performance

nuke.startPerformanceTimers()
nuke.resetPerformanceTimers()
nuke.stopPerformanceTimers()




# set a project start and end frames
new_frame_start = 1
new_frame_end = 100
project_settings = nuke.Root()
project_settings['first_frame'].setValue(new_frame_start)
project_settings['last_frame'].setValue(new_frame_end)



# disable/enable a node
newReadNode['disable'].setValue(True)


# force refresh a node
myNode['update'].execute()
# or
myNode.forceValidate()


# pop up UI alert warning
nuke.alert('prompt')

 

# return a given node
hdriGenNode = nuke.toNode('HDRI_Light_Export')
clampTo1 = nuke.toNode('HDRI_Light_Export.Clamp To 1')

 

# access nodes within a group
nuke.toNode('GroupNodeName.nestedNodeName')

 

# access a knob on a node
hdriGenNode.knob('checkbox').getValue()

 

# return the node type
topNode.Class()
nuke.selectedNode().Class()
nuke.selectedNode().name()

 

# return nodes within a group
hdriGenNode = nuke.toNode('HDRI_Light_Export')
hdriGenNode.begin()
sel = nuke.selectedNodes()
hdriGenNode.end()

 

# nodes position
node.setXpos( 111 )
node.setYpos( 222 )

xPos = node.xpos()
yPos = node.ypos()
print 'new x position is', xPos
print 'new y position is', yPos


# execute a node's button through python
node['button'].execute()



# add knobs
div = nuke.Text_Knob('someTextKnob','')
myNode.addKnob(div)

lgt_name = nuke.EvalString_Knob('lgt1_name','LGT1 name', 'some text') # id, label, txt
myNode.addKnob(lgt_name)

lgt_size = nuke.XY_Knob('lgt1_size', 'LGT1 size')
myNode.addKnob(lgt_size)

lgt_3Dpos = nuke.XYZ_Knob('lgt1_3Dpos', 'LGT1 3D pos')
myNode.addKnob(lgt_3Dpos)

lgt_distance = nuke.Double_Knob('lgt1_distance', ' distance')
myNode.addKnob(lgt_distance )

lgt_isSun = nuke.Boolean_Knob('lgt1_isSun', ' sun/HMI')
myNode.addKnob(lgt_isSun )

lgt_mask_clr = nuke.AColor_Knob('lgt1_maskClr', 'LGT1 mask clr')
lgt_mask_clr.setValue([0.12, 0.62, 0.115, 0.65])
lgt_mask_clr.setVisible(False)
myNode.addKnob(lgt_mask_clr)


# add tab group knob
lightTab = nuke.Tab_Knob('lgt1_tabBegin', 'LGT1, nuke.TABBEGINGROUP)
myNode.addKnob(lightTab)
lightTab = nuke.Tab_Knob('lgt1_tabEnd', 'LGT1', nuke.TABENDGROUP)
myNode.addKnob(lightTab)


# note if you have only one tab and you are programmatically adding to the bottom of it
# remove the last endGroup node to make sure the new knobs go into the tab
myNode.removeKnob(myNode['endGroup'])


# python script knob
remove_script = """
node = nuke.thisNode()
for knob in node.knobs():
	print(knob)
	if "lgt%s" in knob:
		node.removeKnob(node.knobs()[knob])
node.begin()
lightGizmo = nuke.toNode('lgt%s')
nuke.delete(lightGizmo)
node.end()
""" % (str(length), str(length))
lgt_remove = nuke.PyScript_Knob('lgt1_remove', 'LGT1 Remove', remove_script)
myNode.addKnob(lgt_remove )



# link checkbox to function through knobChanged 
hdriGenNode.knob('knobChanged').setValue('''
nk = nuke.thisNode()
k = nuke.thisKnob()
if ("Jabuka_checkbox" in k.name()):
print 'ciao'
''')


# knobChanged production example
my_code = """
n = nuke.thisNode()
k = nuke.thisKnob()
if k.name()=="sheetOrSequence" or k.name()=="showPanel":
      #print(nuke.toNode(n.name() + '.MasterSwitch')['which'].getValue())
      if nuke.toNode(n.name() + '.MasterSwitch')['which'].getValue() == 0.0:
          n['frameEnd'].setValue(nuke.toNode(n.name() + '.MasterSwitch')['masterAppendClip_lastFrame'].getValue())
      elif nuke.toNode(n.name() + '.MasterSwitch')['which'].getValue() == 1.0 :
          n['frameEnd'].setValue(nuke.toNode(n.name() + '.MasterSwitch')['masterContactSheet_lastFrame'].getValue())
"""
nuke.toNode("JonasCSheet1").knob("knobChanged").setValue(my_code)

# retrieve the knobChanged callback
node['knobChanged'].toScript()



# nuke knobChanged callback
https://corson.be/nuke_python_snippet/
# “knobChanged” is an “hidden” knob which holds code executed each time that we touch any node’s knob. 
# Thanks to that we can filter some user actions on the node and doing cool stuff like dynamically adding things inside a group.
# This follows the node
code = """
knob = nuke.thisKnob()
if knob.name() == 'size':
  print "size : %s" % knob.value()
"""
nuke.selectedNode()["knobChanged"].setValue(code)





def find_dependent_nodes(selected_node, targetClass):
    dependent_nodes = set()
    visited_nodes = set()
    def recursive_search(node):
        if node in visited_nodes:
            return
        visited_nodes.add(node)
        dependents = node.dependent()
        for dependent_node in dependents:
            print(dependent_node.Class())
            if dependent_node.Class() == targetClass:
                dependent_nodes.add(dependent_node)
            recursive_search(dependent_node)
    recursive_search(selected_node)
    return dependent_nodes

find_dependent_nodes(node, 'Write')






# nuke changed through a nuke callback
def myCallback():
    # Code to execute when any checkbox knob changes
    print("Some checkbox value has changed!")
    n = nuke.thisNode()
    k = nuke.thisKnob()
    if k.name()=="myknob" or k.name()=="showPanel":
        print('do this')
nuke.addKnobChanged(myCallback)
nuke.removeKnobChanged(myCallback) # remove it first every time you wish to change the callback


# nuke callback production example (note this will need to be saved in a place that nuke can retrieve: 
https://support.foundry.com/hc/en-us/articles/115000007364-Q100248-Adding-Callbacks-in-Nuke)
def sheetOrSequenceCallback():
    # Code to execute when any checkbox knob changes
    #print("Some checkbox value has changed!")
    n = nuke.thisNode()
    k = nuke.thisKnob()
    if k.name()=="sheetOrSequence" or k.name()=="showPanel":
          #print(nuke.toNode(n.name() + '.MasterSwitch')['which'].getValue())
          if nuke.toNode(n.name() + '.MasterSwitch')['which'].getValue() == 0.0:
              n['frameEnd'].setValue(nuke.toNode(n.name() + '.MasterSwitch')['masterAppendClip_lastFrame'].getValue())
          elif nuke.toNode(n.name() + '.MasterSwitch')['which'].getValue() == 1.0 :
              n['frameEnd'].setValue(nuke.toNode(n.name() + '.MasterSwitch')['masterContactSheet_lastFrame'].getValue())
# Add the callback function to the knob
nuke.addKnobChanged(sheetOrSequenceCallback)
nuke.removeKnobChanged(sheetOrSequenceCallback)




# more about callbacks






# return all knobs
for label, knob in sorted(jonasNode.knobs().items()): 
    print(label, knob.value())


# remove a knob
for label, knob in sorted(mynode.knobs().items()): 
    if 'keyshot' in label.lower():
        mynode.removeKnob(knob)



# work inside a node group
posNode.begin()
posNode.end()


 

# move back to root level
nuke.Root().begin()


# Add a button link to docs
import webbrowser
browser = webbrowser.get('chrome')
site = 'https://yoursite'
browser.open(site)
 

# return all nodes
nuke.allNodes()



# python code inside a text node message
[python -exec {
import re
import json
output = 'hello'
...
...
}]
[python output]

 

# connect nodes
blur.setInput(0, read)



# label a node
blur['label'].setValue("Size: [value size]\nChannels: [value channels]\nMix: [value mix]")



# disconnect nodes
node.setInput(0, None)

 

# arrange nodes
for n in nuke.allNodes(): n.autoplace()

 

# snap them to closest grid
for n in nuke.allNodes(): nuke.autoplaceSnap( n )

 

# help on commands
help(nuke.Double_Knob)

 

# rename nodes
node['name'].setValue('new')



# query the format of an image at a given node level
myNode.input(0).format().width()
 

# select given node
all_nodes = nuke.allNodes()
for i in all_nodes:
i.knob("selected").setValue(False)
myNode.setSelected(True)

 

# return the connected nodes
metaNode.dependent()

 

# return the input node
metaNode.input(0)

 

# copy and paste node
nuke.toNode('original node').setSelected(True)
nuke.nodeCopy(nukescripts.cut_paste_file())
nukescripts.clear_selection_recursive()
newNode = nuke.nodePaste(nukescripts.cut_paste_file())


# copy and paste node alternative
https://corson.be/nuke_python_snippet/
node = nuke.selectedNode()
newNode = nuke.createNode(node.Class(), node.writeKnobs(nuke.WRITE_NON_DEFAULT_ONLY | nuke.TO_SCRIPT), inpanel=False)
node.writeKnobs(nuke.WRITE_USER_KNOB_DEFS | nuke.WRITE_NON_DEFAULT_ONLY | nuke.TO_SCRIPT)
 


# set knob value
metaNode.knob('operation').setValue('Avg Intensities')

 

# get knob value
writeNode.knob('file').value()




# get a pulldown choice knob label
pulldown_knob = node[knob_name]
pulldown_index = pulldown_knob.value()  # Get the current index of the pulldown knob
pulldown_label = pulldown_knob.enumName(pulldown_index)



# link two knobs' attributes
# add knob link
k = nuke.Link_Knob('attr1_id','attr1')
k.makeLink(node.name(), 'attr2_id.attr2')

 

# link two knobs between different nodes
sel = nuke.selectedNode()
lgt_colorspace = nuke.Link_Knob('colorspace', 'Colorspace')
sel.addKnob(lgt_colorspace)
Read1 = nuke.selectedNode()
sel.knob('colorspace').makeLink(Read1.name(), 'colorspace')


# link pulldown menus
Ben, how do I expression-link Pulldown Knobs?

This syntax can be read as {child node}.{knob} — link to {parent node}.{knob}
nuke.toNode('lgtRenderStatistics.Text2').knob('yjustify').setExpression('lgtRenderStatistics.yjustify')
nuke.toNode('lgtRenderStatistics.Text2').knob('xjustify').setExpression('lgtRenderStatistics.xjustify')
 

# create a grade node set to only red and change its gain
mg = nuke.nodes.Grade(name='test2',channels='red')
mg['white'].setValue(2)
# remove a node
nuke.delete(newNode)

 

# get one value out of an array paramater
mynode.knob(pos_name).value()[0]
mynode.knob(pos_name).value()[1]

 

# find all nodes of type write
writeNodesList = []
for node in nuke.allNodes('Write'): writeNodesList.append(node)

 

# create an expression in python to connect parameters
myNode.knob("ROI").setExpression("parent." + pos_name)


# link knobs between nodes through an expression (https://learn.foundry.com/nuke/content/comp_environment/expressions/linking_expressions.html)
Transform1.scale


# connect two checkbox knobs so that one works the opposite of the other (False:True)
node = nuke.toNode('myNode.Text2_all_sphericalcameratest_beauty')
node.knob('disable').setExpression('parent.viewStats ? 0 : 1')


# connect parameters between nodes at different level through an (non python) expression 
maskGradeNode.knob('white').setExpression('parent.parent.lgt1_maskClr')


# connect parameters between nodes at different level through a python expression 
nuke.thisNode().parent()['sheetOrSequence'].getValue()
# or using python in TCL
[python {nuke.thisNode().parent()['sheetOrSequence'].getValue()}]


# multiline python expression in TCL
[python {nuke.thisNode().parent()['sheetOrSequence'].getValue()}]
[python {print(nuke.thisNode())}]


# multiline python expression from code with a return statement
nuke.selectedNode().knob('which').setExpression('''[python -execlocal 
x = 2 
for i in range(10): 
    x += i 
ret = x]''', 0)  


# connect 2d knobs on the same node through a python expression
nuke.thisNode()['TL'].getValue()[0] + ((nuke.thisNode()['TR'].getValue()[0] - nuke.thisNode()['TL'].getValue()[0])/2)
# To add this as a python expression on each x and y of a 2d knob 
newLabel_expression_x = "[python nuke.thisNode()\['TL'\].getValue()\[0\] + ((nuke.thisNode()\['TR'\].getValue()\[0\] - nuke.thisNode()\['TL'\].getValue()\[0\])/2)]"
newLabel_expression_y = "[python nuke.thisNode()\['TL'\].getValue()\[1\] + 10]"
node['lightLabel'].setExpression(newLabel_expression_x, 0)
node['lightLabel'].setExpression(newLabel_expression_y, 1)
# note this may launch some errors when generating the node
# a tcl expression seems to work best
newLabel_expression_x = "lgt" + str(length) + "_tl.x() + 20"
newLabel_expression_y = "lgt" + str(length) + "_tl.y() + 20"
lgt_label.setExpression(newLabel_expression_x, 0)
lgt_label.setExpression(newLabel_expression_y, 1)



# load gizmo
nuke.load('Offset')

 

# set knobs colors
hdriGenNode.knob('add').setLabel("<span style="color: yellow;"&gt;Add Light")


# or at creation, add knob with color
lgt_LUX = nuke.Text_Knob('lgt%s_LUX' %str(length),"<font color='yellow'> LUX",'0') # id, label, txt


# or when creating the knob manually:
<font color='#FF0000'>Keyshot 1
or
<font color='red'>Keyshot 1


# set color knob values
hdriGenNode.knob('lgt_maskClr_1').setValue([0.0, 0.5, 0.0, 0.8])
hdriGenNode.knob('lgt_maskClr_1').setValue(0.4,3) # set only the alpha





# return nuke file path
nuke.root().knob('name').value()

 

# write metadata
metadata_content = '{set %sName %s}\n{set %sMaxLuma %s}\n{set %sEV %s}\n{set %sLUX %s}\n{set %sPos2D %s}\n{set %sPos3D %s}\n{set %sDistance %s}\n{set %sScale %s}\n{set %sOutputPath %s}\n' % (lgtName, lgtCustomName, lgtName, str(maxL[0]), lgtName, str(lgt_EV), lgtName, str(lgt_LUX), lgtName, string.replace(str(pos2D),' ',''), lgtName, string.replace(str(pos3D),' ',''), lgtName, str(distance), lgtName, string.replace(str(scale),' ',''), lgtName, outputPath)
metadataNode["metadata"].fromScript(metadata_content)


# read metadata
# metadata should be stored under the read node itself under one of the tabs
readNode.metadata().get( 'exr/arnold/host/name' )
 

# return scene name
nuke.root().knob('name').value()

 

# animate text by getting a knob's value of a specific node:
[value Read1.first]

 

# animate text by getting a knob's value of current node:
[value this.size]

 

# add to the menus
mainMenu = nuke.menu( "Nodes" )
mainMenuItem = mainMenu.findItem( "NewMenuName" )
if not mainMenuItem :
mainMenuItem = mainMenu.addMenu( "NewMenuName" )
subMenuItem = mainMenuItem.findItem( "subMenu" )
if not subMenuItem:
subMenuItem = mainMenuItem.addMenu( "subMenu" )

return [ mainMenuItem ]

menus = myMenus()
for menu in menus:
menu.addCommand('my tool', 'mytool.file.function()', None)

 

# add aov layer
nuke.Layer(mynode, [mynode +'.red', mynode +'.green', mynode +'.blue', mynode +'.alpha'])

 







# onCreate options (like an onload option)
# https://community.foundry.com/discuss/topic/106936/how-to-use-the-oncreate-callback
# https://benmcewan.com/blog/2018/09/10/add-new-functionality-to-default-nodes-with-addoncreate/
# For example, you could do this:
def setIt():
   n = nuke.thisNode()
   k= n.knob( 'artist' )
   user = envTools.getUser()
   k.setValue(user)
nuke.addOnCreate(setIt, nodeClass = "")

# retrieve the oncreate function
sel = nuke.selectedNodes()
code = sel[0]['onCreate'].getValue()
print(code)


# Or if you want to bake your code directly to a node: 
code = """
n = nuke.thisNode()
k= n.knob( 'artist' )
user = envTools.getUser()
k.setValue(user)
"""
nuke.selectedNode()["onCreate"].setValue(code)
# Problem with onCreate is that it's run every time the node is created, which means even open a script will trigger the code.



 

# replace known nodes
nodeToPaste = '''set cut_paste_input [stack 0]
version 12.2 v10
push $cut_paste_input
Group {
name DeepToImage
tile_color 0x60ff
selected true
xpos 862
ypos -3199
addUserKnob {20 DeepToImage}
addUserKnob {6 volumetric_composition l "volumetric composition" +STARTLINE}
volumetric_composition true
}
Input {
inputs 0
name Input1
xpos -891
ypos -705
}
DeepToImage {
volumetric_composition {{parent.volumetric_composition}}
name DeepToImage
xpos -891
ypos -637
}
ModifyMetaData {
metadata {
{remove exr/chunkCount ""}
}
name ModifyMetaData1
xpos -891
ypos -611
}
Output {
name Output1
xpos -891
ypos -530
}
end_group
'''
fileName = '/tmp/deleteme.cache'
out_file = open(fileName, "w")
out_file.write(str(nodeToPaste))
out_file.close()
allNodes = nuke.allNodes()
for i in allNodes:
i.knob("selected").setValue(False)
for node in allNodes:
if 'DeepToImage' in node.name():
node.setSelected(True)
newNode = nuke.nodePaste(fileName)
nuke.delete(node)


# force a knob on the same line
hdriGenNode.addKnob(lgt_name)
# stay on the same line
lgt_lightGroup.clearFlag(nuke.STARTLINE)
hdriGenNode.addKnob(lgt_lightGroup)
# start a new line
lgt_extractMode.setFlag(nuke.STARTLINE)
hdriGenNode.addKnob(lgt_extractMode)

 


# text message per frame
set cut_paste_input [stack 0]
version 12.2 v10
push 0
push 0
push 0
push 0
Text2 {
 inputs 0
 font_size_toolbar 100
 font_width_toolbar 100
 font_height_toolbar 100
 message "MultiplyFloat.a   0.003\nMultiplyFloat2.a 0.35"
 old_message {{77 117 108 116 105 112 108 121 70 108 111 97 116 46 97 32 32 32 48 46 48 48 51 10 77 117 108 116 105 112 108 121 70 108 111 97 116 50 46 97 32 48 46 51 53}
   }
 box {175.2000122 896 1206.200012 1014}
 transforms {{0 2}
   }
 global_font_scale 0.5
 center {1024 540}
 cursor_initialised true
 autofit_bbox false
 initial_cursor_position {{175.2000122 974.4000854}
   }
 group_animations {{0} imported: 0 selected: items: "root transform/"}
 animation_layers {{1 11 1024 540 0 0 1 1 0 0 0 0}
   }
 name Text20
 selected true
 xpos 1197
 ypos -132
}
FrameRange {
 first_frame 1017
 last_frame 1017
 time ""
 name FrameRange19
 selected true
 xpos 1197
 ypos -77
}
AppendClip {
 inputs 5
 firstFrame 1017
 meta_from_first false
 time ""
 name AppendClip3
 selected true
 xpos 1433
}
push 0
Reformat {
 format "2048 1080 0 0 2048 1080 1 2K_DCP"
 name Reformat4
 selected true
 xpos 1843
 ypos -251
}
Merge2 {
 inputs 2
 name Merge5
 selected true
 xpos 1843
}
push $cut_paste_input
Reformat {
 format "2048 1080 0 0 2048 1080 1 2K_DCP"
 name Reformat5
 selected true
 xpos 1715
 ypos 80
}
Merge2 {
 inputs 2
 name Merge6
 selected true
 xpos 1843
 ypos 86
}






# check negative pixels
set cut_paste_input [stack 0]
version 12.2 v10
push $cut_paste_input
Expression {
 expr0 "r < 0 ? 1 : 0"
 expr1 "g < 0 ? 1 : 0"
 expr2 "b < 0 ? 1 : 0"
 name Expression4
 selected true
 xpos 1032
 ypos -106
}
FilterErode {
 channels rgba
 size -1.3
 name FilterErode4
 selected true
 xpos 1032
 ypos -58
}






# check where the user is clicking on the viewer area
import nuke
from PySide2.QtWidgets import QApplication
from PySide2.QtCore import QObject, QEvent, Qt
from PySide2.QtGui import QMouseEvent

class ViewerClickCallback(QObject):
    def eventFilter(self, obj, event):
        if event.type() == QEvent.MouseButtonPress and event.button() == Qt.LeftButton:
            # Mouse click detected
            mouse_pos = event.pos()
            print("Mouse clicked at position:", mouse_pos.x(), mouse_pos.y())
        return super(ViewerClickCallback, self).eventFilter(obj, event)

#Create an instance of the callback
callback = ViewerClickCallback()

#Install the event filter on the application
qapp = QApplication.instance()
qapp.installEventFilter(callback)
qapp.removeEventFilter(callback)



## you can put this under a node's button and close the callback after a given mouse click
## OR closing the callback through a different button 
import nuke
from PySide2.QtCore import QObject, QEvent, Qt
from PySide2.QtWidgets import QApplication
class ViewerClickCallback(QObject):
    def __init__(self, arg1):
        super().__init__()
        self.arg1 = arg1
    def eventFilter(self, obj, event):
        if event.type() == QEvent.MouseButtonPress and event.button() == Qt.LeftButton:
            # Mouse click detected
            mouse_pos = event.pos()
            print("Mouse clicked at position:", mouse_pos.x(), mouse_pos.y(),'\n')
            if self.arg1 == 'bl':
                jonasNode['bl'].setValue([mouse_pos.x(), mouse_pos.y()])
                qapp.removeEventFilter(callback)
        return super(ViewerClickCallback, self).eventFilter(obj, event)
# Create an instance of the callback
callback = ViewerClickCallback('bl')
# Store the callback as a global variable
nuke.root().knob('custom_callback').setValue(callback)
# Install the event filter on the application
qapp = QApplication.instance()
qapp.installEventFilter(callback)

## on the second button:
import nuke
# Retrieve the callback object from the global variable
callback = nuke.root().knob('custom_callback').value()
# Retrieve the QApplication instance
qapp = QApplication.instance()
# Remove the event filter
qapp.removeEventFilter(callback)




# collect deepsamples for a given node
nodelist = ['DeepSampleB_hdri','DeepSampleA_hdri','DeepSampleB_spheres','DeepSampleA_spheres','DeepSampleB_volume','DeepSampleA_volume','DeepSampleB_furmg','DeepSampleA_furmg','DeepSampleB_furfg','DeepSampleA_furfg','DeepSampleB_furbg','DeepSampleA_furbg','DeepSampleB_checkers','DeepSampleA_checkers']

nodelist = ['DeepSampleB_hdri']

finalSamplesList = []
for nodeName in nodelist:
    print(nodeName)
    finalSamplesList.append(nodeName)
    finalSampes = 0
    for posX in range(0,1921):
        for posY in range(0,1081):
            nukeNode = nuke.toNode(nodeName)
            nukeNode['pos'].setValue([posX,posY])
            current_posSamples = nukeNode['samples'].getValue()
            finalSamples = finalSamples + current_posSamples
    print(finalSamples)
    finalSamplesList.append(finalSamples)



# false color expressions
set cut_paste_input [stack 0]
version 13.2 v8
push $cut_paste_input
Expression {
 expr0 "(r > 2) || (g > 2) || (b > 2) ? 3:0"
 expr1 "((r > 1) && (r < 2)) || ((g > 1) && (g < 2)) || ((b > 1) && (b < 2))\n ? 2:0"
 expr2 "((r > 0) && (r < 1)) || ((g > 0) && (g < 1)) || ((b > 0) && (b < 1))\n ? 1:0"
 name Expression4
 selected true
 xpos 90
 ypos 1795
}

(more…)

www.paul-reed.co.uk/programming.html

www.geeksforgeeks.org/graph-plotting-in-python-set-1/

https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.xlabel.html

https://www.freecodecamp.org/news/how-to-embed-interactive-python-visualizations-on-your-website-with-python-and-matplotlib/

https://python-graph-gallery.com/10-barplot-with-number-of-observation/

www.cartoonbrew.com/animators/hayao-miyazaki-explains-develop-idea-film-147319.html

” The Idea—the Origin of Everything

Is the starting point of an animated film the time when the project is given the go-ahead and production begins? Is it at that point that you, as the animator, first go over your ideas for that story? No, that isn’t the starting point. Everything begins much earlier, perhaps before you even think of becoming an animator. The stories and original works—even initial project planning—are only triggers.

Inspired by that trigger, what rushes forth from inside you is the world you have already drawn inside yourself, the many landscapes you have stored up, the thoughts and feelings that seek expression.

When people speak of a beautiful sunset, do they hurriedly riffle through a book of photographs of sunsets or go in search of a sunset? No, you speak about the sunset by drawing on the many sunsets stored inside you—feelings deeply etched in the folds of your consciousness of the sunset you saw while carried on your mother’s back so long ago that the memory is nearly a dream; or the sunset-washed landscape you saw when, for the first time in your life, you were enchanted by the scene around you; or the sunsets you witnessed that were wrapped in loneliness, anguish, or warmth.

You who want to become animators already have a lot of material for the stories you want to tell, the feelings you want to express, and the imaginary worlds you want to bring alive. At times these may be borrowed from a dream someone related, a fantasy, or an embarrassingly self-involved interior life. But everyone moves forward from this stage. In order for it not to remain merely egotistical, when you tell others about your dream you must turn it into a world unto itself. As you go through the process of sharpening your powers of imagination and technique, the material takes shape. If that shape is amorphous, you can start with a vague yearning. It all begins with having something that you want to express.

Say a project has been decided on and you have been inspired by something. A certain sentiment, a slight sliver of emotion – whatever it is, it must be something you feel drawn to and that you want to depict. It cannot solely be something that others might find amusing, it must be something that you yourself would like to see. It is fine if, at times, the original starting point of a full-length feature film is the image of a girl tilting her head to the side.

From within the confusion of your mind, you start to capture the hazy figure of what you want to express. And then you start to draw. It doesn’t matter if the story isn’t yet complete. The story will follow. Later still the characters take shape. You draw a picture that establishes the underlying tone for a specific world. Of course, what you have drawn will not be your final product. At times, your work may be rejected entirely. When I mentioned earlier that you must have the will to go to any length, this is what I meant. When you draw that first picture, it is only the beginning of an immense journey. This is the start of the preparation stage of the film.

What kind of world, serious or comedic; what degree of distortion; what setting; what climate; what content; what period; whether there is one sun or three; what kinds of characters will appear; what is the main theme…? The answers to all of these questions gradually become clearer as you continue to draw. Don’t just follow a ready-made story. Rather, consider a possible development in the story, or whether a particular kind of character can be added. Make the tree trunk thicker, spread its branches further – or go to the tips of the small branches (this could be the starting point of the idea), and on to the leaves beyond as the branches grow and grow.

Draw many pictures, as many as you can. Eventually a world is created. To create one world means to discard other inconsistent or clashing worlds. If something is very important to you, you can keep it carefully stored in your heart for use at another time. Those who have experienced an outpouring of an amazing number of pictures from inside themselves can feel it. They feel that the fragment of a picture they envisioned, the other trunk of a story that was thrown out while piecing together a narrative, the memory of pining for a girl, the knowledge about a subject gained as they delved deeply into a hobby – all of these play a role and become entwined into one thick strand. The scattered material within you has found its direction and started to flow.

gumroad.com/l/dOumo

www.xuanprada.com/blog/2014/11/3/hdri-shooting

http://blog.gregzaal.com/2016/03/16/make-your-own-hdri/

http://blog.hdrihaven.com/how-to-create-high-quality-hdri/

Shooting checklist

• Full coverage of the scene (fish-eye shots)
• Backplates for look-development (including ground or floor)
• Macbeth chart for white balance
• Grey ball for lighting calibration
• Chrome ball for lighting orientation
• Basic scene measurements
• Material samples
• Individual HDR artificial lighting sources if required

Methodology

• Plant the tripod where the action happens, stabilise it and level it
• Set manual focus
• Set white balance
• Set ISO
• Set raw+jpg
• Set apperture
• Metering exposure
• Set neutral exposure
• Read histogram and adjust neutral exposure if necessary
• Shot slate (operator name, location, date, time, project code name, etc)
• Set auto bracketing
• Shot 5 to 7 exposures with 3 stops difference covering the whole environment
• Place the aromatic kit where the tripod was placed, and take 3 exposures. Keep half of the grey sphere hit by the sun and half in shade.
• Place the Macbeth chart 1m away from tripod on the floor and take 3 exposures
• Take backplates and ground/floor texture references
• Shoot reference materials
• Write down measurements of the scene, specially if you are shooting interiors.
• If shooting artificial lights take HDR samples of each individual lighting source.

Exposures starting point

• Day light sun visible ISO 100 F22
• Day light sun hidden ISO 100 F16
• Cloudy ISO 320 F16
• Sunrise/Sunset ISO 100 F11
• Interior well lit ISO 320 F16
• Interior ambient bright ISO 320 F10
• Interior bad light ISO 640 F10
• Interior ambient dark ISO 640 F8
• Low light situation ISO 640 F5

www.awn.com/news/warnermedia-release-six-superhero-films-year

https://www.researchgate.net/publication/342521609_CAMERA_PROJECTION_MAPPING_FOR_ENVIRONMENTS_IN_NUKE

https://www.foundry.com/insights/film-tv/art-of-lighting-history

archive.org/web/

renderwonk.com/publications/s2010-shading-course/snow/sigg2010_physhadcourse_ILM_slides.compressed.pdf

renderwonk.com/publications/s2010-shading-course/snow/sigg2010_physhadcourse_ILM.pdf

Local files:

Also see: http://www.pixelsham.com/2015/05/16/how-aperture-shutter-speed-and-iso-affect-your-photos/

In photography, exposure value (EV) is a number that represents a combination of a camera’s shutter speed and f-number, such that all combinations that yield the same exposure have the same EV (for any fixed scene luminance).

The EV concept was developed in an attempt to simplify choosing among combinations of equivalent camera settings. Although all camera settings with the same EV nominally give the same exposure, they do not necessarily give the same picture. EV is also used to indicate an interval on the photographic exposure scale. 1 EV corresponding to a standard power-of-2 exposure step, commonly referred to as a stop

EV 0 corresponds to an exposure time of 1 sec and a relative aperture of f/1.0. If the EV is known, it can be used to select combinations of exposure time and f-number.

https://www.streetdirectory.com/travel_guide/141307/photography/exposure_value_ev_and_exposure_compensation.html

Note EV does not equal to photographic exposure. Photographic Exposure is defined as how much light hits the camera’s sensor. It depends on the camera settings mainly aperture and shutter speed. Exposure value (known as EV) is a number that represents the exposure setting of the camera.

Thus, strictly, EV is not a measure of luminance (indirect or reflected exposure) or illuminance (incidental exposure); rather, an EV corresponds to a luminance (or illuminance) for which a camera with a given ISO speed would use the indicated EV to obtain the nominally correct exposure. Nonetheless, it is common practice among photographic equipment manufacturers to express luminance in EV for ISO 100 speed, as when specifying metering range or autofocus sensitivity.

The exposure depends on two things: how much light gets through the lenses to the camera’s sensor and for how long the sensor is exposed. The former is a function of the aperture value while the latter is a function of the shutter speed. Exposure value is a number that represents this potential amount of light that could hit the sensor. It is important to understand that exposure value is a measure of how exposed the sensor is to light and not a measure of how much light actually hits the sensor. The exposure value is independent of how lit the scene is. For example a pair of aperture value and shutter speed represents the same exposure value both if the camera is used during a very bright day or during a dark night.

Each exposure value number represents all the possible shutter and aperture settings that result in the same exposure. Although the exposure value is the same for different combinations of aperture values and shutter speeds the resulting photo can be very different (the aperture controls the depth of field while shutter speed controls how much motion is captured).

EV 0.0 is defined as the exposure when setting the aperture to f-number 1.0 and the shutter speed to 1 second. All other exposure values are relative to that number. Exposure values are on a base two logarithmic scale. This means that every single step of EV – plus or minus 1 – represents the exposure (actual light that hits the sensor) being halved or doubled.

https://www.streetdirectory.com/travel_guide/141307/photography/exposure_value_ev_and_exposure_compensation.html

Formula

https://en.wikipedia.org/wiki/Exposure_value

https://www.scantips.com/lights/math.html

which means   2^EV = N² / t

where

• N is the relative aperture (f-number) Important: Note that f/stop values must first be squared in most calculations
• t is the exposure time (shutter speed) in seconds

EV 0 corresponds to an exposure time of 1 sec and an aperture of f/1.0.

Example: If f/16 and 1/4 second, then this is:

(N² / t) = (16 × 16 ÷ 1/4) = (16 × 16 × 4) = 1024.

Log₂(1024) is EV 10. Meaning, 2¹⁰ = 1024.

Collecting photographic exposure using Light Meters

https://photo.stackexchange.com/questions/968/how-can-i-correctly-measure-light-using-a-built-in-camera-meter

The exposure meter in the camera does not know whether the subject itself is bright or not. It simply measures the amount of light that comes in, and makes a guess based on that. The camera will aim for 18% gray, meaning if you take a photo of an entirely white surface, and an entirely black surface you should get two identical images which both are gray (at least in theory)

https://en.wikipedia.org/wiki/Light_meter

For reflected-light meters, camera settings are related to ISO speed and subject luminance by the reflected-light exposure equation:

where

• N is the relative aperture (f-number)
• t is the exposure time (“shutter speed”) in seconds
• L is the average scene luminance
• S is the ISO arithmetic speed
• K is the reflected-light meter calibration constant

For incident-light meters, camera settings are related to ISO speed and subject illuminance by the incident-light exposure equation:

where

• E is the illuminance (in lux)
• C is the incident-light meter calibration constant

Two values for K are in common use: 12.5 (Canon, Nikon, and Sekonic) and 14 (Minolta, Kenko, and Pentax); the difference between the two values is approximately 1/6 EV.
For C a value of 250 is commonly used.

Nonetheless, it is common practice among photographic equipment manufacturers to also express luminance in EV for ISO 100 speed. Using K = 12.5, the relationship between EV at ISO 100 and luminance L is then :

L = 2^(EV-3)

The situation with incident-light meters is more complicated than that for reflected-light meters, because the calibration constant C depends on the sensor type. Illuminance is measured with a flat sensor; a typical value for C is 250 with illuminance in lux. Using C = 250, the relationship between EV at ISO 100 and illuminance E is then :

E = 2.5 * 2^(EV)

https://nofilmschool.com/2018/03/want-easier-and-faster-way-calculate-exposure-formula

Three basic factors go into the exposure formula itself instead: aperture, shutter, and ISO. Plus a light meter calibration constant.

f-stop²/shutter (in seconds) = lux * ISO/C

If you at least know four of those variables, you’ll be able to calculate the missing value.

So, say you want to figure out how much light you’re going to need in order to shoot at a certain f-stop. Well, all you do is plug in your values (you should know the f-stop, ISO, and your light meter calibration constant) into the formula below:

lux = C (f-stop²/shutter (in seconds))/ISO

Exposure Value Calculator:

https://www.vroegop.nu/exposure-value-calculator/

From that perspective, an exposure stop is a measurement of Exposure and provides a universal linear scale to measure the increase and decrease in light, exposed to the image sensor, due to changes in shutter speed, iso & f-stop.
+-1 stop is a doubling or halving of the amount of light let in when taking a photo.
1 EV is just another way to say one stop of exposure change.

One major use of EV (Exposure Value) is just to measure any change of exposure, where one EV implies a change of one stop of exposure. Like when we compensate our picture in the camera.

If the picture comes out too dark, our manual exposure could correct the next one by directly adjusting one of the three exposure controls (f/stop, shutter speed, or ISO). Or if using camera automation, the camera meter is controlling it, but we might apply +1 EV exposure compensation (or +1 EV flash compensation) to make the result goal brighter, as desired. This use of 1 EV is just another way to say one stop of exposure change.

On a perfect day the difference from sampling the sky vs the sun exposure with diffusing spot meters is about 3.2 exposure difference.

 ~15.4 EV for the sun
 ~12.2 EV for the sky

That is as a ballpark. All still influenced by surroundings, accuracy parameters, fov of the sensor…

EV calculator

https://www.scantips.com/lights/evchart.html#calc

http://www.fredparker.com/ultexp1.htm

Exposure value is basically used to indicate an interval on the photographic exposure scale, with a difference of 1 EV corresponding to a standard power-of-2 exposure step, also commonly referred to as a “stop”.

https://contrastly.com/a-guide-to-understanding-exposure-value-ev/

Retrieving photographic exposure from an image

IF you are still trying to gauge relative brightness, the level of the sun in Nuke can vary, but it should be in the thousands. Ie: between 30,000 and 65,0000 rgb value depending on time of the day, season and atmospherics.

The values for a 12 o’clock sun, with the sun sampled at EV 15.5 (shutter 1/30, ISO 100, F22) is 32.000 RGB max values (or 32,000 pixel luminance).
The thing to keep an eye for is the level of contrast between sunny side/fill side.  The terminator should be quite obvious,  there can be up to 3 stops difference between fill/key in sunny lit objects.

Note: In Foundry’s Nuke, the software will map 18% gray to whatever your center f/stop is set to in the viewer settings (f/8 by default… change that to EV by following the instructions below).
You can experiment with this by attaching an Exposure node to a Constant set to 0.18, setting your viewer read-out to Spotmeter, and adjusting the stops in the node up and down. You will see that a full stop up or down will give you the respective next value on the aperture scale (f8, f11, f16 etc.).
One stop doubles or halves the amount or light that hits the filmback/ccd, so everything works in powers of 2.
So starting with 0.18 in your constant, you will see that raising it by a stop will give you .36 as a floating point number (in linear space), while your f/stop will be f/11 and so on.

If you set your center stop to 0 (see below) you will get a relative readout in EVs, where EV 0 again equals 18% constant gray.
Note: make sure to set your Nuke read node to ‘raw data’

In other words. Setting the center f-stop to 0 means that in a neutral plate, the middle gray in the macbeth chart will equal to exposure value 0. EV 0 corresponds to an exposure time of 1 sec and an aperture of f/1.0.

To switch Foundry’s Nuke’s SpotMeter to return the EV of an image, click on the main viewport, and then press s, this opens the viewer’s properties. Now set the center f-stop to 0 in there. And the SpotMeter in the viewport will change from aperture and fstops to EV.

If you are trying to gauge the EV from the pixel luminance in the image:
– Setting the center f-stop to 0 means that in a neutral plate, the middle 18% gray will equal to exposure value 0.
– So if EV 0 = 0.18 middle gray in nuke which equal to a pixel luminance of 0.18, doubling that value, doubles the EV.

.18 pixel luminance = 0EV
.36 pixel luminance = 1EV
.72 pixel luminance = 2EV
1.46 pixel luminance = 3EV
...

This is a Geometric Progression function: x_n = ar^(n-1)

The most basic example of this function is 1,2,4,8,16,32,… The sequence starts at 1 and doubles each time, so

• a=1 (the first term)
• r=2 (the “common ratio” between terms is a doubling)

And we get:

{a, ar, ar², ar³, … }

= {1, 1×2, 1×2², 1×2³, … }

= {1, 2, 4, 8, … }

In this example the function translates to: n = 2^(n-1)
You can graph this curve through this expression: x = 2^(y-1)  :

You can go back and forth between the two values through a geometric progression function and a log function:

(Note: in a spreadsheet this is: = POWER(2; cell# -1)  and  =LOG(cell#, 2)+1) )

Translating this into a geometric progression between an image pixel luminance and EV:

(more…)