Editing Digital compositing (section)

===Algebraic properties===
When many partially transparent layers need to be composited together, it is worthwhile to consider the algebraic properties of compositing operators used.  Specifically, the associativity and commutativity determine when repeated calculation can or cannot be avoided.

Consider the case when we have four layers to blend to produce the final image: F=A*(B*(C*D)) where A, B, C, D are partially transparent image layers and "*" denotes a compositing operator (with the left layer on top of the right layer).  If only layer C changes, we should find a way to avoid re-blending all of the layers when computing F.  Without any special considerations, four full-image blends would need to occur.  For compositing operators that are [[commutative]], such as [[additive blending]], it is safe to re-order the blending operations.  In this case, we might compute T=A*(B*D) only once and simply blend T*C to produce F, a single operation.  Unfortunately, most operators are not commutative.  However, many are [[associative]], suggesting it is safe to re-group operations to F=(A*B)*(C*D), i.e. without changing their order.  In this case, we may compute S:=A*B once and save this result.  To form F with an associative operator, we need only do two additional compositing operations to integrate the new layer S, by computing F:=S*(C*D).  This expression indicates compositing C with all of the layers below it in one step, and then blending all of the layers on top of it with the previous result to produce the final image in the second step.

If all layers of an image change regularly but many layers still need to be composited (such as in [[distributed rendering]]), the commutativity of a compositing operator can still be exploited to speed up computation through [[parallelism (computing)|parallelism]] even when there is no gain from pre-computation.  Again, consider the image F=A*(B*(C*D)).  Each compositing operation in this expression depends on the next, leading to serial computation.  However, associativity can allow us to rewrite F=(A*B)*(C*D) where there are clearly two operations that do not depend on each other that may be executed in parallel.  In general, we can build a tree of pair-wise compositing operations with a height that is logarithmic in the number of layers.