Some rather attractive compositing math

Posted on February 4, 2016 by Bryan / 2 Comments

This morning, one of my coworkers, Dan, presented a problem: We commonly merge translucent elements such as smoke on top of themselves in order to thicken them up prior to merging them into the composite. We find that this creates a more satisfying blend than simply adjusting the gamma of the alpha. As with any operation that is done frequently, it is best to make a macro or script that can automate the process. To that end, Dan was attempting to use Fusion’s Custom Tool to make an Iterative Merge node.

The basic math behind an additive merge is f + b * a, where f is the foreground, b is the background, and a is the inverse of the foreground alpha (1-alpha. I abbreviate that simply to “a” to make the math that follows easier to read). When using the same image for both, it is the slightly simpler f + fa. The Iterated Merge would make this a recursive problem. The expression for the second merge is:

(f+fa) + (f+fa)a = f+2fa+fa²

The second merge:

f+2fa+fa² + (f+2fa+fa²)a = f+3fa+3fa²+fa³

The third merge:

f+3fa+3fa²+fa³ + (f+3fa+3fa²+fa³)a = f+4fa+6fa²+4fa³+fa^4

That’s far enough to see the pattern emerging. With each iteration, the polynomial gains a degree and term. Take a look at those coefficients:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

What do you know? It’s Pascal’s Triangle! Having recognized it, I can stop laboriously multiplying and just fill out the triangle to any desired level to learn the coefficients I need:

1 5 10 10 5 1
1 6 16 20 16 6 1
1 7 22 36 36 22 7 1
1 8 29 58 72 58 29 8 1

So nine merges gives this beastly formula:

f + 8fa + 29fa² + 58fa³ + 72fa^4 + 58fa^5 + 29fa^6 + 8fa^7 + fa^8

Unfortunately, there’s no way that I know of to write an expression in Fusion that will generate this kind of polynomial, so in production we’re going to use a much simpler approach:

f + n * fa, where n is the number of desired iterations.

Mathematically, it is imprecise, but it’s way faster to calculate, and it should give us a reasonable approximation of correct results. At such time as I learn how to make Fuses, I might try to create a correct Iterative Merge. The algorithm is a fairly simple recursion, so it shouldn’t be too difficult.

UPDATE: My excellent co-worker Joe Laude did some experiments and devised a much simpler approach to this problem. As it turns out, the only thing that really needs to be modified is the alpha channel. He used an AlphaDivide node (to Nuke users, that would be an Unpremult) to reverse the influence of the alpha on the color channels. Then the expression on the alpha is simply 1-(1-a1)^n1 where n1 is NumberIn1 from the Custom Tool’s Controls panel. This inverts the alpha channel, multiplies it by itself n times, then inverts it again. Then an AlphaMultiply applies the new alpha channel to the color channels, resulting in smoke that appears thicker without creating harsh edges, as would happen by modifying the alpha in place.

Here’s Joe’s Thickener macro (click to expand):

{
Tools = ordered() {
Thickener = MacroOperator {
CtrlWZoom = false,
Inputs = ordered() {
MainInput1 = InstanceInput {
SourceOp = “AlphaDivide1”,
Source = “Input”,
},
Input1 = InstanceInput {
SourceOp = “AlphaThicken”,
Source = “Thicken”,
Default = 1,
},
},
Outputs = {
MainOutput1 = InstanceOutput {
SourceOp = “AlphaMultiply1”,
Source = “Output”,
},
},
ViewInfo = GroupInfo { Pos = { 3190, -115.5, }, },
Tools = ordered() {
AlphaDivide1 = AlphaDivide {
CtrlWZoom = false,
CtrlWShown = false,
ViewInfo = OperatorInfo { Pos = { 0, 10.1499, }, },
},
AlphaThicken = Custom {
CtrlWZoom = false,
CtrlWShown = false,
NameSet = true,
CustomData = {
Settings = {
{
Tools = ordered() {
CustomTool1 = Custom {
CustomData = {
},
ViewInfo = OperatorInfo { Pos = { 550, 181.5, }, },
CtrlWZoom = false,
Name = “CustomTool1”,
Inputs = {
LUTIn2 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn2”,
},
LUTIn1 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn1”,
},
Image1 = Input {
Source = “Output”,
SourceOp = “TimeSpeed1”,
},
LUTIn4 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn4”,
},
Image2 = Input {
Source = “Output”,
SourceOp = “ChangeDepth1_1”,
},
LUTIn3 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn3”,
},
},
},
CustomTool1LUTIn1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
NameSet = true,
SplineColor = { Green = 0, Red = 204, Blue = 0, },
Name = “CustomTool1LUTIn1”,
},
CustomTool1LUTIn2 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
NameSet = true,
SplineColor = { Green = 204, Red = 0, Blue = 0, },
Name = “CustomTool1LUTIn2”,
},
CustomTool1LUTIn3 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
NameSet = true,
SplineColor = { Green = 0, Red = 0, Blue = 204, },
Name = “CustomTool1LUTIn3”,
},
CustomTool1LUTIn4 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
NameSet = true,
SplineColor = { Green = 204, Red = 204, Blue = 204, },
Name = “CustomTool1LUTIn4”,
},
},
},
{
Tools = ordered() {
CustomTool1 = Custom {
Inputs = {
RedExpression = Input { Value = “c1-c2”, },
LUTIn4 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn4”,
},
LUTIn3 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn3”,
},
LUTIn2 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn2”,
},
LUTIn1 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn1”,
},
Image1 = Input {
Source = “Output”,
SourceOp = “TimeSpeed1”,
},
GreenExpression = Input { Value = “c1-c2”, },
BlueExpression = Input { Value = “c1-c2”, },
Image2 = Input {
Source = “Output”,
SourceOp = “ChangeDepth1_1”,
},
},
CtrlWZoom = false,
CustomData = {
},
ViewInfo = OperatorInfo { Pos = { 550, 181.5, }, },
},
CustomTool1LUTIn1 = LUTBezier {
SplineColor = { Green = 0, Red = 204, Blue = 0, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
CustomTool1LUTIn2 = LUTBezier {
SplineColor = { Green = 204, Red = 0, Blue = 0, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
CustomTool1LUTIn3 = LUTBezier {
SplineColor = { Green = 0, Red = 0, Blue = 204, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
CustomTool1LUTIn4 = LUTBezier {
SplineColor = { Green = 204, Red = 204, Blue = 204, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
},
},
{
Tools = ordered() {
CustomTool1 = Custom {
Inputs = {
RedExpression = Input { Value = “c1+c2”, },
LUTIn4 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn4”,
},
LUTIn3 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn3”,
},
LUTIn2 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn2”,
},
LUTIn1 = Input {
Source = “Value”,
SourceOp = “CustomTool1LUTIn1”,
},
Image1 = Input {
Source = “Output”,
SourceOp = “TimeSpeed1”,
},
GreenExpression = Input { Value = “c1+c2”, },
BlueExpression = Input { Value = “c1+c2”, },
Image2 = Input {
Source = “Output”,
SourceOp = “ChangeDepth1_1”,
},
},
CtrlWZoom = false,
CustomData = {
},
ViewInfo = OperatorInfo { Pos = { 550, 181.5, }, },
},
CustomTool1LUTIn1 = LUTBezier {
SplineColor = { Green = 0, Red = 204, Blue = 0, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
CustomTool1LUTIn2 = LUTBezier {
SplineColor = { Green = 204, Red = 0, Blue = 0, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
CustomTool1LUTIn3 = LUTBezier {
SplineColor = { Green = 0, Red = 0, Blue = 204, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
CustomTool1LUTIn4 = LUTBezier {
SplineColor = { Green = 204, Red = 204, Blue = 204, },
NameSet = true,
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
{ 1, Flags = { Linear = true, }, LH = { 0.666666666666667, 0.666666666666667, }, },
},
},
},
},
},
},
},
Inputs = {
NumberIn1 = Input {
Value = 1,
Expression = “Thicken”,
},
LUTIn1 = Input {
SourceOp = “AlphaThickenLUTIn1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “AlphaThickenLUTIn2”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “AlphaThickenLUTIn3”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “AlphaThickenLUTIn4”,
Source = “Value”,
},
AlphaExpression = Input { Value = “1-(1-a1)^n1”, },
Image1 = Input {
SourceOp = “AlphaDivide1”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 43.1499, }, },
UserControls = ordered() {
Thicken = {
LINKID_DataType = “Number”,
INP_Default = 1,
IC_ControlPage = 0,
INPID_InputControl = “SliderControl”,
INP_MaxScale = 21,
INP_MinAllowed = 0,
},
},
},
AlphaThickenLUTIn1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
AlphaThickenLUTIn2 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
AlphaThickenLUTIn3 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
AlphaThickenLUTIn4 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
AlphaMultiply1 = AlphaMultiply {
CtrlWShown = false,
Inputs = {
Input = Input {
SourceOp = “AlphaThicken”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 76.1499, }, },
},
},
},
},
ActiveTool = “Thickener”,
}

alpha channel, efficiency, Fibonacci, fusion, iterative merge, macro, macros, math, mathematics, maths, pascal's triangle, polynomials

Bryan

Web admin for the Christian Gamers Guild and co-host of the Geek @ Arms podcast. Bryan primarily runs character-driven narrativist RPGs such as Primetime Adventures and Tales From the Loop. View all posts by Bryan →

2 Comments

Ribel says:

February 4, 2016 at 3:21 pm

If I’m getting it right,
since f + f*a = result
you have to plug the result into the next iteration:
result + result*a, and so on.
And since the result is pixel’s channel value
you can create Iterative Merge by connecting couple of CTs
and control the number of iterations with Number control
In the case of 9 iterations the expression is:

if(int(n1)>=N, c1+c1*(1-a1), c1),

where N is integer from 1 to 9 for each consecutive CT

the value n1 of all Number controls is controlled by the first Number control through simple expression.

Here is the macro setting:

{
Tools = ordered() {
IterativeMerge = MacroOperator {
CtrlWZoom = false,
Inputs = ordered() {
MainInput1 = InstanceInput {
SourceOp = “m1_1”,
Source = “Image1”,
},
Input1 = InstanceInput {
SourceOp = “m1_1”,
Source = “NumberIn1”,
MaxScale = 9,
Default = 0,
},
},
Outputs = {
MainOutput1 = InstanceOutput {
SourceOp = “m9_1”,
Source = “Output”,
},
},
ViewInfo = GroupInfo { Pos = { 1540, 511.5, }, },
Tools = ordered() {
m9_1 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m9LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m9LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m9LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m9LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=9, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=9, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=9, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m8_1”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 538.15, }, },
},
m9LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m9LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m9LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m9LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m7_2 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m6_1LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m6_1LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m6_1LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m6_1LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=7, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=7, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=7, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m6_2”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 406.15, }, },
},
m6_1LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m6_1LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m6_1LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m6_1LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m8_1 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m7_1LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m7_1LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m7_1LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m7_1LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=8, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=8, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=8, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m7_2”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 472.15, }, },
},
m7_1LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m7_1LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m7_1LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m7_1LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m6_2 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m5_1LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m5_1LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m5_1LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m5_1LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=6, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=6, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=6, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m5_2”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 340.15, }, },
},
m5_1LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m5_1LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m5_1LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m5_1LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m5_2 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m3_1_1LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m3_1_1LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m3_1_1LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m3_1_1LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=5, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=5, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=5, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m4_1”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 274.15, }, },
},
m3_1_1LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m3_1_1LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m3_1_1LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m3_1_1LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m4_1 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m3_1LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m3_1LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m3_1LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m3_1LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=4, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=4, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=4, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m3_2”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 208.15, }, },
},
m3_1LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m3_1LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m3_1LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m3_1LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m3_2 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m2_1LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m2_1LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m2_1LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m2_1LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=3, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=3, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=3, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m2_2”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 142.15, }, },
},
m2_1LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m2_1LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m2_1LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m2_1LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m2_2 = Custom {
CtrlWShown = false,
NameSet = true,
Inputs = {
NumberIn1 = Input { Expression = “m1_1.NumberIn1”, },
LUTIn1 = Input {
SourceOp = “m2LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m2LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m2LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m2LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=2, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=2, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=2, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
Image1 = Input {
SourceOp = “m1_1”,
Source = “Output”,
},
},
ViewInfo = OperatorInfo { Pos = { 0, 76.15, }, },
},
m2LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m2LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m2LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m2LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
m1_1 = Custom {
CtrlWZoom = false,
CtrlWShown = false,
NameSet = true,
Inputs = {
LUTIn1 = Input {
SourceOp = “m1LUTIn1_1”,
Source = “Value”,
},
LUTIn2 = Input {
SourceOp = “m1LUTIn2_1”,
Source = “Value”,
},
LUTIn3 = Input {
SourceOp = “m1LUTIn3_1”,
Source = “Value”,
},
LUTIn4 = Input {
SourceOp = “m1LUTIn4_1”,
Source = “Value”,
},
RedExpression = Input { Value = “if(int(n1)>=1, c1+c1*(1-a1), c1)”, },
GreenExpression = Input { Value = “if(int(n1)>=1, c1+c1*(1-a1), c1)”, },
BlueExpression = Input { Value = “if(int(n1)>=1, c1+c1*(1-a1), c1)”, },
NameforNumber1 = Input { Value = “Number of Merges”, },
ShowNumber2 = Input { Value = 0, },
ShowNumber3 = Input { Value = 0, },
ShowNumber4 = Input { Value = 0, },
ShowNumber5 = Input { Value = 0, },
ShowNumber6 = Input { Value = 0, },
ShowNumber7 = Input { Value = 0, },
ShowNumber8 = Input { Value = 0, },
ShowPoint1 = Input { Value = 0, },
ShowPoint2 = Input { Value = 0, },
ShowPoint3 = Input { Value = 0, },
ShowPoint4 = Input { Value = 0, },
},
ViewInfo = OperatorInfo { Pos = { 0, 10.15, }, },
},
m1LUTIn1_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 0, Blue = 0, },
CtrlWShown = false,
},
m1LUTIn2_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 204, Blue = 0, },
CtrlWShown = false,
},
m1LUTIn3_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 0, Green = 0, Blue = 204, },
CtrlWShown = false,
},
m1LUTIn4_1 = LUTBezier {
KeyColorSplines = {
[0] = {
[0] = { 0, RH = { 0.333333333333333, 0.333333333333333, }, Flags = { Linear = true, }, },
[1] = { 1, LH = { 0.666666666666667, 0.666666666666667, }, Flags = { Linear = true, }, },
},
},
SplineColor = { Red = 204, Green = 204, Blue = 204, },
CtrlWShown = false,
},
},
},
},
ActiveTool = “IterativeMerge”,
}

Reply
Bryan says:

February 4, 2016 at 5:44 pm

That works, but if you’re going to chain tools together, you might as well use 10 Merges instead of 10 Custom Tools. The overhead is way lower.

Reply

Some rather attractive compositing math

2 Comments

Leave a Comment Cancel reply

Categories