Image: Transform & Warp#

Transforms, distortion, UV mapping and sampling.

32 nodes.

Back to the reference index

Contents#

• COP Align (PCG) — Places an image onto the pixel grid of a reference image using stretch, fit, fill or no scaling.
• COP Align Pixels (PCG) — Snaps an image onto the pixel grid of a reference and then shifts it by whole pixels to align its edges.
• COP Align Window (PCG) — Moves and optionally scales an image so that its window lines up with a reference window or a target rectangle.
• COP Bend (PCG) — Bends an image along a curved patch defined by corners, sides or a bend angle.
• COP Chromatic Aberration (PCG) — Offsets the colour channels radially so edges show colour fringes.
• COP Copy Transform (PCG) — Makes several transformed copies of the image and stacks them, each copy shifted, rotated and scaled further than the last.
• COP Corner Pin (PCG) — Warps an image so its four corners land on given positions, or rotates it like a 3D card seen by a pinhole camera.
• COP Crop / Pad (PCG) — Crops an image to a window, and pads it when the window extends beyond the image.
• COP Distort (PCG) — Warps an image per pixel by a vector image, so noise, hand-painted flow or motion vectors displace the pixels.
• COP Flip (PCG) — Mirrors layers horizontally and/or vertically by reversing pixel indices.
• COP Heat Distort (PCG) — Distorts pixels with simplex noise that drifts over time, producing a heat-haze effect.
• COP Heat Distort by Layer (PCG) — Distorts pixels using an input noise layer (or direction layer), with optional curved tracing, streak blur and chromatic aberration.
• COP Hex Tile (PCG) — Breaks up visible tiling of a texture by laying it out on a hexagonal grid with a random offset and rotation per cell.
• COP Lattice Deform (PCG) — Warps an image with a grid of control points that are offset in uv.
• COP Lens Distort (PCG) — Adds or removes radial lens distortion.
• COP Mirror (PCG) — Mirrors one half of an image onto the other, or reflects it across arbitrary mirror planes.
• COP Polar (PCG) — Resamples the whole image between Cartesian and polar layouts.
• COP Polar Coords (PCG) — Converts UV coordinate values stored in a layer to angle and length layers, or back.
• COP Refract from Height (PCG) — Computes the 2-channel UV offset that a water-like height surface causes when viewing something below it.
• COP Resize (PCG) — Resamples the image to a new resolution with bilinear filtering.
• COP Retile (PCG) — Shuffles the image's tiles randomly or turns it into a seamlessly tileable image.
• COP Space Transform (PCG) — Converts coordinate values stored in a layer between Buffer, Pixel, Texture, Image and World spaces.
• COP Sphere Sample (PCG) — Maps a lat-long image onto a sphere and renders it with a default camera.
• COP Swirl (PCG) — Warps an image with a swirl, pinch, bulge or bend distortion.
• COP Tile (PCG) — Repeats the image in a grid, enlarging the output resolution.
• COP Transform (PCG) — Translates, rotates and scales an image around a pivot without changing its resolution.
• COP Transform 3D (PCG) — Places the image as a rectangle in 3D with a full Houdini transform and renders it back to the same raster.
• COP UV Inverse (PCG) — Inverts a UV mapping: turns an output-to-source UV map into a source-to-output one.
• COP UV Map (PCG) — Generates a UV layer, either as a plain per-pixel UV ramp or as one 0-1 UV set per ID island.
• COP UV Sample (PCG) — Samples a source image at per-pixel coordinates: UVs, or directions into a lat-long or mirror-ball map.
• COP UV Transform (PCG) — Scales, rotates and translates the values of a UV layer around a pivot.
• COP Warp (PCG) — Warps an image to another frame's position using a backward motion vector layer.

Nodes#

COP Align (PCG)#

PCG_COPAlign · category PCG/cop

Places an image onto the pixel grid of a reference image using stretch, fit, fill or no scaling.

Resamples cop so that it covers the resolution of reference. stretch fills the whole reference grid and ignores aspect ratio; fit keeps the aspect ratio and scales the image until it fits inside the reference (leaving empty bars); fill keeps the aspect ratio and scales until the reference is completely covered (cropping the overflow); none does not scale and simply centres the image.

This is a whole-image fit to the reference resolution. For rectangle-based alignment with Justify / Goal rules use COP Align Window, and for pixel-exact snapping use COP Align Pixels.

Inputs

Outputs

Parameters

Compared with Houdini

Does not mirror a single Houdini node; the Houdini Align and Align Pixels nodes are covered by COP Align Window and COP Align Pixels.

COP Align Pixels (PCG)#

PCG_COPAlignPixels · category PCG/cop · Houdini: Align Pixels (COP)

Snaps an image onto the pixel grid of a reference and then shifts it by whole pixels to align its edges.

Works in two steps. First the point of the source window chosen by Side X / Side Y is converted to pixel coordinates of the reference image and rounded to the nearest pixel corner; the source is then laid out from there at 1:1 pixel size, with no interpolation. Second, the snapped source is translated by whole pixels so that its Justify edge lands on the Goal edge of the target: the reference window, the source's original window, or a single Target Point. The offset is in pixels and is rounded.

The result lives on the reference grid (size_ref, or the source itself when it is not connected). Pixels outside it are discarded and uncovered pixels are zero. Because the image is never resampled, nothing is blurred.

Inputs

Outputs

Parameters

Snapping

Matching

Compared with Houdini

There is no separate data window and display window; they are treated as one window. COP Align does something different (it fits the whole image into the reference resolution) and is kept as its own node.

COP Align Window (PCG)#

PCG_COPAlignWindow · category PCG/cop · Houdini: Align (COP)

Moves and optionally scales an image so that its window lines up with a reference window or a target rectangle.

The source rectangle is the full image window in image space. The target is either the window of size_ref (or the source's own window when it is not connected), or a rectangle you give with Target Point and Target Size. If Scale To Fit is on, the source is first scaled around its own centre to match the target; then it is translated per axis so that its Justify edge meets the target's Goal edge, and finally Offset is added. The result is rasterized onto the grid of size_ref (or the source) with the chosen filter; areas not covered are zero.

Target Point is the centre of the target rectangle and Target Size its width and height.

Inputs

Outputs

Parameters

Target

Matching

Compared with Houdini

There is no separate data window and display window, so Houdini's Data / Display window choices are merged into one. Whether the Houdini Target Point is a centre or a corner is not documented; here it is the centre of the target rectangle.

COP Bend (PCG)#

PCG_COPBend · category PCG/cop · Houdini: Bend (COP)

Bends an image along a curved patch defined by corners, sides or a bend angle.

All positions are in image space (-1..1 across the longer side). The source image fills the patch with texture coordinates (s, t) in 0..1; for every output pixel the node solves for the source coordinate with a per-pixel Newton iteration. Pixels that fall outside the patch, or where no solution is found, are zero. Where the patch folds over itself only one solution is found.

corners builds each edge as a cubic Bezier from the corner points and two tangent handles per corner, blended into a Coons patch. sides uses the four corners plus the midpoint of each edge (each edge is a quadratic curve through its midpoint). angle bends the part of the image along Capture Direction, within Capture Length of the origin, into a circular arc with a total turn of Bend Angle. The part beyond follows rigidly and the part before stays put.

The output uses the grid of size_ref, or the source's own grid if it is not connected.

Inputs

Outputs

Parameters

Corners

Corner Handles

Side Handles

Capture

Compared with Houdini

The Houdini documentation only lists the parameters, so some choices are made here: tangent handles are offsets relative to their corner, and in Angle mode the bend goes to the left of the capture direction. COP Swirl in bend mode is a different effect (a bending twist around the centre) and is kept separate.

COP Chromatic Aberration (PCG)#

PCG_COPChromaticAberration · category PCG/cop · Houdini: Chromatic Aberration (COP)

Offsets the colour channels radially so edges show colour fringes.

The red channel is scaled up around Center by 1 + Amount and the blue channel is scaled down by 1 - Amount, while green stays unchanged. This creates the coloured fringes that grow towards the edges of the image, like a lens with lateral chromatic aberration.

Inputs

Outputs

Parameters

COP Copy Transform (PCG)#

PCG_COPCopyTransform · category PCG/cop · Houdini: Copy and Transform (COP)

Makes several transformed copies of the image and stacks them, each copy shifted, rotated and scaled further than the last.

Copy i (starting at 0) is translated by i * Translate in uv units, rotated by i * Rotate degrees around Pivot and scaled by Scale^i (multiplied per axis by Scale XY). Copies are combined with Op: over_last and under use Porter-Duff compositing and compute a proper alpha (layers without alpha are treated as fully opaque, so their whole frame covers what is below); add adds; max takes the larger value; over is the older mode in which copy 0 is on top and alpha is interpolated like a normal channel.

Fade makes later copies fainter: copy i is multiplied by (1 - Fade)^i. For over_last and under only alpha is faded.

Inputs

Outputs

Parameters

Transform per Copy

Compared with Houdini

Corresponds to Copy and Transform. The over mode is kept for compatibility and differs from Houdini's Over; use over_last or under to match Houdini.

COP Corner Pin (PCG)#

PCG_COPCornerPin · category PCG/cop · Houdini: Corner Pin (COP)

Warps an image so its four corners land on given positions, or rotates it like a 3D card seen by a pinhole camera.

Both modes build a homography (a perspective transform), so straight lines stay straight. In corners mode you give the uv positions of the four output corners (bottom left, bottom right, top right, top left). In rotate_3d mode the image is treated as a card that is rotated in 3D by the given XYZ Euler angles in degrees and photographed by a pinhole camera with the given field of view; the four corner positions are computed from that and the same homography is used. If the card is rotated behind the camera an error is raised: reduce the angles or increase Distance.

Inputs

Outputs

Parameters

3D

Compared with Houdini

Covers Corner Pin and the card rotation use of Transform 3D.

COP Crop / Pad (PCG)#

PCG_COPCrop · category PCG/cop · Houdini: Crop (COP)

Crops an image to a window, and pads it when the window extends beyond the image.

The origin is at the bottom left, as everywhere in COP. The window may extend outside the image: the outside is filled according to Border, so a negative X / Y with a larger resolution pads the image outward without another node. Parts that stay inside the image are copied bit for bit.

The window is given either as integer pixels (X, Y, Resolution) or, for other Units and Methods, through Corner and Extent. With Units pixels and Method lower_left_size the integer X, Y and Resolution fields are used; otherwise Corner and Extent are used and converted to pixels, rounding each corner to the nearest pixel edge. Pad Left / Right / Top / Bottom then grow the window outward.

Typical uses: cropping a 1024 x 1024 composition to 832 x 1216 before a diffusion pass, or extending a render with a black border to make an outpainting canvas.

Inputs

Outputs

Parameters

Pixel Padding

Compared with Houdini

Houdini's Crop mode Reframe to Crop is not available, because layers here always equal the frame and cannot carry data outside it. Aspect Ratio, Extract Tile, Min / Max Resolution, Reset Pixel Origin and the geometry input are not implemented. Border has an additional mirror option.

Tips

• To pad an image, use a negative X / Y and a larger resolution, or use the Pad fields.

COP Distort (PCG)#

PCG_COPDistort · category PCG/cop · Houdini: Distort (COP)

Warps an image per pixel by a vector image, so noise, hand-painted flow or motion vectors displace the pixels.

Computes out[p] = cop[p + amount * field[p]]. This is the general form of Houdini's Distort by Noise: wire a 2-channel COP Noise into field for noise distortion, a painted flow map for directional dragging, or a backward motion vector layer for a frame-to-frame warp.

The lookup is backward: the field says where in the input each output pixel fetches its value from, so the visual result is the opposite of "pushing pixels along the vector". The benefit is that no holes appear. For a forward-looking result use a negative amount (equivalent for small displacements, not for large ones).

If the field has a different resolution than the main input it is resampled to the main input first, as in Composite.

Inputs

Outputs

Parameters

COP Flip (PCG)#

PCG_COPFlip · category PCG/cop · Houdini: Flip (COP)

Mirrors layers horizontally and/or vertically by reversing pixel indices.

The flip reverses the index order directly, with no resampling, so it is bit-exact lossless. Vertical flips the v axis; since row 0 of a COP image is the bottom, this turns the image upside down. Enabling both is a 180 degree rotation, which is cheaper than a rotation in COP Transform (also lossless).

Inputs

Outputs

Parameters

COP Heat Distort (PCG)#

PCG_COPHeatDistort · category PCG/cop · Houdini: Heat Distort (COP)

Distorts pixels with simplex noise that drifts over time, producing a heat-haze effect.

Equivalent of Heat Distort (the procedural one). Pixels are pushed by up to amount pixels using simplex noise that drifts in the given direction as time advances. If a field layer is given, the distortion is scaled by that layer's values, so it only acts where the layer is above 0 (for instance, the haze above a heat source). Wire the frame number into time for animation.

Inputs

Outputs

Parameters

Compared with Houdini

For distortion driven by an input noise layer, use COP Heat Distort by Layer instead.

COP Heat Distort by Layer (PCG)#

PCG_COPHeatDistortByLayer · category PCG/cop · Houdini: Heat Distort by Layer (COP)

Distorts pixels using an input noise layer (or direction layer), with optional curved tracing, streak blur and chromatic aberration.

Equivalent of Heat Distort by Layer. Instead of generating noise it uses a noise layer of the input. The displacement direction is the gradient of the noise (or an explicit 2-channel direction layer, if given) rotated by angle, then scaled: displacement = scale * effect * Rot(angle) * direction in image units (the long side is 2, +y up). The output samples the source at p - displacement with bilinear filtering.

accurate walks backward along the field in steps of about step_pixels, evaluating the field at each position, so curved fields give curved trajectories; off, a single straight step is taken. streak_blur averages samples along that path. blur_source blurs the source and mixes between sharp and blurred according to displacement magnitude relative to the maximum. blur_noise pre-blurs the noise before its gradient is taken. chromatic offsets red, green and blue by different multiples of the displacement (alpha follows green) on layers with at least 3 channels.

The formulas are not given in Houdini's documentation; the definitions here are the plugin's own.

Inputs

Outputs

Parameters

Distortion

Blur Source

Blur Noise

Chromatic Aberration

Compared with Houdini

The older COP Heat Distort generates its own simplex noise that drifts in time; this node takes the noise as an input layer. The default channel multipliers for chromatic aberration (1.2 / 1.0 / 0.8) are the plugin's choice, since Houdini's documentation does not give them.

COP Hex Tile (PCG)#

PCG_COPHexTile · category PCG/cop · Houdini: Hex Tile (COP)

Breaks up visible tiling of a texture by laying it out on a hexagonal grid with a random offset and rotation per cell.

The plane is divided into a hexagonal grid. Each cell gets its own randomly offset and randomly rotated copy of the source texture, and the three copies that overlap at every pixel are blended with barycentric weights (hex-tiling after Mikkelsen 2022). The result hides the repetition of a tiling texture.

The weights are sharpened as w^(1 + 8*contrast) and renormalized, so a higher Blend Contrast gives narrower, less blurry seams between cells. The source texture should itself be tileable, because it is sampled with wrapping. If the source input is not connected, the Source Layer is read from cop itself.

Inputs

Outputs

Parameters

Tips

• Use a tileable source texture; non-tileable input will show seams where the texture wraps.

COP Lattice Deform (PCG)#

PCG_COPLatticeDeform · category PCG/cop · Houdini: Lattice Deform (COP)

Warps an image with a grid of control points that are offset in uv.

A lattice of (nx+1) x (ny+1) control points is laid over the image, where Divisions sets the number of cells nx ny. Each control point has a uv offset, either typed in explicitly (Point Offsets) or generated randomly (Jitter). The offsets are bilinearly interpolated across the image, and the image is resampled by inverse mapping (each output pixel reads the input at minus its offset), which matches a forward warp for small offsets.

Inputs

Outputs

Parameters

COP Lens Distort (PCG)#

PCG_COPLensDistort · category PCG/cop · Houdini: Lens Distort (COP)

Adds or removes radial lens distortion.

Applies the radial term of the Brown-Conrady model, r_d = r * (1 + k1*r^2 + k2*r^4), where r is measured from the Center and normalized by half the image diagonal. A negative K1 gives barrel distortion, a positive K1 gives pincushion. Distort adds distortion to a clean image and Undistort removes it; the two round-trip. Very large |K1| values make the mapping non-monotonic and the Distort solver can then converge to the wrong root.

Inputs

Outputs

Parameters

COP Mirror (PCG)#

PCG_COPMirror · category PCG/cop · Houdini: Mirror (COP)

Mirrors one half of an image onto the other, or reflects it across arbitrary mirror planes.

The four directional modes copy one side onto the other around Mirror Position: Left to Right copies the left half over the right half, and so on. Quad mirrors the bottom-left quarter onto the whole image. Position is a uv coordinate.

Number and Offset and Custom Mirror Planes are Houdini's two arbitrary-plane modes. A mirror plane is a line in image space (origin at the image centre, -1 to 1 spanning the longer side, square pixels). With Angle 0 and Offset 0 it is the vertical centre line and the left half is mirrored onto the right. A positive Offset moves the plane to the right, and Reverse swaps which side is the source. In Number and Offset, plane k has the angle k * Angle and all planes share Offset. In Custom, each line of Mirrors defines one plane as angle offset [reverse]. Planes are applied in sequence, each acting on the result of the previous ones, but the lookup is composed so the image is resampled only once. Those two modes ignore Mirror Position.

Inputs

Outputs

Parameters

COP Polar (PCG)#

PCG_COPPolar · category PCG/cop

Resamples the whole image between Cartesian and polar layouts.

Cartesian to Polar unrolls a ring into a horizontal strip: U becomes the angle and V the radius. Polar to Cartesian rolls a strip back into a ring. The two directions are inverses of each other. The aspect ratio is preserved relative to the shorter image side.

This moves pixels. To only convert the coordinate values stored in a UV layer, use COP Polar Coords instead.

Inputs

Outputs

Parameters

Compared with Houdini

Unlike Houdini's UV to Polar / Polar to UV, which only convert coordinate values, this node resamples the image itself (equivalent to UV Map, then polar conversion, then UV Sample).

COP Polar Coords (PCG)#

PCG_COPPolarCoords · category PCG/cop · Houdini: Polar to UV (COP), UV to Polar (COP)

Converts UV coordinate values stored in a layer to angle and length layers, or back.

UV to Polar reads the uv layer and writes two single-channel layers, angle and length, measured around the Origin. Polar to UV does the inverse: it reads the angle and length layers (or the constants when a layer name is empty) and writes a uv layer.

Angle 0 points along +U and increases counter-clockwise. Angles come out in the range from 0 up to one full turn in the chosen units. Only coordinate values are converted; no pixels move.

Inputs

Outputs

Parameters

Compared with Houdini

Origin is an addition; Houdini always measures from UV (0, 0).

COP Refract from Height (PCG)#

PCG_COPRefractFromHeight · category PCG/cop · Houdini: Refract from Height (COP)

Computes the 2-channel UV offset that a water-like height surface causes when viewing something below it.

Looks through a height layer acting as a liquid surface and writes how far objects on the bottom appear shifted, as a 2-channel UV offset layer. Feeding it to COP Distort (Units = UV, Amount = 1, Field Layer = the output) produces an underwater distortion; the offset already says where the line of sight lands, and Distort samples backwards, so no negation is needed.

A flat surface gives exactly zero offset; with IOR 1 the offset is zero however much the surface moves; the offset is linear in Depth. There is no Fresnel and no absorption: this is a distortion field, not a render. If a Source Layer is given, the refracted image is also produced by sampling it with the offset.

Inputs

Outputs

Parameters

View

Height

Refraction

Ground

COP Resize (PCG)#

PCG_COPResize · category PCG/cop · Houdini: Resample (COP), Resize (COP)

Resamples the image to a new resolution with bilinear filtering.

Coordinates are converted using pixel centres: x = (i+0.5)*W/W' - 0.5, not the end-point-aligned i*(W-1)/(W'-1). Pixels are cells with width, not points. Scaling 2 columns to 1 gives x = 0.5 (half of each) with centre alignment, whereas end-point alignment would sample only the left pixel.

The UV grid and Sample nodes use the same convention, so generating noise and then resizing matches generating the noise directly at the target size.

Inputs

Outputs

Parameters

COP Retile (PCG)#

PCG_COPRetile · category PCG/cop · Houdini: Retile (COP)

Shuffles the image's tiles randomly or turns it into a seamlessly tileable image.

Shuffle cuts the image into a grid and rearranges the tiles randomly, optionally rotating them by multiples of 90 degrees and flipping them. Make Seamless cross-fades the image with a copy of itself shifted by half its size, weighted by the distance to the edge, so that the result tiles.

Inputs

Outputs

Parameters

COP Space Transform (PCG)#

PCG_COPSpaceTransform · category PCG/cop · Houdini: Space Transform (COP)

Converts coordinate values stored in a layer between Buffer, Pixel, Texture, Image and World spaces.

Converts the first two channels of a coordinate layer; a third channel is passed through unchanged. The source space is interpreted using the resolution of the source reference, and the destination space using the destination reference (the main image if a reference is not connected). Position applies the full affine conversion; Vector applies only the linear part, without translation. In Pixel space the centre of the first pixel is 0.5.

This is not the same as a vector transform (rotation, scale, matrices, tangent space).

Inputs

Outputs

Parameters

Compared with Houdini

There is no camera or pixel scale, so Buffer equals Pixel and World equals Image.

COP Sphere Sample (PCG)#

PCG_COPSphereSample · category PCG/cop · Houdini: Sphere Sample (COP)

Maps a lat-long image onto a sphere and renders it with a default camera.

The source is treated as a lat-long (equirectangular) map. With Celestial Sphere on, it is an infinitely distant sky dome affected only by Rotate, and the mask is all 1. With it off, it is a transformable unit sphere and the mask marks pixels where the camera ray hits the sphere.

There is no camera metadata: the camera looks along -Z, and with perspective projection it sits at (0, 0, Camera Distance).

Inputs

Outputs

Parameters

Compared with Houdini

Camera Distance is an addition, since there is no camera metadata.

COP Swirl (PCG)#

PCG_COPSwirl · category PCG/cop · Houdini: Swirl (COP)

Warps an image with a swirl, pinch, bulge or bend distortion.

All four modes are inverse mappings: for every output pixel the node computes where in the input to sample. Distances are measured from Center in aspect-corrected UV units (height = 1).

• Swirl: inside Radius, rotates the content by Amount degrees, fading with (1 - r/R)^2 so the rotation is strongest at the centre and zero at the radius.
• Pinch / Bulge: pulls the content towards the centre (pinch) or pushes it outwards (bulge) inside Radius, with the same quadratic falloff. Amount is clamped to 0-1, which keeps the mapping monotonic so nothing folds over.
• Bend: bends the image horizontally into an arc; Amount is the angle subtended by the full image width.

The warp is applied with bilinear resampling to the selected layers only; other layers are left untouched.

Inputs

Outputs

Parameters

Tips

• Use a Radius of 0.5 or more for a swirl that reaches the image edge.

COP Tile (PCG)#

PCG_COPTile · category PCG/cop

Repeats the image in a grid, enlarging the output resolution.

Copies the image Tiles times in X and Y; the output resolution becomes (width x tiles X, height x tiles Y). The copies are bit-exact, with no resampling.

With Mirror enabled, every odd column (or row) is flipped, which is the quickest way to turn any image into a seamlessly tiling one, at the cost of mirror symmetry in the result; directional content such as text or faces will give it away.

This is not the same as the Tile U option of the Noise node, which makes the noise function periodic without changing resolution; this node duplicates the picture and increases the resolution.

Inputs

Outputs

Parameters

COP Transform (PCG)#

PCG_COPTransform · category PCG/cop · Houdini: HeightField Transform 2D (COP), Transform 2D (COP)

Translates, rotates and scales an image around a pivot without changing its resolution.

Applies scale first, then rotation, then translation, all around Pivot. The resolution stays the same; content moving outside the frame is handled by Border.

Rotation is done in an aspect-corrected space (normalised by the short side, as used by the COP Shape node), so a non-square image is not sheared when rotated: a circle rotated by 30 degrees matches an ellipse drawn rotated by 30 degrees. Rotation is counter-clockwise in degrees with V pointing up, which can look reversed compared with ComfyUI nodes that use V down; that is the coordinate convention, not a bug.

Multiples of 90 degrees are exact pixel moves (the angle snaps to exact 0 and +-1 values, giving the same result as np.rot90), and a pure integer-pixel translation is equivalent to np.roll.

Downscaling is not anti-aliased. At scale 0.25 each output pixel covers 4x4 input pixels but bilinear sampling reads only 2x2, giving moire. Blur first (sigma of about 0.5 / scale) when shrinking a lot.

Layers not selected are passed through untouched. Note for SDF layers: translation and rotation preserve distances but scaling does not, so a scaled SDF layer is no longer a correct SDF.

Inputs

Outputs

Parameters

Compared with Houdini

Covers both Transform 2D and HeightField Transform 2D.

COP Transform 3D (PCG)#

PCG_COPTransform3D · category PCG/cop · Houdini: Transform 3D (COP)

Places the image as a rectangle in 3D with a full Houdini transform and renders it back to the same raster.

The image is treated as a rectangle on the z = 0 plane, positioned in 3D with the full Houdini transform (transform order, rotate order, translate, rotate, scale, shear, uniform scale, pivot translate and rotate, invert), and then viewed with a default camera. The camera is orthographic by default; with Perspective on it becomes a perspective camera at distance Camera Distance on the Z axis. This corresponds to Houdini's Transform 3D with Rasterize enabled. Pixels that do not hit the plane (seen edge-on, or plane behind the camera) become 0.

Translation is in image space, where -1 to 1 spans the long edge of the image. Layers do not carry border metadata here, so Border Auto behaves like Clip: the image is sampled normally inside its rectangle and is 0 outside, with no bleeding of black into the edge. Constant fades edges to black through the filter kernel; Clamp and Mirror and Wrap extend the image.

This node is not the same as the four-corner mapping of Corner Pin.

Inputs

Outputs

Parameters

Pivot Transform

Compared with Houdini

Only the Rasterize mode of Houdini's Transform 3D is implemented. Metadata-only transforms (which change no pixels) and Crop to Content are not available, because layers have no data window. Camera Distance is an addition.

COP UV Inverse (PCG)#

PCG_COPUVInverse · category PCG/cop · Houdini: UV Inverse (COP)

Inverts a UV mapping: turns an output-to-source UV map into a source-to-output one.

The input UV layer maps each output pixel to a UV position in a source image. This node computes the inverse. Every output pixel splats its own pixel-centre UV onto the source pixel it points to; if several fall into the same source pixel they are averaged. Source pixels that nothing points to are filled by push-pull (if Fill is on). A coverage layer named <Output Layer>_mask (1 where a pixel was hit, before filling) is written as well.

The inverse only makes sense where the map is roughly one-to-one and not much sparser than the source; the coverage layer tells you where that holds.

Inputs

Outputs

Parameters

COP UV Map (PCG)#

PCG_COPUVMap · category PCG/cop · Houdini: UV Map (COP), UV Map by ID (COP)

Generates a UV layer, either as a plain per-pixel UV ramp or as one 0-1 UV set per ID island.

UV Map (identity) writes the UV of every pixel centre, which you can scale, rotate (around 0.5, 0.5) and offset. UV Map by ID maps the bounding box of each ID (value greater than 0 in ID Layer) to its own 0-1 range, so every segmented region can carry a complete texture. Pixels with ID 0 get UV 0 (and uvscale 0).

UV Space selects the coordinate system of the result: Texture is 0 to 1, Image is -1 to 1 across the long edge, Pixel counts pixels from 0.5 at the first pixel centre. By ID supports only Texture and Image. The values then go through (uv + Shift) x Cycles and are folded back into the space's range according to the border mode. An optional uvscale layer holds the effective scale factor relative to the identity map (the largest singular value of the Jacobian, including Scale, Cycles and the island scaling).

In by-ID mode, ID Mode can output island statistics instead of local UVs: bounding box centre, minimum corner, maximum corner or size (measured in the chosen UV space; no shift, cycles or border are applied, and the uvscale is 1). With Connected on, ID regions that are not connected (4-neighbour) count as separate islands.

Inputs

Outputs

Parameters

Border

Compared with Houdini

Covers both UV Map and UV Map by ID. The default border mode Extend leaves values unfolded; Houdini's default is not documented.

COP UV Sample (PCG)#

PCG_COPUVSample · category PCG/cop · Houdini: UV Sample (COP)

Samples a source image at per-pixel coordinates: UVs, or directions into a lat-long or mirror-ball map.

Reads a coordinate layer from the main input and looks up the Source image at those positions with bilinear filtering; the result has the resolution of the main input. If no source is connected the node samples the main input itself.

• UV: the coordinate layer has 2 channels (0-1 UV).
• Lat-Long: the layer holds 3-channel directions (a normal or reflection vector); the source is an equirectangular environment map, Y up.
• Mirror Ball: same directions, the source is a photograph of a mirror ball.

Inputs

Outputs

Parameters

COP UV Transform (PCG)#

PCG_COPUVTransform · category PCG/cop · Houdini: UV Transform (COP)

Scales, rotates and translates the values of a UV layer around a pivot.

Changes the UV values stored in a layer, not the image: values are scaled around Pivot, then rotated counter-clockwise, then translated. With Wrap on, the fractional part is taken afterwards so the result stays within 0-1. Because it transforms coordinates, feeding the result to a sampler moves the sampled texture in the opposite sense (translating UVs by +0.1 shifts the texture by -0.1).

Inputs

Outputs

Parameters

COP Warp (PCG)#

PCG_COPWarp · category PCG/cop

Warps an image to another frame's position using a backward motion vector layer.

Backward warp: out[p] = image[p + motion[p]], so every output pixel fetches its value from where it came from. The motion layer must therefore be motion_bwd (the vectors on the next frame's grid pointing back to the previous frame). Feeding forward motion produces a reversed warp that looks nearly right for small displacements and only shows wrong smearing when animated, which is why the layer name defaults to motion_bwd.

A typical use is temporal consistency: warp the previous frame (for example an AI-generated image) to the current frame's position and use it as the img2img init or ControlNet reference. The image and the motion layer must have the same resolution. Only the selected layer is warped; the other layers of the input are kept unchanged.

Inputs

Outputs

Parameters