- 
        
            
        
        
            
                Add
            
         Adds two images together. 
- 
        
            
        
        
            
                Anaglyph
            
         Creates an anaglyph from a pair of input images. 
- 
        
            
        
        
            
                Atop
            
         Composites the first input (Foreground) over the second (background),
but only where the background alpha exists. 
- 
        
            
        
        
            
                Average
            
         Averages the foreground image and the background image. 
- 
        
            
        
        
            
                Blend
            
         Blends frames from two sequences together using a simple linear
blend. 
- 
        
            
        
        
            
                Blur
            
         Blurs an image. 
- 
        
            
        
        
            
                Border
            
         Adds a border to the image. 
- 
        
            
        
        
            
                Bright
            
         Applies a brightness factor and bright shift to the first input. 
- 
        
            
        
        
            
                Bump
            
         Builds a bump map from a plane. 
- 
        
        
            
                COP generators
            
         
- 
        
            
        
        
            
                Channel Copy
            
         Copy channels from any of inputs into the output image. 
- 
        
            
        
        
            
                Chromakey
            
         Mask or key an image based on its color. 
- 
        
            
        
        
            
                Color
            
         Creates a constant color image. 
- 
        
            
        
        
            
                Color Correct
            
         Applies a variety of color corrections to the image 
- 
        
            
        
        
            
                Color Curve
            
         Adjusts the R,G,B and/or A channels based on a user-defined
curve. 
- 
        
            
        
        
            
                Color Map
            
         Maps a range of color to a new range. 
- 
        
            
        
        
            
                Color Replace
            
         Replace a color region in an image with another region. 
- 
        
            
        
        
            
                Color Wheel
            
         Generates a simple HSV color wheel. 
- 
        
            
        
        
            
                Composite
            
         Does a composite (over, under, inside, add, etc) between two
images. 
- 
        
            
        
        
            
                Contrast
            
         Increases or decreases the contrast of an image. 
- 
        
            
        
        
            
                Convert
            
         Changes the data format of a plane. 
- 
        
            
        
        
            
                Convolve
            
         Performs a generic convolve on the source image. 
- 
        
            
        
        
            
                Corner Pin
            
         Fits an image into an arbitrary quadrilateral. 
- 
        
            
        
        
            
                Corner Ramp
            
         Generates a four corner ramp. 
- 
        
            
        
        
            
                Crop
            
         Crops an image and changes its resolution. 
- 
        
            
        
        
            
                Cryptomatte
            
         Extracts matte from Cryptomatte image. 
- 
        
            
        
        
            
                DSM Flatten
            
         Flattens a Deep Shadow/Camera Map into a flat 2D raster. 
- 
        
            
        
        
            
                Defocus
            
         Defocuses an image similar to a real camera defocus. 
- 
        
            
        
        
            
                Deform
            
         Deforms an image by moving the underlying UV coordinates. 
- 
        
            
        
        
            
                Degrain
            
         Removes film grain from an image. 
- 
        
            
        
        
            
                Deinterlace
            
         De-interlaces a frame of video by either averaging scanlines or
copying a scanline. 
- 
        
            
        
        
            
                Delete
            
         Removes planes or components from an input sequence. 
- 
        
            
        
        
            
                Denoise
            
         Removes white noise from an image. 
- 
        
            
        
        
            
                Denoise AI
            
         Uses machine-learning algorithms to denoise images with high quality and speed. 
- 
        
            
        
        
            
                Depth Darken
            
         Darkens depth boundaries in an image. 
- 
        
            
        
        
            
                Depth of Field
            
         Creates a depth-of-field mask, which describes how out of focus parts
of the image are. 
- 
        
            
        
        
            
                Diff
            
         Computes the difference between the foreground image and the
background image. 
- 
        
            
        
        
            
                Dilate/Erode
            
         Expands and shrinks mattes. 
- 
        
            
        
        
            
                Drop Shadow
            
         Creates a blurred shadow offset of an image. 
- 
        
            
        
        
            
                Edge Blur
            
         Blurs the edges of an image. 
- 
        
            
        
        
            
                Edge Detect
            
         Detects edges in the input image. 
- 
        
            
        
        
            
                Emboss
            
         Adds a lighting effect to the image by using a bump map. 
- 
        
            
        
        
            
                Environment
            
         Applies an environment map to an image. 
- 
        
            
        
        
            
                Equalize
            
         Equalizes colors by stretching or shifting the image histogram. 
- 
        
            
        
        
            
                Error Function Table Generator
            
         Creates an image containing precomputed error function terms for hair albedo computation 
- 
        
            
        
        
            
                Expand
            
         Expands and shrinks mattes. 
- 
        
            
        
        
            
                Extend
            
         Extends the length of a sequence so that it can be animated beyond
its frame range. 
- 
        
            
        
        
            
                Extract
            
         Extracts a plane or channel from a multi-plane source. 
- 
        
            
        
        
            
                Extrapolate Boundaries
            
         Fills empty areas of an image using the colors at the edges the non-empty areas. 
- 
        
            
        
        
            
                Fetch
            
         Fetches a sequence of images from another COP, even in another network. 
- 
        
            
        
        
            
                Field Merge
            
         Merges two fields into one Interlaced Frame. 
- 
        
            
        
        
            
                Field Split
            
         Splits an interlaced frame into two fields per frame (odd and even
fields). 
- 
        
            
        
        
            
                Field Swap
            
         Swaps the two fields containing the even and odd scanlines of the
frame. 
- 
        
            
        
        
            
                File
            
         Loads image files into Houdini. 
- 
        
            
        
        
            
                Flip
            
         Flips the image horizontally and/or vertically. 
- 
        
            
        
        
            
                Fog
            
         Adds a variety of atmospheric effects to an image, including fog,
haze and heat waves. 
- 
        
            
        
        
            
                Font
            
         Renders anti-aliased text. 
- 
        
            
        
        
            
                Front Face
            
         Cleans up flipped normals by making them face the camera.  
- 
        
            
        
        
            
                Function
            
         Performs a variety of mathematical functions on the input image. 
- 
        
            
        
        
            
                Gamma
            
         Applies gamma correction to the image. 
- 
        
            
        
        
            
                Geokey
            
         Keys out parts of the image based on pixel position or normal
direction. 
- 
        
            
        
        
            
                Geometry
            
         Renders geometry from a SOP as a single color image. 
- 
        
            
        
        
            
                Gradient
            
         Computes the gradient of an image. 
- 
        
            
        
        
            
                Grain
            
         Adds grain to an image. 
- 
        
            
        
        
            
                HSV
            
         Converts between RGB and HSV color spaces, or applies hue and saturation modifications. 
- 
        
            
        
        
            
                Hue Curve
            
         Adjusts the saturation or luminance of the image based on hue. 
- 
        
            
        
        
            
                Illegal Pixel
            
         Detects illegal pixels, like NAN and INF, in images. 
- 
        
            
        
        
            
                Inside
            
         Restricts the foreground color to the area of the background’s alpha
matte. 
- 
        
            
        
        
            
                Interleave
            
         Interleaves image sequences. 
- 
        
            
        
        
            
                Invert
            
         Applies a photographic pixel inversion to the image. 
- 
        
            
        
        
            
                Labs Attribute Import
            
          Imports geometry attributes as image planes using a UV attribute   
- 
        
            
        
        
            
                Labs Blackbody
            
          Generates a blackbody ramp, or colorizes a black and white image with a blackbody ramp  
- 
        
            
        
        
            
                Labs Demosaic
            
          Converts a single mosaic (flipbook/subuv) image into a sequence of sub images based on the frame  
- 
        
            
        
        
            
                Labs Grid Texture
            
          Generates a texture that can be used as a simple resolution checkerboard  
- 
        
            
        
        
            
                Labs Normal Color
            
          Simple Helper Node to generate the default Normal Color  
- 
        
            
        
        
            
                Labs Normal Combine
            
          A Simple Node That Overlays 2 Normal Maps together  
- 
        
            
        
        
            
                Labs Normal From Grayscale
            
          Convert a Grayscale Image Into a Normal Map   
- 
        
            
        
        
            
                Labs Normal Invert
            
          Invert individual channels on an image  
- 
        
        
            
                Labs Normal Levels
            
          Adjusts black point, white point, and midrange to increase, balance, or decrease contrast on a Normal Map.  
- 
        
            
        
        
            
                Labs Normal Rotate
            
          Rotates a Normal Map while correcting recalculating it’s internal vectors  
- 
        
        
            
                Labs Normalize Normal
            
          Ensures the normal map is balanced in a unit vector  
- 
        
            
        
        
            
                Labs Substance Archive
            
          Load Substance Archive (SBSAR) Files into COPs  
- 
        
            
        
        
            
                Layer
            
         Layers a series of inputs together by compositing them one by one on
the background image (input 1). 
- 
        
            
        
        
            
                Levels
            
         Adjusts black point, white point, and midrange to increase, balance,
or decrease contrast. 
- 
        
            
        
        
            
                Lighting
            
         Adds a light to the image. 
- 
        
            
        
        
            
                Limit
            
         Limits the pixel range at the high end, low end or both. 
- 
        
            
        
        
            
                Lookup
            
         Applies a lookup table to the input. 
- 
        
            
        
        
            
                Luma Matte
            
         Sets the alpha to the luminance of the color. 
- 
        
            
        
        
            
                Lumakey
            
         Keys the image based on luminance (or similar function). 
- 
        
            
        
        
            
                Mask
            
         Masks out an area of an image. 
- 
        
            
        
        
            
                Max
            
         Outputs the maximum value of the foreground and background images for
each pixel, which tends to lighten the image. 
- 
        
            
        
        
            
                Median
            
         Applies a 3 x 3 or 5 x 5 median filter to the input image. 
- 
        
            
        
        
            
                Merge
            
         Merges the planes of several inputs together. 
- 
        
            
        
        
            
                Metadata
            
         Applies metadata to an image sequence. 
- 
        
            
        
        
            
                Min
            
         Outputs the minimum value of the foreground and background images for
each pixel, which tends to darken the image. 
- 
        
            
        
        
            
                Mono
            
         Converts a color or vector into a scalar quantity, like luminance or length. 
- 
        
            
        
        
            
                Mosaic
            
         Takes a sequence of images and combines them into 1 image by tiling them. 
- 
        
            
        
        
            
                Multiply
            
         Multiplies the foreground image with the background image. 
- 
        
            
        
        
            
                Noise
            
         Generates continuous noise patterns. 
- 
        
            
        
        
            
                Null
            
         Does nothing. 
- 
        
            
        
        
            
                Outside
            
         Restricts the foreground color to the area outside of the background’s alpha matte. 
- 
        
            
        
        
            
                Over
            
         Composites the first input (Foreground) over the second
(background). 
- 
        
            
        
        
            
                Pixel
            
         Modifies an image’s pixels using expressions. 
- 
        
            
        
        
            
                Premultiply
            
         Allows colour to be converted to or from a premultiplied form. 
- 
        
            
        
        
            
                Pulldown
            
         Performs a pulldown (cine-expand) on the input sequence. 
- 
        
            
        
        
            
                Pushup
            
         Performs a pushup (cine-expand) on the input sequence. 
- 
        
            
        
        
            
                Quantize
            
         Quantizes input data into discrete steps. 
- 
        
            
        
        
            
                ROP File Output
            
         Renders frames out to disk. 
- 
        
            
        
        
            
                Radial Blur
            
         Does a radial or angular blur. 
- 
        
            
        
        
            
                Ramp
            
         Generates a variety of linear and radial ramps, which are fully
keyframable. 
- 
        
            
        
        
            
                Reference
            
         Copies the sequence information from its input. 
- 
        
            
        
        
            
                Rename
            
         Change the name a plane. 
- 
        
            
        
        
            
                Render
            
         Renders a mantra output driver directly into a composite network. 
- 
        
            
        
        
            
                Reverse
            
         Simply reverses the frames in the sequence. 
- 
        
            
        
        
            
                Rotoshape
            
         Draws one or more curves or shapes. 
- 
        
            
        
        
            
                SOP Import
            
         Imports a 2d Volume from SOPs as planes into a composite network. 
- 
        
            
        
        
            
                Scale
            
         Changes the resolution of the image. 
- 
        
            
        
        
            
                Screen
            
         Adds two images together, saturating at white like photographic
addition. 
- 
        
            
        
        
            
                Sequence
            
         Sequences two or more inputs end to end. 
- 
        
            
        
        
            
                Shape
            
         Generates simple shapes, such as circles, stars and regular N-sided
polygons. 
- 
        
            
        
        
            
                Sharpen
            
         Sharpens an image by enhancing the contrast of edges. 
- 
        
            
        
        
            
                Shift
            
         Shifts an image sequence in time. 
- 
        
            
        
        
            
                Shuffle
            
         Shuffle frames around to do out-of-order editing. 
- 
        
            
        
        
            
                Sky Environment Map
            
         Creates sky and ground images for use as environment maps. 
- 
        
            
        
        
            
                Snip
            
         Either removes frames from a sequence or allows you to order them in
a user-defined order. 
- 
        
            
        
        
            
                Streak Blur
            
         Streaks an image, adding a motion blur effect. 
- 
        
            
        
        
            
                Subnetwork
            
         Contains networks of other COPs. 
- 
        
            
        
        
            
                Subtract
            
         Subtracts the foreground image from the background image. 
- 
        
            
        
        
            
                Switch
            
         Passes the input of one of its connected inputs through, acting like
an exclusive switch. 
- 
        
            
        
        
            
                Switch Alpha
            
         Replaces input 1's alpha with input 2's alpha. 
- 
        
            
        
        
            
                Terrain Noise
            
         Generate noise suitable for terrain height maps. 
- 
        
            
        
        
            
                Tile
            
         Tiles the image sequence with multiple copies of the input image. 
- 
        
            
        
        
            
                Time Filter
            
         Blurs a pixel through several frames. 
- 
        
            
        
        
            
                Time Machine
            
         Uses a second input to time warp the first input on a per pixel
basis. 
- 
        
            
        
        
            
                Time Scale
            
         Stretches or compresses a sequence in time. 
- 
        
            
        
        
            
                Time Warp
            
         Warps time by slowing or speeding it up throughout the sequence. 
- 
        
            
        
        
            
                Transform
            
         Translates, rotates and/or scales the input image without changing
the image resolution. 
- 
        
            
        
        
            
                Trim
            
         Trims an input sequence in time by adjusting the beginning or the end
of the sequence. 
- 
        
            
        
        
            
                UV Map
            
         Creates a UV map. 
- 
        
            
        
        
            
                Under
            
         Composites the first input (Foreground) under the second
(background). 
- 
        
            
        
        
            
                Unpin
            
         Extracts an arbitrary quadrilateral area out of the input image. 
- 
        
            
        
        
            
                VEX Filter
            
         Runs a VEX script on its input planes. 
- 
        
            
        
        
            
                VEX Generator
            
         Runs a VEX script on the planes it generates. 
- 
        
            
        
        
            
                VOP COP2 Filter
            
         Contains a VOP network that filters input image data. 
- 
        
            
        
        
            
                VOP COP2 Generator
            
         Contains a VOP network that generates image data. 
- 
        
            
        
        
            
                Vector
            
         Performs vector operations on the input. 
- 
        
            
        
        
            
                Velocity Blur
            
         Blurs an image by using pixel velocity to produce a motion blur
effect. 
- 
        
            
        
        
            
                Window
            
         Cuts a small window out of a larger image. 
- 
        
            
        
        
            
                Wipe
            
         Does a wipe between two input sequences. 
- 
        
            
        
        
            
                Xor
            
         Makes two elements mutually exclusive; if their alpha mattes overlap,
the overlap is removed. 
- 
        
            
        
        
            
                Z Comp
            
         Does a Z composite of two images.