Search Results for: hdr

https://www.studiobinder.com/blog/what-is-dynamic-range-photography/

 

https://www.hdrsoft.com/resources/dri.html#bit-depth

 

 

The dynamic range is a ratio between the maximum and minimum values of a physical measurement. Its definition depends on what the dynamic range refers to.

For a scene: Dynamic range is the ratio between the brightest and darkest parts of the scene.

 

For a camera: Dynamic range is the ratio of saturation to noise. More specifically, the ratio of the intensity that just saturates the camera to the intensity that just lifts the camera response one standard deviation above camera noise.

 

For a display: Dynamic range is the ratio between the maximum and minimum intensities emitted from the screen.

 

 

 

 

 

nofilmschool.com/types-of-film-lights

 

“Not every light performs the same way. Lights and lighting are tricky to handle. You have to plan for every circumstance. But the good news is, lighting can be adjusted. Let’s look at different factors that affect lighting in every scene you shoot. ”

Use CRI, Luminous Efficacy and color temperature controls to match your needs.

 

Color Temperature
Color temperature describes the “color” of white light by a light source radiated by a perfect black body at a given temperature measured in degrees Kelvin

 

http://www.pixelsham.com/2019/10/18/color-temperature/

 

CRI
“The Color Rendering Index is a measurement of how faithfully a light source reveals the colors of whatever it illuminates, it describes the ability of a light source to reveal the color of an object, as compared to the color a natural light source would provide. The highest possible CRI is 100. A CRI of 100 generally refers to a perfect black body, like a tungsten light source or the sun. ”

 

https://www.studiobinder.com/blog/what-is-color-rendering-index/

 

 

 

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

 

Light source	CCT (K)	CRI
Low-pressure sodium (LPS/SOX)	1800	−44
Clear mercury-vapor	6410	17
High-pressure sodium (HPS/SON)	2100	24
Coated mercury-vapor	3600	49
Halophosphate warm-white fluorescent	2940	51
Halophosphate cool-white fluorescent	4230	64
Tri-phosphor warm-white fluorescent	2940	73
Halophosphate cool-daylight fluorescent	6430	76
“White” SON	2700	82
Standard LED Lamp	2700–5000	83
Quartz metal halide	4200	85
Tri-phosphor cool-white fluorescent	4080	89
High-CRI LED lamp (blue LED)	2700–5000	95
Ceramic discharge metal-halide lamp	5400	96
Ultra-high-CRI LED lamp (violet LED)	2700–5000	99
Incandescent/halogen bulb	3200	100

 

Luminous Efficacy
Luminous efficacy is a measure of how well a light source produces visible light, watts out versus watts in, measured in lumens per watt. In other words it is a measurement that indicates the ability of a light source to emit visible light using a given amount of power. It is a ratio of the visible energy to the power that goes into the bulb.

 

FILM LIGHT TYPES

https://www.studiobinder.com/blog/video-lighting-kits/?utm_campaign=Weekly_Newsletter&utm_medium=email&utm_source=sendgrid&utm_term=production-lighting&utm_content=production-lighting

 

 

 

Consumer light types

 

https://www.researchgate.net/figure/Emission-spectra-of-different-light-sources-a-incandescent-tungsten-light-bulb-b_fig1_312320039

 

http://dev.informationdisplay.org/IDArchive/2015/NovemberDecember/FrontlineTechnologyCandleLikeEmission.aspx

 

 

Tungsten Lights
Light interiors and match domestic places or office locations. Daylight.

Advantages of Tungsten Lights
Almost perfect color rendition
Low cost
Does not use mercury like CFLs (fluorescent) or mercury vapor lights
Better color temperature than standard tungsten
Longer life than a conventional incandescent
Instant on to full brightness, no warm-up time, and it is dimmable

Disadvantages of Tungsten Lights
Extremely hot
High power requirement
The lamp is sensitive to oils and cannot be touched
The bulb is capable of blowing and sending hot glass shards outward. A screen or layer of glass on the outside of the lamp can protect users.

 

 

Hydrargyrum medium-arc iodide lights
HMI’s are used when high output is required. They are also used to recreate sun shining through windows or to fake additional sun while shooting exteriors. HMIs can light huge areas at once.

Advantages of HMI lights
High light output
Higher efficiency
High color temperature

Disadvantages of HMI lights:
High cost
High power requirement
Dims only to about 50%
the color temperature increases with dimming
HMI bulbs will explode is dropped and release toxic chemicals

 

 

Fluorescent
Fluorescent film lighting is achieved by laying multiple tubes next to each other, combining as many as you want for the desired brightness. The good news is you can choose your bulbs to either be warm or cool depending on the scenario you’re shooting. You want to get these bulbs close to the subject because they’re not great at opening up spaces. Fluorescent lighting is used to light interiors and is more compact and cooler than tungsten or HMI lighting.

Advantages of Fluorescent lights
High efficiency
Low power requirement
Low cost
Long lamp life
Cool
Capable of soft even lighting over a large area
Lightweight

Disadvantages of Fluorescent lights
Flicker
High CRI
Domestic tubes have low CRI & poor color rendition.

 

 

LED
LED’s are more and more common on film sets. You can use batteries to power them. That makes them portable and sleek – no messy cabled needed. You can rig your own panels of LED lights to fit any space necessary as well. LED’s can also power Fresnel style lamp heads such as the Arri L-series.

Advantages of LED light
Soft, even lighting
Pure light without UV-artifacts
High efficiency
Low power consumption, can be battery powered
Excellent dimming by means of pulse width modulation control
Long lifespan
Environmentally friendly
Insensitive to shock
No risk of explosion

Disadvantages of LED light
High cost.
LED’s are currently still expensive for their total light output

www.outpost-vfx.com/en/news/18-pro-tips-and-tricks-for-lighting

Get as much information regarding your plate lighting as possible

Always use a reference

Replicate what is happening in real life

Invest into a solid HDRI

Start Simple

Observe real world lighting, photography and cinematography

Don’t neglect the theory

Learn the difference between realism and photo-realism.

Keep your scenes organised

https://www.freecodecamp.org/news/advanced-computer-vision-with-python/

 

https://www.freecodecamp.org/news/how-to-use-opencv-and-python-for-computer-vision-and-ai/

 

 

Working for a VFX (Visual Effects) studio provides numerous opportunities to leverage the power of Python and OpenCV for various tasks. OpenCV is a versatile computer vision library that can be applied to many aspects of the VFX pipeline. Here’s a detailed list of opportunities to take advantage of Python and OpenCV in a VFX studio:

 

1. Image and Video Processing:
   • Preprocessing: Python and OpenCV can be used for tasks like resizing, color correction, noise reduction, and frame interpolation to prepare images and videos for further processing.
   • Format Conversion: Convert between different image and video formats using OpenCV’s capabilities.
2. Tracking and Matchmoving:
   • Feature Detection and Tracking: Utilize OpenCV to detect and track features in image sequences, which is essential for matchmoving tasks to integrate computer-generated elements into live-action footage.
3. Rotoscoping and Masking:
   • Segmentation and Masking: Use OpenCV for creating and manipulating masks and alpha channels for various VFX tasks, like isolating objects or characters from their backgrounds.
4. Camera Calibration:
   • Intrinsic and Extrinsic Calibration: Python and OpenCV can help calibrate cameras for accurate 3D scene reconstruction and camera tracking.
5. 3D Scene Reconstruction:
   • Stereoscopy: Use OpenCV to process stereoscopic image pairs for creating 3D depth maps and generating realistic 3D scenes.
   • Structure from Motion (SfM): Implement SfM techniques to create 3D models from 2D image sequences.
6. Green Screen and Blue Screen Keying:
   • Chroma Keying: Implement advanced keying algorithms using OpenCV to seamlessly integrate actors and objects into virtual environments.
7. Particle and Fluid Simulations:
   • Particle Tracking: Utilize OpenCV to track and manipulate particles in fluid simulations for more realistic visual effects.
8. Motion Analysis:
   • Optical Flow: Implement optical flow algorithms to analyze motion patterns in footage, useful for creating dynamic VFX elements that follow the motion of objects.
9. Virtual Set Extension:
   • Camera Projection: Use camera calibration techniques to project virtual environments onto physical sets, extending the visual scope of a scene.
10. Color Grading:
    • Color Correction: Implement custom color grading algorithms to match the color tones and moods of different shots.
11. Automated QC (Quality Control):
    • Artifact Detection: Develop Python scripts to automatically detect and flag visual artifacts like noise, flicker, or compression artifacts in rendered frames.
12. Data Analysis and Visualization:
    • Performance Metrics: Use Python to analyze rendering times and optimize the rendering process.
    • Data Visualization: Generate graphs and charts to visualize render farm usage, project progress, and resource allocation.
13. Automating Repetitive Tasks:
    • Batch Processing: Automate repetitive tasks like resizing images, applying filters, or converting file formats across multiple shots.
14. Machine Learning Integration:
    • Object Detection: Integrate machine learning models (using frameworks like TensorFlow or PyTorch) to detect and track specific objects or elements within scenes.
15. Pipeline Integration:
    • Custom Tools: Develop Python scripts and tools to integrate OpenCV-based processes seamlessly into the studio’s pipeline.
16. Real-time Visualization:
    • Live Previsualization: Implement real-time OpenCV-based visualizations to aid decision-making during the preproduction stage.
17. VR and AR Integration:
    • Augmented Reality: Use Python and OpenCV to integrate virtual elements into real-world footage, creating compelling AR experiences.
18. Camera Effects:
    • Lens Distortion: Correct lens distortions and apply various camera effects using OpenCV, contributing to the desired visual style.

 

Interpolating frames from an EXR sequence using OpenCV can be useful when you have only every second frame of a final render and you want to create smoother motion by generating intermediate frames. However, keep in mind that interpolating frames might not always yield perfect results, especially if there are complex changes between frames. Here’s a basic example of how you might use OpenCV to achieve this:

 

import cv2
import numpy as np
import os

# Replace with the path to your EXR frames
exr_folder = "path_to_exr_frames"

# Replace with the appropriate frame extension and naming convention
frame_template = "frame_{:04d}.exr"

# Define the range of frame numbers you have
start_frame = 1
end_frame = 100
step = 2

# Define the output folder for interpolated frames
output_folder = "output_interpolated_frames"
os.makedirs(output_folder, exist_ok=True)

# Loop through the frame range and interpolate
for frame_num in range(start_frame, end_frame + 1, step):
    frame_path = os.path.join(exr_folder, frame_template.format(frame_num))
    next_frame_path = os.path.join(exr_folder, frame_template.format(frame_num + step))

    if os.path.exists(frame_path) and os.path.exists(next_frame_path):
        frame = cv2.imread(frame_path, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)
        next_frame = cv2.imread(next_frame_path, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)

        # Interpolate frames using simple averaging
        interpolated_frame = (frame + next_frame) / 2

        # Save interpolated frame
        output_path = os.path.join(output_folder, frame_template.format(frame_num))
        cv2.imwrite(output_path, interpolated_frame)

        print(f"Interpolated frame {frame_num}") # alternatively: print("Interpolated frame {}".format(frame_num))

 

Please note the following points:

 

• The above example uses simple averaging to interpolate frames. More advanced interpolation methods might provide better results, such as motion-based algorithms like optical flow-based interpolation.
• EXR files can store high dynamic range (HDR) data, so make sure to use cv2.IMREAD_ANYDEPTH flag when reading these files.
• OpenCV might not support EXR format directly. You might need to use a library like exr to read and manipulate EXR files, and then convert them to OpenCV-compatible formats.
• Consider the characteristics of your specific render when using interpolation. If there are large changes between frames, the interpolation might lead to artifacts.
• Experiment with different interpolation methods and parameters to achieve the desired result.
• For a more advanced and accurate interpolation, you might need to implement or use existing algorithms that take into account motion estimation and compensation.

 

https://www.amazon.ca/dp/B0076A620Y

Datacolor SpyderX Elite
This excellent monitor calibrator comes with useful features, such as multi-monitor and projectors support, and it can detect the light conditions you’re working in to ensure your monitor looks its best.

X-Rite i1Display Pro Plus
Supports multiple monitors and HDR.
You’re able to use your profile across multiple displays (either on the same machine or network) as well as assess the ambient light in your workspace to set your monitor up for best results.

https://www.amazon.ca/X-Rite-i1Display-Pro-Plus-EODIS3PL/dp/B07XFX74V6

 

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…)

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) )

2(y-1)	log2(x)+1
x	y
1	1
2	2
4	3
8	4
16	5
32	6
64	7
128	8
256	9
512	10
1024	11
2048	12
4096	13

 

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

(more…)

https://www.translatorscafe.com/unit-converter/en-US/illumination/1-11/

 

 

The power output of a light source is measured using the unit of watts W. This is a direct measure to calculate how much power the light is going to drain from your socket and it is not relatable to the light brightness itself.

The amount of energy emitted from it per second. That energy comes out in a form of photons which we can crudely represent with rays of light coming out of the source. The higher the power the more rays emitted from the source in a unit of time.

Not all energy emitted is visible to the human eye, so we often rely on photometric measurements, which takes in account the sensitivity of human eye to different wavelenghts

 

 

 

https://pllight.com/understanding-lighting-metrics/

Candela is the basic unit of measure of light intensity from any point in a single direction from a light source. It measures the total volume of light within a certain beam angle and direction.
While the luminance of starlight is around 0.001 cd/m2, that of a sunlit scene is around 100,000 cd/m2, which is a hundred millions times higher. The luminance of the sun itself is approximately 1,000,000,000 cd/m2.

 

https://www.hdrsoft.com/resources/dri.html#bit-depth

To make it easier to represent values that vary so widely, it is common to use a logarithmic scale to plot the luminance. The scanline below represents the log base 10 of the luminance, so going from 0.1 to 1 is the same distance as going from 100 to 1000, for instance. A scene showing the interior of a room with a sunlit view outside the window, for instance, will have a dynamic range of approximately 100,000:1.

 

Lumen (lm) is the basic unit of measure for a light that is visible to the human eye. It indicates the total potential amount of light from a light source. If a uniform point source of 1 candela is at the center of a sphere with a 1ft2 radius with an opening of 1 ft2 at its surface, the quantity of light that passes through that opening is equal to 1 lumen. Since lumens are a photometric measurement for humans, we do not use this unit of measure for describing horticultural lighting.

 

Technically speaking, a Lumen is the SI unit of luminous flux, which is equal to the amount of light which is emitted per second in a unit solid angle of one steradian from a uniform source of one-candela intensity radiating in all directions.

 

Illuminance refers to the density of light over a given surface area, and is expressed in mostly LUX or lumens/m2.
Luminance refers to the amount of light emitted under various circumstances, and it is expressed mostly in LUMENS or candela/m2.

 

 

 

Lux (lx) or often Illuminance, is a photometric unit along a given area, which takes in account the sensitivity of human eye to different wavelenghts. It is the measure of light at a specific distance within a specific area at that distance. Often used to measure the incidental sun’s intensity. Its default unit describes the number of lumens visible in a square meter (lumen/m2). 100 lumens spread out over an area of 1 m2 will have an illuminance of 100 lx. The same 100 lumens spread out over 10 m2 produces a dimmer illuminance of only 10 lx.

 

The core difference between lux and lumens can be summarized as follows:

• Lux is a measure of illuminance, the total amount of light that falls on a surface at a given distance
  
• Lumens is a measure of luminous flux, the total amount of light emitted in all directions.

 

A footcandle describes the number of lumen per square foot. Therefore, one footcandle is equal to approximately 10.764 lx. This measure is only relevant for how we perceive light and is irrelevant for plant growth. Like lumens, lux and footcandles are not useful for describing horticultural lighting.

 

Color Rendering Index, or CRI, describes the ability of a light source to show an object’s color accurately in comparison to standardized colour samples under a reference light source. The highest value a light can achieve is a CRI of 100. Lower CRI values result in objects appearing unnatural or discolored. Under a light with a CRI of 100, an orange appears bright orange; under a light with a CRI of 70, the orange appears darker and bluer. This measure is dependent on how the human eye sees light, and so it is not a useful parameter for choosing horticultural lighting.

 

Correlated Color Temperature, or CCT, describes the color of a light source vs. a reference source when heated to a particular temperature, and is measured in degrees Kelvin (°K). The higher the CCT of a light source, the cooler the light’s color. For example, a very red light achieves a CCT of about 1000 K while a very blue light can achieve a CCT of about 10,000 K. Warm white lights will have a CCT around 2700 K (since they emit more energy at the red end of the spectrum), neutral white will be around 4000 K, and cool white around 5000 K (emitting more energy at the blue end of the spectrum). Similar to CRI, this measure is dependent on light perception by the human eye, and, once again, is not useful for describing or choosing horticultural lighting.

 

http://www.lumis.co.nz/reference-information/lighting-terminology

Light is a visible portion of electromagnetic radiation. Watts isn’t a measure of light output. Watts is actually a measure of total power output. Not all of the energy emitted by a light source is visible light – heat and invisible light waves (ex. infrared light) are also emitted. Lumens, on the other hand, will tell you the total visible light output of a source. For this reason, lumens (not watts) is the relevant unit of measure when you’re concerned about visibility. The higher the power the more rays emitted from the source in a unit of time.

 

Irradiance (radiant flux emitted by a surface per unit area aka watt per square meter) is a radiometric unit. As such also actually a measure of total power output.
Radiometric units are based on physical power, that means all wavelengths are weighted equally, while photometric units take into account the sensitivity of human eye to different wavelengths.
The weighting is determined by the luminosity function (which was measured for human eye and is an agreed-upon standard).

 

Converting Irradiance and Illuminance
http://www.dfisica.ubi.pt/~hgil/Fotometria/HandBook/ch07.html
There is a different conversion factor for every wavelength, so the spectral composition of light must be known to make the conversion.

At the most sensitive wavelegth to the human eye the conversion factor is

1.0 W/m2 = 683.002 lumen/m2 # at wavelength = 555nm (green)

That means the irradiance (power) to make 1 lumen is at it’s minimum at this wavelength (just 1.464 mW/m2).
Luminous efficiency is then the ratio between the actual number of lumens per watt and the theoretical maximum.
Incandescent light bulb has a luminous efficiency of 2% which is very poor. It’s because lot of it’s irradiance is only heat which is not visible. The luminosity function is zero for wavelengths outside the visible spectrum.

 

 

 

https://www.rapidtables.com/calc/light/lux-to-lumen-calculator.html

 

https://www.projectorpoint.co.uk/news/how-bright-should-my-projector-be/

 

https://dracobroadcast.eu/blogs/news/continuous-light-converting-guide

 

• Watts (halogen) – A measure of energy consumed
• Watts (HMI) – A measure of energy consumed
• Watts (LED) – A measure of energy consumed
• Lux – Lumens per square meter, illuminance at target
• Footcandles – Lumens per square foot
• Stops – Size of lens aperture
• EV – Exposure Value
• Lumens – Measure of amount of visible light, luminance from source
• Candela – Measure of entire volume of lighting
• NIT = Candela per square meter but is not part of the International System of Units

Photo editing
skylum.com/luminar

 

Photo editing
photolemur.com/

 

Photo editing
https://skylum.com/aurorahdr

 

Noise reduction
https://skylum.com/noiseless

 

Noise reduction
https://www.picturecode.com/showcase/noise.php

 

Noise reduction
https://topazlabs.com/denoise-ai/

 

Noise reduction
https://ni.neatvideo.com/examples#kingfisher

 

Color picker/editor
www.ricoholmes.com/cc-hover-color-picker.html

 

Texturing
digitalanarchy.com/demos/textureanarchy.html

 

Photo enhancer
cc-extensions.com/products/alce/

 

Photo sharpner
https://topazlabs.com/sharpen-ai/

 

Custom guides
guideguide.me/

 

Photo editor
www.on1.com/products/effects/

 

Image scaler
exposure.software/blowup/

 

Particle support
www.painterartist.com/en/product/particleshop/

 

Edge enhancer
fixelalgorithms.co/products/edgehancer3/

 

Jpeg to Raw
https://topazlabs.com/jpeg-to-raw-ai/

 

Animation editor
https://exchange.adobe.com/creativecloud.details.100950.powtoon-extension-for-photoshop.html

 

Best free Actions collection
https://blog.spoongraphics.co.uk/freebies/12-free-cinematic-photo-effect-actions-adobe-photoshop

 

Add-ons collection
https://www.the-orange-box.com/photoshop-add-ons/

Building a Portable PBR Texture Scanner by Stephane Lb
http://rtgfx.com/pbr-texture-scanner/

 

 

How To Split Specular And Diffuse In Real Images, by John Hable
http://filmicworlds.com/blog/how-to-split-specular-and-diffuse-in-real-images/

 

Capturing albedo using a Spectralon
https://www.activision.com/cdn/research/Real_World_Measurements_for_Call_of_Duty_Advanced_Warfare.pdf

Real_World_Measurements_for_Call_of_Duty_Advanced_Warfare.pdf

Spectralon is a teflon-based pressed powderthat comes closest to being a pure Lambertian diffuse material that reflects 100% of all light. If we take an HDR photograph of the Spectralon alongside the material to be measured, we can derive thediffuse albedo of that material.

 

The process to capture diffuse reflectance is very similar to the one outlined by Hable.

 

1. We put a linear polarizing filter in front of the camera lens and a second linear polarizing filterin front of a modeling light or a flash such that the two filters are oriented perpendicular to eachother, i.e. cross polarized.

 

2. We place Spectralon close to and parallel with the material we are capturing and take brack-eted shots of the setup7. Typically, we’ll take nine photographs, from -4EV to +4EV in 1EVincrements.

 

3. We convert the bracketed shots to a linear HDR image. We found that many HDR packagesdo not produce an HDR image in which the pixel values are linear. PTGui is an example of apackage which does generate a linear HDR image. At this point, because of the cross polarization,the image is one of surface diffuse response.

 

4. We open the file in Photoshop and normalize the image by color picking the Spectralon, filling anew layer with that color and setting that layer to “Divide”. This sets the Spectralon to 1 in theimage. All other color values are relative to this so we can consider them as diffuse albedo.

https://www.hdrsoft.com/resources/dri.html#bit-depth

 

The dynamic range is a ratio between the maximum and minimum values of a physical measurement. Its definition depends on what the dynamic range refers to.

For a scene: Dynamic range is the ratio between the brightest and darkest parts of the scene.

For a camera: Dynamic range is the ratio of saturation to noise. More specifically, the ratio of the intensity that just saturates the camera to the intensity that just lifts the camera response one standard deviation above camera noise.

For a display: Dynamic range is the ratio between the maximum and minimum intensities emitted from the screen.

 

The Dynamic Range of real-world scenes can be quite high — ratios of 100,000:1 are common in the natural world. An HDR (High Dynamic Range) image stores pixel values that span the whole tonal range of real-world scenes. Therefore, an HDR image is encoded in a format that allows the largest range of values, e.g. floating-point values stored with 32 bits per color channel. Another characteristics of an HDR image is that it stores linear values. This means that the value of a pixel from an HDR image is proportional to the amount of light measured by the camera.

 

For TVs HDR is great, but it’s not the only new TV feature worth discussing.

 

Wide color gamut, or WCG, is often lumped in with HDR. While they’re often found together, they’re not intrinsically linked. Where HDR is an increase in the dynamic range of the picture (with contrast and brighter highlights in particular), a TV’s wide color gamut coverage refers to how much of the new, larger color gamuts a TV can display.

 

Wide color gamuts only really matter for HDR video sources like UHD Blu-rays and some streaming video, as only HDR sources are meant to take advantage of the ability to display more colors.

 

 

www.cnet.com/how-to/what-is-wide-color-gamut-wcg/

 

Color depth is only one aspect of color representation, expressing the precision with which the amount of each primary can be expressed through a pixel; the other aspect is how broad a range of colors can be expressed (the gamut)

 

Image rendering bit depth

 

Wide color gamuts include a greater number of colors than what most current TVs can display, so the greater a TV’s coverage of a wide color gamut, the more colors a TV will be able to reproduce.

 

When we talk about a color space or color gamut we refer to the range of color values stored in an image. The perception of these color also requires a display that has been tuned with to resolve these color profiles at best. This is often referred to as a ‘viewer lut’.

 

So this comes also usually paired with an increase in bit depth, going from the old 8 bit system (256 shades per color, with the potential of over 16.7 million colors: 256 green x 256 blue x 256 red) to 10  (1024+ shades per color, with access to over a billion colors) or higher bits, like 12 bit (4096 shades per RGB for 68 billion colors).

The advantage of higher bit depth is in the ability to bias color with the minimum loss.

https://photo.stackexchange.com/questions/72116/whats-the-point-of-capturing-14-bit-images-and-editing-on-8-bit-monitors

 

For an extreme example, raising the brightness from a completely dark image allows for better reproduction, independently on the reproduction medium, due to the amount of data available at editing time:

 

https://www.cambridgeincolour.com/tutorials/dynamic-range.htm

 

https://www.hdrsoft.com/resources/dri.html#bit-depth

 

Note that the number of bits itself may be a misleading indication of the real dynamic range that the image reproduces — converting a Low Dynamic Range image to a higher bit depth does not change its dynamic range, of course.

• 8-bit images (i.e. 24 bits per pixel for a color image) are considered Low Dynamic Range.
• 16-bit images (i.e. 48 bits per pixel for a color image) resulting from RAW conversion are still considered Low Dynamic Range, even though the range of values they can encode is significantly higher than for 8-bit images (65536 versus 256). Note that converting a RAW file involves applying a tonal curve that compresses the dynamic range of the RAW data so that the converted image shows correctly on low dynamic range monitors. The need to adapt the output image file to the dynamic range of the display is the factor that dictates how much the dynamic range is compressed, not the output bit-depth. By using 16 instead of 8 bits, you will gain precision but you will not gain dynamic range.
• 32-bit images (i.e. 96 bits per pixel for a color image) are considered High Dynamic Range.Unlike 8- and 16-bit images which can take a finite number of values, 32-bit images are coded using floating point numbers, which means the values they can take is unlimited.It is important to note, though, that storing an image in a 32-bit HDR format is a necessary condition for an HDR image but not a sufficient one. When an image comes from a single capture with a standard camera, it will remain a Low Dynamic Range image,

 

 

Also note that bit depth and dynamic range are often confused as one, but are indeed separate concepts and there is no direct one to one relationship between them. Bit depth is about capacity, dynamic range is about the actual ratio of data stored.
The bit depth of a capturing or displaying device gives you an indication of its dynamic range capacity. That is, the highest dynamic range that the device would be capable of reproducing if all other constraints are eliminated.

 

https://rawpedia.rawtherapee.com/Bit_Depth

 

Finally, note that there are two ways to “count” bits for an image — either the number of bits per color channel (BPC) or the number of bits per pixel (BPP). A bit (0,1) is the smallest unit of data stored in a computer.

For a grayscale image, 8-bit means that each pixel can be one of 256 levels of gray (256 is 2 to the power 8).

For an RGB color image, 8-bit means that each one of the three color channels can be one of 256 levels of color.
Since each pixel is represented by 3 colors in this case, 8-bit per color channel actually means 24-bit per pixel.

Similarly, 16-bit for an RGB image means 65,536 levels per color channel and 48-bit per pixel.

To complicate matters, when an image is classified as 16-bit, it just means that it can store a maximum 65,535 values. It does not necessarily mean that it actually spans that range. If the camera sensors can not capture more than 12 bits of tonal values, the actual bit depth of the image will be at best 12-bit and probably less because of noise.

The following table attempts to summarize the above for the case of an RGB color image.

 

 

Type of digital support	Bit depth per color channel	Bit depth per pixel	FStops	Theoretical maximum Dynamic Range	Reality
8-bit	8	24	8	256:1	most consumer images
12-bit CCD	12	36	12	4,096:1	real maximum limited by noise
14-bit CCD	14	42	14	16,384:1	real maximum limited by noise
16-bit TIFF (integer)	16	48	16	65,536:1	bit-depth in this case is not directly related to the dynamic range captured
16-bit float EXR	16	48	30	65,536:1	values are distributed more closely in the (lower) darker tones than in the (higher) lighter ones, thus allowing for a more accurate description of the tones more significant to humans. The range of normalized 16-bit floats can represent thirty stops of information with 1024 steps per stop. We have eighteen and a half stops over middle gray, and eleven and a half below. The denormalized numbers provide an additional ten stops with decreasing precision per stop. http://download.nvidia.com/developer/GPU_Gems/CD_Image/Image_Processing/OpenEXR/OpenEXR-1.0.6/doc/#recs
HDR image (e.g. Radiance format)	32	96	“infinite”	4.3 billion:1	real maximum limited by the captured dynamic range

32-bit floats are often called “single-precision” floats, and 64-bit floats are often called “double-precision” floats. 16-bit floats therefore are called “half-precision” floats, or just “half floats”.

 

https://petapixel.com/2018/09/19/8-12-14-vs-16-bit-depth-what-do-you-really-need/

On a separate note, even Photoshop does not handle 16bit per channel. Photoshop does actually use 16-bits per channel. However, it treats the 16th digit differently – it is simply added to the value created from the first 15-digits. This is sometimes called 15+1 bits. This means that instead of 216 possible values (which would be 65,536 possible values) there are only 215+1 possible values (which is 32,768 +1 = 32,769 possible values).

 

Rec-601 (for the older SDTV format, very similar to rec-709) and Rec-709 (the HDTV’s recommended set of color standards, at times also referred to sRGB, although not exactly the same) are currently the most spread color formats and hardware configurations in the world.

 

Following those you can find the larger P3 gamut, more commonly used in theaters and in digital production houses (with small variations and improvements to color coverage), as well as most of best 4K/WCG TVs.

 

And a new standard is now promoted against P3, referred to Rec-2020 and UHDTV.

 

It is still debatable if this is going to be adopted at consumer level beyond the P3, mainly due to lack of hardware supporting it. But initial tests do prove that it would be a future proof investment.

www.colour-science.org/anders-langlands/

 

Rec. 2020 is ultimately designed for television, and not cinema. Therefore, it is to be expected that its properties must behave according to current signal processing standards. In this respect, its foundation is based on current HD and SD video signal characteristics.

 

As far as color bit depth is concerned, it allows for a maximum of 12 bits, which is more than enough for humans.

Comparing standards, REC-709 covers 35.9% of the human visible spectrum. P3 45.5%. And REC-2020 75.8%.
https://www.avsforum.com/forum/166-lcd-flat-panel-displays/2812161-what-color-volume.html

 

Comparing coverage to hardware devices

 

To note that all the new standards generally score very high on the Pointer’s Gamut chart. But with REC-2020 scoring 99.9% vs P3 at 88.2%.
www.tftcentral.co.uk/articles/pointers_gamut.htm

https://www.slideshare.net/hpduiker/acescg-a-common-color-encoding-for-visual-effects-applications

 

The Pointer’s gamut is (an approximation of) the gamut of real surface colors as can be seen by the human eye, based on the research by Michael R. Pointer (1980). What this means is that every color that can be reflected by the surface of an object of any material is inside the Pointer’s gamut. Basically establishing a widely respected target for color reproduction. Visually, Pointers Gamut represents the colors we see about us in the natural world. Colors outside Pointers Gamut include those that do not occur naturally, such as neon lights and computer-generated colors possible in animation. Which would partially be accounted for with the new gamuts.

cinepedia.com/picture/color-gamut/

 

Not all current TVs can support the full spread of the new gamuts. Here is a list of modern TVs’ color coverage in percentage:
www.rtings.com/tv/tests/picture-quality/wide-color-gamut-rec-709-dci-p3-rec-2020

 

There are no TVs that can come close to displaying all the colors within Rec.2020, and there likely won’t be for at least a few years. However, to help future-proof the technology, Rec.2020 support is already baked into the HDR spec. That means that the same genuine HDR media that fills the DCI P3 space on a compatible TV now, will in a few years also fill Rec.2020 on a TV supporting that larger space.

 

Rec.2020’s main gains are in the number of new tones of green that it will display, though it also offers improvements to the number of blue and red colors as well. Altogether, Rec.2020 will cover about 75% of the visual spectrum, which is a sizeable increase in coverage even over DCI P3.

 

 

Dolby Vision

https://www.highdefdigest.com/news/show/what-is-dolby-vision/39049

https://www.techhive.com/article/3237232/dolby-vision-vs-hdr10-which-is-best.html

 

Dolby Vision is a proprietary end-to-end High Dynamic Range (HDR) format that covers content creation and playback through select cinemas, Ultra HD displays, and 4K titles. Like other HDR standards, the process uses expanded brightness to improve contrast between dark and light aspects of an image, bringing out deeper black levels and more realistic details in specular highlights — like the sun reflecting off of an ocean — in specially graded Dolby Vision material.

 

The iPhone 12 Pro gets the ability to record 4K 10-bit HDR video. According to Apple, it is the very first smartphone that is capable of capturing Dolby Vision HDR.

The iPhone 12 Pro takes two separate exposures and runs them through Apple’s custom image signal processor to create a histogram, which is a graph of the tonal values in each frame. The Dolby Vision metadata is then generated based on that histogram. In Laymen’s terms, it is essentially doing real-time grading while you are shooting. This is only possible due to the A14 Bionic chip.

 

Dolby Vision also allows for 12-bit color, as opposed to HDR10’s and HDR10+’s 10-bit color. While no retail TV we’re aware of supports 12-bit color, Dolby claims it can be down-sampled in such a way as to render 10-bit color more accurately.

 

 

 

 

 

Resources for more reading:

https://www.avsforum.com/forum/166-lcd-flat-panel-displays/2812161-what-color-volume.html

 

wolfcrow.com/say-hello-to-rec-2020-the-color-space-of-the-future/

 

www.cnet.com/news/ultra-hd-tv-color-part-ii-the-future/

 

 

Supported by LG, Philips, Panasonic and Sony sell the OLED system TVs.
OLED stands for “organic light emitting diode.”
It is a fundamentally different technology from LCD, the major type of TV today.
OLED is “emissive,” meaning the pixels emit their own light.

 

Samsung is branding its best TVs with a new acronym: “QLED”
QLED (according to Samsung) stands for “quantum dot LED TV.”
It is a variation of the common LED LCD, adding a quantum dot film to the LCD “sandwich.”
QLED, like LCD, is, in its current form, “transmissive” and relies on an LED backlight.

 

OLED is the only technology capable of absolute blacks and extremely bright whites on a per-pixel basis. LCD definitely can’t do that, and even the vaunted, beloved, dearly departed plasma couldn’t do absolute blacks.

QLED, as an improvement over OLED, significantly improves the picture quality. QLED can produce an even wider range of colors than OLED, which says something about this new tech. QLED is also known to produce up to 40% higher luminance efficiency than OLED technology. Further, many tests conclude that QLED is far more efficient in terms of power consumption than its predecessor, OLED.

 

When analyzing TVs color, it may be beneficial to consider at least 3 elements:
“Color Depth”, “Color Gamut”, and “Dynamic Range”.

 

Color Depth (or “Bit-Depth”, e.g. 8-bit, 10-bit, 12-bit) determines how many distinct color variations (tones/shades) can be viewed on a given display.

 

Color Gamut (e.g. WCG) determines which specific colors can be displayed from a given “Color Space” (Rec.709, Rec.2020, DCI-P3) (i.e. the color range).

 

Dynamic Range (SDR, HDR) determines the luminosity range of a specific color – from its darkest shade (or tone) to its brightest.

 

The overall brightness range of a color will be determined by a display’s “contrast ratio”, that is, the ratio of luminance between the darkest black that can be produced and the brightest white.

 

Color Volume is the “Color Gamut” + the “Dynamic/Luminosity Range”.
A TV’s Color Volume will not only determine which specific colors can be displayed (the color range) but also that color’s luminosity range, which will have an affect on its “brightness”, and “colorfulness” (intensity and saturation).

 

The better the colour volume in a TV, the closer to life the colours appear.

 

QLED TV can express nearly all of the colours in the DCI-P3 colour space, and of those colours, express 100% of the colour volume, thereby producing an incredible range of colours.

 

With OLED TV, when the image is too bright, the percentage of the colours in the colour volume produced by the TV drops significantly. The colours get washed out and can only express around 70% colour volume, making the picture quality drop too.

 

Note. OLED TV uses organic material, so it may lose colour expression as it ages.

 

Resources for more reading and comparison below

www.avsforum.com/forum/166-lcd-flat-panel-displays/2812161-what-color-volume.html

 

www.newtechnologytv.com/qled-vs-oled/

 

news.samsung.com/za/qled-tv-vs-oled-tv

 

www.cnet.com/news/qled-vs-oled-samsungs-tv-tech-and-lgs-tv-tech-are-not-the-same/

 

http://gamedev.stackexchange.com/questions/60638/what-is-physically-correct-lighting-all-about

 

2012-08 Nathan Reed wrote:

Physically-based shading means leaving behind phenomenological models, like the Phong shading model, which are simply built to “look good” subjectively without being based on physics in any real way, and moving to lighting and shading models that are derived from the laws of physics and/or from actual measurements of the real world, and rigorously obey physical constraints such as energy conservation.

 

For example, in many older rendering systems, shading models included separate controls for specular highlights from point lights and reflection of the environment via a cubemap. You could create a shader with the specular and the reflection set to wildly different values, even though those are both instances of the same physical process. In addition, you could set the specular to any arbitrary brightness, even if it would cause the surface to reflect more energy than it actually received.

 

In a physically-based system, both the point light specular and the environment reflection would be controlled by the same parameter, and the system would be set up to automatically adjust the brightness of both the specular and diffuse components to maintain overall energy conservation. Moreover you would want to set the specular brightness to a realistic value for the material you’re trying to simulate, based on measurements.

 

Physically-based lighting or shading includes physically-based BRDFs, which are usually based on microfacet theory, and physically correct light transport, which is based on the rendering equation (although heavily approximated in the case of real-time games).

 

It also includes the necessary changes in the art process to make use of these features. Switching to a physically-based system can cause some upsets for artists. First of all it requires full HDR lighting with a realistic level of brightness for light sources, the sky, etc. and this can take some getting used to for the lighting artists. It also requires texture/material artists to do some things differently (particularly for specular), and they can be frustrated by the apparent loss of control (e.g. locking together the specular highlight and environment reflection as mentioned above; artists will complain about this). They will need some time and guidance to adapt to the physically-based system.

 

On the plus side, once artists have adapted and gained trust in the physically-based system, they usually end up liking it better, because there are fewer parameters overall (less work for them to tweak). Also, materials created in one lighting environment generally look fine in other lighting environments too. This is unlike more ad-hoc models, where a set of material parameters might look good during daytime, but it comes out ridiculously glowy at night, or something like that.

 

Here are some resources to look at for physically-based lighting in games:

 

SIGGRAPH 2013 Physically Based Shading Course, particularly the background talk by Naty Hoffman at the beginning. You can also check out the previous incarnations of this course for more resources.

 

Sébastien Lagarde, Adopting a physically-based shading model and Feeding a physically-based shading model

 

And of course, I would be remiss if I didn’t mention Physically-Based Rendering by Pharr and Humphreys, an amazing reference on this whole subject and well worth your time, although it focuses on offline rather than real-time rendering.

http://www.xdcam-user.com/2014/05/what-is-a-gamut-or-color-space-and-why-do-i-need-to-know-about-it/

 

In video terms gamut is normally related to as the full range of colours and brightness that can be either captured or displayed.

 

Generally speaking all color gamuts recommendations are trying to define a reasonable level of color representation based on available technology and hardware. REC-601 represents the old TVs. REC-709 is currently the most distributed solution. P3 is mainly available in movie theaters and is now being adopted in some of the best new 4K HDR TVs. Rec2020 (a wider space than P3 that improves on visibke color representation) and ACES (the full coverage of visible color) are other common standards which see major hardware development these days.

 

 

To compare and visualize different solution (across video and printing solutions), most developers use the CIE color model chart as a reference.
The CIE color model is a color space model created by the International Commission on Illumination known as the Commission Internationale de l’Elcairage (CIE) in 1931. It is also known as the CIE XYZ color space or the CIE 1931 XYZ color space.
This chart represents the first defined quantitative link between distributions of wavelengths in the electromagnetic visible spectrum, and physiologically perceived colors in human color vision. Or basically, the range of color a typical human eye can perceive through visible light.

 

Note that while the human perception is quite wide, and generally speaking biased towards greens (we are apes after all), the amount of colors available through nature, generated through light reflection, tend to be a much smaller section. This is defined by the Pointer’s Chart.

 

In short. Color gamut is a representation of color coverage, used to describe data stored in images against available hardware and viewer technologies.

 

Camera color encoding from
https://www.slideshare.net/hpduiker/acescg-a-common-color-encoding-for-visual-effects-applications

 

CIE 1976

http://bernardsmith.eu/computatrum/scan_and_restore_archive_and_print/scanning/

 

https://store.yujiintl.com/blogs/high-cri-led/understanding-cie1931-and-cie-1976

 

The CIE 1931 standard has been replaced by a CIE 1976 standard. Below we can see the significance of this.

 

People have observed that the biggest issue with CIE 1931 is the lack of uniformity with chromaticity, the three dimension color space in rectangular coordinates is not visually uniformed.

 

The CIE 1976 (also called CIELUV) was created by the CIE in 1976. It was put forward in an attempt to provide a more uniform color spacing than CIE 1931 for colors at approximately the same luminance

 

The CIE 1976 standard colour space is more linear and variations in perceived colour between different people has also been reduced. The disproportionately large green-turquoise area in CIE 1931, which cannot be generated with existing computer screens, has been reduced.

 

If we move from CIE 1931 to the CIE 1976 standard colour space we can see that the improvements made in the gamut for the “new” iPad screen (as compared to the “old” iPad 2) are more evident in the CIE 1976 colour space than in the CIE 1931 colour space, particularly in the blues from aqua to deep blue.

 

 

https://dot-color.com/2012/08/14/color-space-confusion/

Despite its age, CIE 1931, named for the year of its adoption, remains a well-worn and familiar shorthand throughout the display industry. CIE 1931 is the primary language of customers. When a customer says that their current display “can do 72% of NTSC,” they implicitly mean 72% of NTSC 1953 color gamut as mapped against CIE 1931.