user: Give a detailed overview of Data: syntax, arguments, return values, common patterns.

assistant: ### Dimensionality

Compositing nodes operate on data that is either an image or a dimensionless single value. For
instance, the [Levels node](types/utilities/levels.xhtml#bpy-types-compositornodelevels) outputs a single value, while the
[Render Layers node](types/input/scene/render_layers.xhtml#bpy-types-compositornoderlayers) outputs an image. Node inputs that
expect a single value assume a default value if an image is given and ignore the image completely,
for instance, the [Transform node](types/transform/transform.xhtml#bpy-types-compositornodetransform) expects single values
for its inputs and will assume default values if images were given to those inputs. The default
values are those that are considered identity and thus have no effect on the output, so for the
[Transform node](types/transform/transform.xhtml#bpy-types-compositornodetransform), the *X*, *Y*, and *Angle* inputs will
have a default value of zero, while the *Scale* input will have a default value of one. On the other
hand, if node inputs that expect an image are given a single value, the single value will be assumed
to cover the whole compositing space. For instance, the [Filter node](types/filter/filter.xhtml#bpy-types-compositornodefilter) expect its *Factor* input to be an image, but if a single value is
given, it will be assumed to be the same for all pixels.

### Type

Three types of data exist, all of which are stored in half precision formats:

Float
:   A signed floating-point number. Integer data is also stored as floats because no integer type
    exist.

Vector
:   A 4D vector. While it is 4D, it can have different interpretations depending on the node that uses
    it. It can be treated as a 2D vector with the last two components ignored, for instance, the
    *Vector* input of the [Displace node](types/transform/displace.xhtml#bpy-types-compositornodedisplace) is treated as a 2D
    vector. It can be treated as a 3D vector with the last component ignored, for instance, the
    *Vector* input of the [Seperate XYZ node](types/utilities/vector/separate_xyz.xhtml) is treated as
    a 3D vector. It can be treated as two consecutive 2D vectors. For instance the *Velocity Pass* as
    expected by the [Vector Blur node](types/filter/blur/vector_blur.xhtml#bpy-types-compositornodevecblur) is assumed to have the
    *2D Previous Velocity* in the X and Y components of the vector and the *2D Next Velocity* in the
    Z and W components of the vector.

Color
:   A 4D vector storing the Red, Green, Blue, and Alpha of the color. The color is free form and does
    not conform to a specific color space or alpha storage model, instead, appropriate nodes will have
    settings to control the representation of their output and nodes exist to convert between the
    different representations.

#### Implicit Conversion

In case a node input is given data of type other than its own type, the following implicit
conversions are performed:

| Source | Target | Conversion |
| --- | --- | --- |
| Float | Vector | f => Vector(f, f, f, 0) |
| Float | Color | f => Color(f, f, f, 1) |
| Vector | Float | (x, y, z, w) => Average(x, y, z) |
| Vector | Color | (x, y, z, w) => Color(x, y, z, 1) |
| Color | Float | (r, g, b, a) => Luminance(r, g, b) |
| Color | Vector | (r, g, b, a) => Vector(r, g, b, 0) |

The following example demonstrates implicit conversion between a color type and a float type, since
the [Math Node](types/utilities/math/math.xhtml) expect float inputs.

[image reference removed]

An example that demonstrates implicit conversion between a color type and a float type, since the
*Math* node expects float inputs.