If – Rudyard Kipling
If you can keep your head when all about you
Are losing theirs and blaming it on you,
If you can trust yourself when all men doubt you,
But make allowance for their doubting too;
If you can wait and not be tired by waiting,
Or being lied about, don’t deal in lies,
Or being hated, don’t give way to hating,
And yet don’t look too good, nor talk too wise:
If you can dream—and not make dreams your master;
If you can think—and not make thoughts your aim;
If you can meet with Triumph and Disaster
And treat those two impostors just the same;
If you can bear to hear the truth you’ve spoken
Twisted by knaves to make a trap for fools,
Or watch the things you gave your life to, broken,
And stoop and build ’em up with worn-out tools:
If you can make one heap of all your winnings
And risk it on one turn of pitch-and-toss,
And lose, and start again at your beginnings
And never breathe a word about your loss;
If you can force your heart and nerve and sinew
To serve your turn long after they are gone,
And so hold on when there is nothing in you
Except the Will which says to them: ‘Hold on!’
If you can talk with crowds and keep your virtue,
Or walk with Kings—nor lose the common touch,
If neither foes nor loving friends can hurt you,
If all men count with you, but none too much;
If you can fill the unforgiving minute
With sixty seconds’ worth of distance run,
Yours is the Earth and everything that’s in it,
And—which is more—you’ll be a man, my son
WebAR tutorial
With Unity
7 Easy Portrait Lighting Setups
Butterfly
Loop
Rembrandt
Split
Rim
Broad
Short
Schofield’s Laws of Computing
https://www.freecodecamp.org/news/schofields-laws-of-computing/
“Never put data into a program unless you can see exactly how to get it out.” ― Jack Schofield (2003)
“Data doesn’t really exist unless you have at least two copies of it.” ― Jack Schofield (2008)
“The easier it is for you to access your data, the easier it is for someone else to access your data.” ― Jack Schofield (2008)
Advanced Computer Vision with Python OpenCV and Mediapipe
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:
- 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.
- 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.
- 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.
- Camera Calibration:
- Intrinsic and Extrinsic Calibration: Python and OpenCV can help calibrate cameras for accurate 3D scene reconstruction and camera tracking.
- 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.
- Green Screen and Blue Screen Keying:
- Chroma Keying: Implement advanced keying algorithms using OpenCV to seamlessly integrate actors and objects into virtual environments.
- Particle and Fluid Simulations:
- Particle Tracking: Utilize OpenCV to track and manipulate particles in fluid simulations for more realistic visual effects.
- 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.
- Virtual Set Extension:
- Camera Projection: Use camera calibration techniques to project virtual environments onto physical sets, extending the visual scope of a scene.
- Color Grading:
- Color Correction: Implement custom color grading algorithms to match the color tones and moods of different shots.
- 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.
- 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.
- Automating Repetitive Tasks:
- Batch Processing: Automate repetitive tasks like resizing images, applying filters, or converting file formats across multiple shots.
- 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.
- Pipeline Integration:
- Custom Tools: Develop Python scripts and tools to integrate OpenCV-based processes seamlessly into the studio’s pipeline.
- Real-time Visualization:
- Live Previsualization: Implement real-time OpenCV-based visualizations to aid decision-making during the preproduction stage.
- VR and AR Integration:
- Augmented Reality: Use Python and OpenCV to integrate virtual elements into real-world footage, creating compelling AR experiences.
- 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.
How to Build a Hackintosh
https://www.freecodecamp.org/news/build-a-hackintosh/
A Hackintosh is a non-Mac computer system, made with PC parts, that runs the macOS operating system.
Basic GafferHQ python introduction
Working with the Python Scripting API
http://www.gafferhq.org/documentation/1.0.2.0/WorkingWithThePythonScriptingAPI/index.html
Node Graph editing in Python
https://www.gafferhq.org/documentation/1.0.0.0/WorkingWithThePythonScriptingAPI/TutorialNodeGraphEditingInPython/index.html
Common operations
https://www.gafferhq.org/documentation/1.0.0.0/Reference/ScriptingReference/CommonOperations/index.html
Scripting box nodes
https://blog.gafferhq.org/?p=278
Dev and pipe tips
https://blog.gafferhq.org/?cat=35
import GafferScene
import Gaffer
# return a list of selections
# (nodes HAVE TO BE selected for the following)
sel = root.selection() # gaffer standard set
list(sel)
sel[0].typeName()
dir( sel[0] )
sel[0].getName()
sel.clear()
root.removeChild( sel[0] )
# store the selected nodes in a variable
>>> sel = root.selection()
>>> myGroup = sel[0]
>>> light = sel[1]
# set location name
myGroup['name'].setValue('groupLocation')
light['name'].setValue('photometricLightLocation')
# connect a node to a group
>>> myGroup['in'][0].setInput( light['out'] )
# return the node/port attached to a group port
>>> myGroup['in'][0].childNames('/')
photometricLightLocation
>>> myGroup['in'][0].getInput().fullName()
>>> myGroup['in'][0].source().fullName()
gui.scripts.ScriptNode.lighting_in1.PhotometricLightNode.out
# return the full name of one of the objects
# attached to the out port
>>> light['out'].outputs()[0].fullName()
gui.scripts.ScriptNode.lighting_in1.GroupNode.in.in0
>>> light
GafferArnold.ArnoldLight( "PhotometricLightNode" )
>>> light['out'].childNames('')
photometricLightLocation
>>> light['out'].outputs()[0].node()
GafferScene.Group( "Group" )
