Image: Analysis, I/O & Utility#

Statistics, import / export, sequences, devices and wrangles.

28 nodes.

Back to the reference index

Contents#

• COP Bounding Rect (PCG) — Finds the bounding rectangle of a mask, or one rectangle per id, and writes it as a fill layer plus a JSON report.
• COP Compare (PCG) — Measures the difference between two images with MAE, RMSE, PSNR and SSIM and writes a diff layer and an SSIM map.
• COP Contact Sheet (PCG) — Arranges the frames of a sequence into a grid image, optionally labelled with frame numbers.
• COP Export (PCG) — Converts a COP layer to a ComfyUI IMAGE and MASK for previewing, saving or any node that takes an IMAGE.
• COP Flood Fill (PCG) — Selects the connected region around a seed whose values are close to the seed value and outputs it as a mask.
• COP HeightField Tile Splice (PCG) — Reassembles a sequence of tiles from Tile Split into one image, blending the overlap zones.
• COP HeightField Tile Split (PCG) — Cuts an image into a grid of overlapping tiles and outputs them as a sequence.
• COP Histogram Plot (PCG) — Draws a layer's histogram as an image and outputs the raw bucket counts.
• COP Illegal Pixel (PCG) — Finds NaN, infinite or rule-matching pixels and fixes, highlights or isolates them.
• COP Import (PCG) — Converts a ComfyUI IMAGE into a COP image so it can enter a COP chain.
• COP Info (PCG) — Reports the torch and CUDA environment and, if an image is connected, its resolution, layers and backend.
• COP Light (PCG) — Lights an image using tangent-space normals with a directional or point light.
• COP Prefix Sum (PCG) — Computes running sums of pixel values along U or V, or a 2D summed-area table.
• COP Segment by Connectivity (PCG) — Labels the connected regions of a mask with an integer ID layer.
• COP Segment By Value (PCG) — Assigns IDs to pixels by their value range, optionally splitting disconnected areas.
• COP Sequence Clips (PCG) — Joins ranges of one or more image sequences end to end into a new sequence.
• COP Sequence Ops (PCG) — Reverses, shifts, loops, retimes or blends image sequences.
• COP Statistics (PCG) — Computes per-layer, per-channel statistics and counts non-finite values.
• COP Time Pack (PCG) — Samples a sequence at several moments in time and packs the frames into one multi-layer image.
• COP To Device (PCG) — Moves an image to a chosen compute backend (NumPy, torch CPU, CUDA or exact float64).
• COP Vector Math (PCG) — Performs per-pixel vector operations such as dot, cross, length, normalize and arithmetic between layers or constants.
• COP Vector Transform (PCG) — Rotates, scales or re-bases the vectors stored in a layer (normals, velocities, directions).
• COP Visualize (PCG) — Renders a height layer through a color ramp (with hillshade and contours) or a velocity layer as hue, streaks or arrows.
• COP Wrangle (PCG) — Runs VEX-style per-pixel code on the whole image at once.
• COP Write File (PCG) — Writes image layers to disk as PNG, EXR or RAW files, with channel packing, remapping and terrain tiling.
• Sequence Export (PCG) — Converts a COP sequence into a ComfyUI IMAGE batch and a MASK batch, one entry per frame.
• Sequence Import (PCG) — Converts a ComfyUI IMAGE batch into a COP sequence, one frame per batch entry.
• Sequence Pick (PCG) — Picks one frame from a COP sequence by index, wrapping around out-of-range indices.

Nodes#

COP Bounding Rect (PCG)#

PCG_COPBoundingRect · category PCG/cop · Houdini: Bounding Rectangle (COP)

Finds the bounding rectangle of a mask, or one rectangle per id, and writes it as a fill layer plus a JSON report.

Takes the axis-aligned bounding box of all pixels where Layer is above Threshold. With Per ID on, Layer is read as an id image instead and every integer id above 0 gets its own rectangle. The rectangle is expanded by Padding pixels and clipped to the image.

The output layer Out Layer holds the filled rectangles: 1 inside the box, or the id value in Per ID mode. The rects output is a JSON list with one entry per box, containing id, pixels (x0, y0, x1, y1, inclusive, y pointing up) and uv (u0, v0, u1, v1, measured to pixel edges, not centres). Empty masks produce no box.

Inputs

Outputs

Parameters

COP Compare (PCG)#

PCG_COPCompare · category PCG/cop · Houdini: Error (COP)

Measures the difference between two images with MAE, RMSE, PSNR and SSIM and writes a diff layer and an SSIM map.

Compares Layer A of a with Layer B of b and reports MAE, RMSE, PSNR, SSIM and the maximum absolute difference. Typical uses are comparing generated images against a reference, comparing a workflow before and after a parameter change, or producing a score for automatic selection. SSIM looks at local structure and is less sensitive to a global brightness shift; PSNR and RMSE compare raw pixel values.

SSIM uses the standard settings from the original paper: a Gaussian window with sigma 1.5 (11 x 11), K1 = 0.01, K2 = 0.03. Data Range is the width of the value range (1 for 0..1 images). Borders are clamped; many implementations only average over windows fully inside the image, so small differences against other tools are normal.

If b has a different resolution it is resampled to a first. The image output gets a per-pixel difference layer and an SSIM map layer.

Inputs

Outputs

Parameters

Compared with Houdini

Corresponds loosely to Houdini's Error node, but adds SSIM and PSNR. For a per-pixel comparison mask use COP Compare Mask.

COP Contact Sheet (PCG)#

PCG_COPContactSheet · category PCG/cop · Houdini: Contact Sheet (COP)

Arranges the frames of a sequence into a grid image, optionally labelled with frame numbers.

The first frame is placed top left and frames follow row by row. All frames are resampled to the size of the first frame multiplied by Scale. Columns can be chosen automatically so that the grid is close to square. Each tile gets Padding pixels of background around it, and with Labels on the frame number (starting at 0) is drawn in the top left corner of the tile.

Inputs

Outputs

Parameters

COP Export (PCG)#

PCG_COPExport · category PCG/cop

Converts a COP layer to a ComfyUI IMAGE and MASK for previewing, saving or any node that takes an IMAGE.

Because IMAGE is conventionally 0-1, values are clamped by default. SDFs, normals and displacement naturally contain negative values or values above 1 and would turn all black or all white, so clamping can be switched off with mode.

Channel handling: a 1-channel layer is replicated to gray, a 4-channel layer drops its alpha (ComfyUI carries alpha as a separate MASK), and a 2-channel layer gets a zero third channel.

normalize is a data-dependent mapping: it changes with the input frame. It is good for inspection and not for exporting assets.

Inputs

Outputs

Parameters

COP Flood Fill (PCG)#

PCG_COPFloodFill · category PCG/cop · Houdini: Fill Connected (COP)

Selects the connected region around a seed whose values are close to the seed value and outputs it as a mask.

Equivalent of Fill Connected. Starting from the seed (a uv position or a seed layer), every connected pixel whose value differs from the seed value by no more than tolerance is selected. The result is a mask layer. The second output is the number of selected pixels.

Inputs

Outputs

Parameters

COP HeightField Tile Splice (PCG)#

PCG_COPTileSplice · category PCG/cop · Houdini: HeightField Tile Splice (SOP)

Reassembles a sequence of tiles from Tile Split into one image, blending the overlap zones.

Puts the tiles of a sequence back together using the same Columns, Rows and Overlap that were used to split them. In the overlap bands neighbouring tiles are blended with a smoothstep whose weights sum to 1 everywhere, so tiles that were processed separately join without visible seams. Feather sets how much of the overlap band is used as the transition. If the tiles were not changed, the spliced result is identical, pixel for pixel, to the original image.

Inputs

Outputs

Parameters

Compared with Houdini

Corresponds to HeightField Tile Splice, working on COP images.

COP HeightField Tile Split (PCG)#

PCG_COPTileSplit · category PCG/cop · Houdini: HeightField Tile Split (SOP)

Cuts an image into a grid of overlapping tiles and outputs them as a sequence.

Divides the image into Columns x Rows tiles. Each tile extends by Overlap pixels on every side that has a neighbour (the outer image edges get no extra border). The tiles are output as a sequence ordered from the bottom-left tile, first along X then along Y. They can be processed separately and put back together with Tile Splice using the same settings.

Inputs

Outputs

Parameters

Compared with Houdini

Corresponds to HeightField Tile Split, working on COP images.

COP Histogram Plot (PCG)#

PCG_COPHistogramPlot · category PCG/cop · Houdini: Histogram (COP)

Draws a layer's histogram as an image and outputs the raw bucket counts.

Each bucket value is the number of pixels in the bucket divided by the number of counted pixels, multiplied by Scale. A value equal to Maximum goes into the last bucket, NaN is never counted, and the counted-pixel total does not depend on how many values were discarded as outside the range.

Plot modes:

• Colored Bars: a horizontal color ramp whose color at each column is the share of each channel in that bucket.
• Separate Bars: one grayscale band per channel, red at the bottom and alpha (if present) at the top.
• Graph: a bar chart where the share sets the bar height (full image height = 1); the channels are drawn in their own channels, so R, G and B bars overlap.

The second output counts is the raw data: width equals Buckets, height 5, rows from bottom to top are R, G, B, A counts, and the top row holds the number of counted pixels in its first column. To equalize or match histograms use COP Histogram instead.

Inputs

Outputs

Parameters

COP Illegal Pixel (PCG)#

PCG_COPIllegalPixel · category PCG/cop · Houdini: Illegal Pixel (COP)

Finds NaN, infinite or rule-matching pixels and fixes, highlights or isolates them.

Replace is the plugin's original behaviour: NaN, +Inf and -Inf are replaced by the values you give, and negative values can optionally be clamped to 0. The other four modes follow Houdini's Illegal Pixels menu: Blend fills bad pixels with the average of the surrounding good pixels, Zero clears them, Highlight paints them with the Highlight Color, and Isolate keeps only bad pixels and clears the rest.

In those four modes a pixel counts as bad when any channel matches Detect (NaN, Infinite, both, or a Custom rule using Rule and Value). They ignore the replacement values and Clamp Negative.

The report output is a JSON string with counts per layer: NaN, +Inf, -Inf (and negative) component counts in Replace mode, and the number of flagged pixels (not components) in the other modes.

Inputs

Outputs

Parameters

Compared with Houdini

The Replace option and its three replacement values are specific to this plugin; Houdini has no equivalent.

COP Import (PCG)#

PCG_COPImport · category PCG/cop

Converts a ComfyUI IMAGE into a COP image so it can enter a COP chain.

Takes the output of a sampler, Load Image or any IMAGE socket and stores one image of the batch as a COP layer.

This node flips the vertical axis once. ComfyUI and PIL put row 0 at the top, while COP puts row 0 at the bottom (v points up, consistent with UVs and Houdini). Import and Export are the only nodes in the plugin that flip, so you never need to flip an image inside a chain; if a result looks upside down, check that you did not insert an extra flip.

Inputs

Outputs

Parameters

COP Info (PCG)#

PCG_COPInfo · category PCG/cop

Reports the torch and CUDA environment and, if an image is connected, its resolution, layers and backend.

Outputs a short text describing the torch version, whether CUDA is available and which GPU it is, the size thresholds Auto uses (pixel count and VRAM budget), and, when cop is connected, the image's resolution, layers, the backend they live on and an estimate of memory use. The same text is printed to the ComfyUI console.

It exists to answer "is my COP actually running on the GPU?". Auto silently falls back to CPU when the image is too small, no CUDA build of torch is installed, or the VRAM budget is exceeded; this node makes that visible.

Inputs

Outputs

COP Light (PCG)#

PCG_COPLight · category PCG/cop · Houdini: Light (COP)

Lights an image using tangent-space normals with a directional or point light.

Shades the image from a tangent-space normal layer (Z up, as produced by a height-to-normal conversion). The result is Albedo * (Ambient + diffuse * color * intensity * lit) + specular * color * intensity * lit, using Lambert diffuse and a Blinn-Phong highlight with the viewer looking straight down.

A Directional light is defined by Azimuth (the direction the light comes from: 0 degrees from +u, 90 degrees from +v) and Elevation, the same convention as Height to Shadow. A Point light sits above Light Position (uv) at Light Height (as a fraction of the image width), so the direction differs per pixel; no inverse-square falloff is applied.

With Shadows on and a Height Layer given, directional lights use Height to Shadow; point lights march from every pixel toward the light and are shadowed when terrain rises above the line of sight.

Inputs

Outputs

Parameters

Light

Material

Shadows

COP Prefix Sum (PCG)#

PCG_COPPrefixSum · category PCG/cop · Houdini: Prefix Sum (COP)

Computes running sums of pixel values along U or V, or a 2D summed-area table.

Accumulates values along rows, columns, or both. Both gives an integral image (summed-area table), from which the sum over any rectangle needs only four lookups. Reverse directions accumulate from the opposite edge.

Inputs

Outputs

Parameters

COP Segment by Connectivity (PCG)#

PCG_COPSegment · category PCG/cop · Houdini: Segment by Connectivity (COP)

Labels the connected regions of a mask with an integer ID layer.

Writes an ID layer where 0 is background and 1..K number the regions in order of decreasing area. The numbering is deterministic (area descending, then by position), so the same mask always yields the same IDs. Connect the result to an ID mask step to get one mask per region, for example to split an AI segmentation image into separate regions.

Regions below Minimum Area are merged into the background, which removes stray specks. With Tileable on, opposite edges are connected, so a region crossing the seam of a seamless texture counts as one. The algorithm works on runs with a union-find structure, so the Python loop count is the number of runs, not pixels. NumPy only.

The outputs are the region count and a text report.

Inputs

Outputs

Parameters

COP Segment By Value (PCG)#

PCG_COPSegmentByValue · category PCG/cop · Houdini: Mono to ID (COP), Segment by Value (COP)

Assigns IDs to pixels by their value range, optionally splitting disconnected areas.

Values are grouped into equal bins, fixed-size steps or one group per unique value. With Split Disconnected, areas of the same group that are not connected receive different IDs. The second output is the number of regions.

Cast to Integer is Houdini's Mono to ID (Cast): the value is truncated directly to an integer ID, with no renumbering and no connectivity analysis.

Inputs

Outputs

Parameters

COP Sequence Clips (PCG)#

PCG_COPSequenceClips · category PCG/cop · Houdini: Sequence (COP)

Joins ranges of one or more image sequences end to end into a new sequence.

Each clip is a start frame and a frame count. Clip k is taken from input k; if there are more clips than inputs, the last input is reused. Clips are placed back to back. The second output is the resulting frame count.

Inputs

Outputs

Parameters

Compared with Houdini

Equivalent to Houdini's Sequence node, not Sequence Import.

COP Sequence Ops (PCG)#

PCG_COPSequenceOps · category PCG/cop · Houdini: Reverse (COP), Sequence Blend (COP), Time Blend (COP), Time Loop (COP), Time Shift (COP)

Reverses, shifts, loops, retimes or blends image sequences.

Reverse plays the sequence backwards. Time Shift moves it by a number of frames, holding or looping outside the range. Time Loop makes a seamless loop by cross-fading the tail with the head. Retime resamples to a target frame count with linear interpolation. Sequence Blend mixes frame by frame with a second sequence. The second output is the output frame count.

Inputs

Outputs

Parameters

COP Statistics (PCG)#

PCG_COPStatistics · category PCG/cop · Houdini: Statistics (COP)

Computes per-layer, per-channel statistics and counts non-finite values.

Reports min, max, mean, standard deviation (population, divided by N) and percentiles for every channel, together with the number of non-finite values. NaN and inf are excluded from the statistics but always reported, because a single NaN usually shows up far downstream as a black pixel or a fully NaN image.

Outputs are json (all numbers), report (readable text) and value, one chosen number that can be wired to other nodes, for example as a score. With a Mask Layer only pixels inside the mask are counted. The image passes through unchanged.

Inputs

Outputs

Parameters

COP Time Pack (PCG)#

PCG_COPTimePack · category PCG/cop · Houdini: Time Pack (COP)

Samples a sequence at several moments in time and packs the frames into one multi-layer image.

Samples the sequence at times Range Start, Range Start + Step, ... up to Range End. In Relative mode the range is offset by Frame; in Absolute mode the range values are frame numbers. Units can be frames or seconds (seconds are converted with FPS, since this plugin has no scene frame rate).

Each sample becomes a set of layers in the output, with the sample index (counted from 0) added to the layer name as a prefix (0_C) or a suffix (C_0). Times between two frames are linearly interpolated between them; times outside the sequence use the first or last frame.

Inputs

Outputs

Parameters

Compared with Houdini

Only the By Frame method is implemented.

Tips

• The number of samples is capped; raise Step if the node reports too many samples.

COP To Device (PCG)#

PCG_COPToDevice · category PCG/cop

Moves an image to a chosen compute backend (NumPy, torch CPU, CUDA or exact float64).

Normally not needed: the device chosen on a generator decides where the whole chain runs, and filters and composites follow their input. It is useful when the first half of a chain runs fast on the GPU but a later node only has a CPU implementation, when you want to compare the results of two backends in one workflow, or when GPU memory is tight and you want to bring an intermediate result back to main memory.

Moving has a cost: one full-image transfer of height x width x channels x 4 bytes (a 2048x2048 four-channel image is about 67 MB). Avoid bouncing back and forth in the middle of a chain. Compositing nodes automatically move their second input to the device of the first, so you do not need this node for that.

Inputs

Outputs

Parameters

COP Vector Math (PCG)#

PCG_COPVectorMath · category PCG/cop · Houdini: Cross Product (COP), Dot Product (COP)

Performs per-pixel vector operations such as dot, cross, length, normalize and arithmetic between layers or constants.

Computes A op B per pixel. A is a layer name; B is either a layer name or a constant such as 0 0 1. If the channel counts differ, a single-channel B is broadcast; otherwise both are cut to the smaller channel count.

Dot, Length and Distance output a single channel. Cross requires 3 channels. Divide returns 0 where the divisor is 0. Reflect computes A - 2 (A . n) n with B taken as the normal (normalised). Lerp blends from A to B by T.

Inputs

Outputs

Parameters

Compared with Houdini

Corresponds to Dot Product and Cross Product; the other operations are additions of this plugin.

COP Vector Transform (PCG)#

PCG_COPVectorTransform · category PCG/cop · Houdini: Vector Transform (COP), Vector Transform 2D (COP)

Rotates, scales or re-bases the vectors stored in a layer (normals, velocities, directions).

Transforms the vector values of a layer, not the image itself. Modes:

• Rotate 2D: rotates the first two components counter-clockwise around Z by Angle.
• Rotate 3D: Euler rotation in degrees, X first, then Y, then Z.
• Scale: component-wise scale.
• Matrix (3x3): multiplies each vector by a 3x3 matrix (v' = M v, row-major, 9 numbers).
• Tangent to World / World to Tangent: builds a tangent frame (TBN) per pixel from Normal Layer. If no tangent layer is given, the tangent is +X projected onto the tangent plane, which matches the +U direction of Height to Normal (a different reference axis is used where the normal is parallel to X).

Channels beyond those transformed (such as alpha) are kept.

Inputs

Outputs

Parameters

Compared with Houdini

Covers Vector Transform, Vector Transform 2D and the tangent/world part of Space Transform.

COP Visualize (PCG)#

PCG_COPVisualize · category PCG/cop · Houdini: HeightField Visualize (COP), Visualize Velocity (COP)

Renders a height layer through a color ramp (with hillshade and contours) or a velocity layer as hue, streaks or arrows.

Writes a displayable color layer. Height Ramp maps the height through a color ramp between Lo and Hi (both 0 = use the layer's own minimum and maximum), optionally multiplied by a hillshade term and darkened along contour lines. Velocity modes need a 2-channel layer:

• HSV: hue encodes direction (+U is red, counter-clockwise) and brightness the speed times Scale, clamped to 1.
• LIC: line integral convolution (Cabral-Leedom): white noise is averaged along the flow line LIC Length steps in both directions, so the texture streaks along the flow.
• Arrows: one arrow per Arrow Spacing pixels, length proportional to speed times Scale, capped to the cell size.

For Height Ramp, Mode selects how values outside Lo-Hi are handled and Tint by lets another layer provide the color while hillshade and contours still come from the height layer.

Inputs

Outputs

Parameters

Compared with Houdini

Combines HeightField Visualize and Visualize Velocity. Houdini outputs coloured geometry; this node outputs an image.

COP Wrangle (PCG)#

PCG_COPWrangle · category PCG/cop · Houdini: Python Snippet (COP), Wrangle (COP)

Runs VEX-style per-pixel code on the whole image at once.

The code uses the same function library as the geometry Wrangle. Layers are read and written as attributes: @C, @mask, @N.x; @u and @v are the 0-1 pixel coordinates (V pointing up), @x and @y the pixel coordinates and @res the resolution. Assigning to a layer that does not exist creates it.

The code is evaluated once for the entire image with array operations, not once per pixel, so an if statement has to be written as where(cond, a, b).

Example: @mask = smoothstep(0.3, 0.6, @C.x).

ch("name") in the code creates a custom parameter on the node (see ch() parameters); its value is read when the image is computed.

Inputs

Outputs

Parameters

Compared with Houdini

Covers Wrangle and Python Snippet. The code runs vectorised over the whole image, not once per pixel, so there are no per-pixel branches.

COP Write File (PCG)#

PCG_COPWriteFile · category PCG/cop · Houdini: ROP Image Output (COP)

Writes image layers to disk as PNG, EXR or RAW files, with channel packing, remapping and terrain tiling.

Writes into the ComfyUI output directory with pure NumPy encoders (no OpenEXR or OpenCV needed). Channels lists one source per output channel, separated by spaces: a layer name (for example albedo) gives its channels, ao roughness metallic packs three single-channel layers into RGB (an ORM map), N.x N.y N.z picks components, and constants such as 1 or 0.5 are allowed. At most four channels.

Before a PNG or RAW 16 is written, Remap brings values into 0-1: Clamp, Signed (-1..1 to 0..1, for normals), Normalize (stretches the whole image's min..max to full range) or Range (a given In Min..In Max). Normalize uses one range for the full image, so when you export tiles they all share it; the range is written to the sidecar .json next to the files. Encode sRGB applies the sRGB curve to the first three channels (for albedo). EXR and RAW 32 are written as floats without encoding; with Remap Clamp the values are written unchanged.

Tiles splits the image in X x Y files; with Shared Edge neighbouring tiles share their border row or column of pixels (the terrain tile convention), which requires (width - 1) to be divisible by the X tile count (and likewise for height). In the file name {index} is replaced by Index, {tx} and {ty} by the tile coordinates and {tile} by ty x tiles X + tx; {tx:02} pads to two digits.

The first output is a JSON report (files, channels, range and so on); the second is an 8-bit preview of what was written.

Inputs

Outputs

Parameters

Range

Tiles

Compared with Houdini

Corresponds to ROP Image Output. Image row 0 is at the bottom in a COP layer (V up) and is flipped when written.

Sequence Export (PCG)#

PCG_SequenceExport · category PCG/cop

Converts a COP sequence into a ComfyUI IMAGE batch and a MASK batch, one entry per frame.

Each frame becomes one batch entry, so the output can drive video-style ComfyUI workflows. In Normalize mode the minimum and maximum are computed over the whole sequence, not per frame. Per-frame normalisation makes brightness jump from frame to frame (a static object seems to breathe) and is hard to notice because every single frame looks fine; depth sequences are especially sensitive, because an approaching object would be rescaled back to its previous appearance.

The mask batch takes the first channel of the mask layer of every frame (clamped to 0-1); frames without that layer output a mask of all 1. Frames are flipped vertically from COP orientation (row 0 at the bottom) to IMAGE orientation.

Inputs

Outputs

Parameters

Sequence Import (PCG)#

PCG_SequenceImport · category PCG/cop

Converts a ComfyUI IMAGE batch into a COP sequence, one frame per batch entry.

Each entry of the batch becomes one COP frame holding the image data in a single layer. The vertical flip from IMAGE orientation (row 0 at the top) to COP orientation (row 0 at the bottom) happens in this node only.

Inputs

Outputs

Parameters

Sequence Pick (PCG)#

PCG_SequencePick · category PCG/cop

Picks one frame from a COP sequence by index, wrapping around out-of-range indices.

Returns frame index mod frame count. An index beyond the end wraps around instead of raising an error, because while scrubbing the index in a preview going out of range is normal and an error would interrupt the whole chain.

Inputs

Outputs

Parameters