Removing tracking markers from green screen

Hello everyone,

I'm coming from a layer based compositor and learning fusion has been a journey. I've reached the tip of my frustration and feel like such an idiot. I can't for the life of me figure out how to get rid of these tracking markers, I've been at it for hours. Masks don't seem to work like i'm used to, I can't seem to simply cut out and alpha channel. I'm really hoping someone can relieve me, I'm on the verge of tears

There's an actor walking across the screen. I've tried cutting out the markers underneath and using a roto of the actor in the foreground. This doesn't seem to work, but i'm sure it's because I don't know what I'm doing. Sorry for my wining, fusion is kicking my a** DX




the mess is me frantically trying everything lol

Screen Shot 2020-12-14 at 11.58.13 PM.png (230.37 KiB) Viewed 3839 times

Screen Shot 2020-12-14 at 11.59.28 PM.png (784.46 KiB) Viewed 3839 times

Thank you for any suggestions you may have.

Could you explain what's happening in the shot, with the two media inputs, and the background?

It looks like maybe your first MediaIn is a person with a green screen for above the waist, and your second MediaIn is some legs and a bag you want to attach to the upper body? Not clear what all might go into the background, but for now you're using light rays?

How complicated the solution is depends a lot on what you need to do. For example, if your foreground doesn't move in front of your tracking marker and the camera doesn't move, you could create a mask for each tracking point and a mask for the boundaries of the green screen and add them all together and route them into your keyer's garbage matte. If the foreground does cross over the trackers sometimes, but the camera isn't moving, you could just animate the tracker masks as appropriate so they don't poke holes in the foreground. (Tracking markers imply the camera will move, but they might just be attached permanently, in case the camera is supposed to move, so you still might be working with a locked-down camera.)

You can insert the background with any Transform you want. If the plane of the green screen is supposed to be the plane of the background image and the camera isn't square to the green screen, you can use a corner pin with the tracking markers as a reference, but you won't need to track them. (Unless the camera is moving...)

On the other hand, if the camera is moving, you'll need to use a Planar Tracker, as you do, to capture the motion of the camera (in relation to the green screen). You'll be tracking the tracking markers and can also use anything that's at the same depth as the green screen if that helps. (If they're not EXACTLY at the same depth of the green screen, they will mess things up.)

If you're not going to be using a planar background, but instead want to use 3D (and you have Resolve Studio) you'd use the Camera Tracker and your scene becomes more complex.

So it appears that you definitely don't need two planar trackers, and might not need even one, depending on whether the camera is moving or not. You can route an image through the tracker to cause it to corner pin, for example, to the plane that's tracked. So you could have everything else in your node tree coming in that way.

I believe pros would instead have the planar tracker sitting off to the side -- only an input, not any outputs -- and would use automation expressions (actually Connect To) to cause tracker data to be copied to locational parameters of the things that you want to follow, rather than trying to route everything through the planar tracker.

P.S. it probably won't work well, and it's not really educational for you, but you might be able to just apply a second key that grabs the tracking marker color and key them out, not using any masks for that purpose at all.

The number one question is: is your camera moving?
If not, and you have created a roto for the actor already, then you're almost done.
In the Delta Keyer you can add 'garbage mattes' they can be polylines, or rectangles or whatever mask will work for you. This will effectively 'cut out' the picture i.e. create a hole where the keyer can't key.
(which is your situation) then you can use the roto of your actor to subtract from those garbage mattes, so they won't cut out your actor. And that's basically all there is to it.

Hey, thanks for your reply.

Sorry if i wasn't very clear with my explanation. The pipeline is pretty straight forward, there's just a mess of things I've tried around it.

The shot is of a man pacing in front of a TV. The screen does move but I am familiar with how to use tracking and keyframing to get what I need. The tracking is not my issue, the crux of the issue for me is how masking works with this software.

Normally I would simply cut an alpha channel from the markers and mask the foreground footage over the alpha channels.


Here's where I started:
MediaIN1> Merge>DeltaKeyer1>PlanarTracker>MediaOut1

is my basic effect to remove the green screen from the MediaIN1 node.


The next problem is the red markers.

So with merge2 I tried putting a copy of the MediaIN1 in the foreground and I roto'd the shopping bag and the actors legs.

The idea was to:

-Cut out an alpha channel around the red markers on the screen
-Add the roto'd MediaIN footage on top of the alpha channel
-Send all the work through the delta key

It should be that simple. However, the way the mask interact are not familiar to me with this compositor.

I hope that cleared some things up.

Copy/paste the following in your comp and see if it makes sense to you.
(select everything between 'code' and copy/paste in the area where your nodes are, this will create new nodes with tools etc)

Code: Select all

{
   Tools = ordered() {
      Ellipse1 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.365104166666667, 0.610185185185185 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
         },
         ViewInfo = OperatorInfo { Pos = { 785.333, -158.091 } },
      },
      Ellipse1_1 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.609375, 0.610185185185185 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
            EffectMask = Input {
               SourceOp = "Ellipse1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 791.333, -129.939 } },
      },
      Ellipse1_2 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.365104166666667, 0.383333333333333 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
            EffectMask = Input {
               SourceOp = "Ellipse1_1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 790.667, -95.7273 } },
      },
      Ellipse1_3 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.613541666666667, 0.389814814814815 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
            EffectMask = Input {
               SourceOp = "Ellipse1_2",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 788, -60.9091 } },
      },
      PacingActorGarbageMask = EllipseMask {
         NameSet = true,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            PaintMode = Input { Value = FuID { "Subtract" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.1875, },
            Height = Input { Value = 0.675, },
            EffectMask = Input {
               SourceOp = "Ellipse1_3",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 788, 9.66669 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { LockY = true, X = -0.416666666666667, Y = 0, RX = 0.268923611111111, RY = 0 },
                     { LockY = true, X = 0.390104166666667, Y = 0, LX = -0.268923611111111, LY = -0, RX = 0.256597222222222, RY = 0 },
                     { LockY = true, X = -0.3796875, Y = 0, LX = 0.513194444444444, LY = 0 }
                  }
               },
            },
         },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 20.33129966259, 0.157369733824877 }, Flags = { LockedY = true } },
            [61] = { 0.472156424952058, LH = { 40.66870033741, 0.31478669112718 }, RH = { 82.3311996459961, 0.637265653883077 }, Flags = { LockedY = true } },
            [125] = { 1, LH = { 103.668845480505, 0.818680780492412 }, Flags = { LockedY = true } }
         }
      },
      Actor = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.105882352941176, },
            TopLeftGreen = Input { Value = 0.0705882352941176, },
            TopLeftBlue = Input { Value = 0.619607843137255, },
            EffectMask = Input {
               SourceOp = "PacingActorMask",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 623.333, -3.5455 } },
      },
      PacingActorMask = EllipseMask {
         NameSet = true,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            PaintMode = Input { Value = FuID { "Subtract" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.1875, },
            Height = Input { Value = 0.675, },
         },
         ViewInfo = OperatorInfo { Pos = { 622.667, -56.8788 } },
      },
      DeltaKeyer1 = DeltaKeyer {
         Inputs = {
            BackgroundRed = Input { Value = 0.395080029964447, },
            BackgroundGreen = Input { Value = 1.04369342327118, },
            BackgroundBlue = Input { Value = 0.0436934009194374, },
            TuningRanges = Input {
               Value = ColorCurves {
                  Curves = {
                     {
                        Points = {
                           { 0, 1 },
                           { 0.4, 0.2 },
                           { 0.6, 0 },
                           { 1, 0 }
                        }
                     },
                     {
                        Points = {
                           { 0, 0 },
                           { 0.4, 0 },
                           { 0.6, 0.2 },
                           { 1, 1 }
                        }
                     }
                  }
               },
            },
            ["Garbage.Matte"] = Input {
               SourceOp = "PacingActorGarbageMask",
               Source = "Mask",
            },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 771, 103.606 } },
      },
      Markers = TextPlus {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.3671875, 0.5 }, },
            Red1 = Input { Value = 0.180999994277954, },
            Green1 = Input { Value = 0.0642549991607666, },
            Blue1 = Input { Value = 0.0642549991607666, },
            StyledText = Input { Value = "X      X\n\nX      X", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
            ManualFontKerningPlacement = Input {
               Value = StyledText {
                  Array = {
                  },
                  Value = ""
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 526.667, -3.54546 } },
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "TelevisionPart2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Actor",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 627, 103.439 } },
      },
      TelevisionPart2 = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "TelevisionPart1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Markers",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 525.667, 102.227 } },
      },
      TelevisionPart1 = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Background1_1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 415.667, 102.227 } },
      },
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.181, },
            TopLeftGreen = Input { Value = 0.064255, },
            TopLeftBlue = Input { Value = 0.064255, },
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 281, 102.561 } },
      },
      Background1_1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.272, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftAlpha = Input { Value = 0.32, },
            EffectMask = Input {
               SourceOp = "Rectangle1_1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 276.333, 47.0758 } },
      },
      Rectangle1_1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            JoinStyle = Input { Value = 0, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.447916666666667, },
            Height = Input { Value = 0.444444444444444, },
            CornerRadius = Input { Value = 0.181, },
         },
         ViewInfo = OperatorInfo { Pos = { 284.667, -9 } },
      },
      Rectangle1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            JoinStyle = Input { Value = 0, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            CornerRadius = Input { Value = 0.181, },
         },
         ViewInfo = OperatorInfo { Pos = { 99.6667, 4.71212 } },
      },
      Note1 = Note {
         Inputs = {
            Comments = Input { Value = "If you passthrough the Pacing Actor Mask you can see what it does", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 897.333, -0.515257 },
            Flags = {
               Expanded = true
            },
            Size = { 196, 42.5758 }
         },
      },
      TheseMasksRemoveTheTrackers = Underlay {
         CtrlWZoom = false,
         NameSet = true,
         ViewInfo = UnderlayInfo {
            Pos = { 784.667, -181.727 },
            Size = { 172, 164.121 }
         },
      }
   }
}

So with merge2 I tried putting a copy of the MediaIN1 in the foreground and I roto'd the shopping bag and the actors legs.

Minor comment: that's one of the major problems with a layer-based approach: making copies of things and placing them on layers under or over the original. If you really want a copy, you pull another line off of the original and route it to the node you want to use it.

So where you'd copy a layer, you route it to multiple places, and where you would pre-comp multiple layers -- because you want to apply one or more operations to affect all of them -- you put those operations after the (last) merge that brings the layers together.

Another advantage of a node-based approach is that it's just a script... as Sander de Regt has so wonderfully provided. Way better than words! (I think the tracking marker mattes are offset, though. I had to shift them a bit to get it to work in my v17 Fusion:

Code: Select all

{
   Tools = ordered() {
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "TelevisionPart2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Actor",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { -23.0004, 321.348 } },
      },
      TelevisionPart2 = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "TelevisionPart1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Markers",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { -124.333, 320.136 } },
      },
      Actor = Background {
         NameSet = true,
         Inputs = {
            EffectMask = Input {
               SourceOp = "PacingActorMask",
               Source = "Mask",
            },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.105882352941176, },
            TopLeftGreen = Input { Value = 0.0705882352941176, },
            TopLeftBlue = Input { Value = 0.619607843137255, },
         },
         ViewInfo = OperatorInfo { Pos = { -26.6674, 214.363 } },
      },
      PacingActorMask = EllipseMask {
         NameSet = true,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            PaintMode = Input { Value = FuID { "Subtract" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.1875, },
            Height = Input { Value = 0.675, },
         },
         ViewInfo = OperatorInfo { Pos = { -27.3334, 161.03 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { LockY = true, X = -0.416666666666667, Y = 0, RX = 0.268923611111111, RY = 0 },
                     { LockY = true, X = 0.390104166666667, Y = 0, LX = -0.268923611111111, LY = 0, RX = 0.256597222222222, RY = 0 },
                     { LockY = true, X = -0.3796875, Y = 0, LX = 0.513194444444444, LY = 0 }
                  }
               },
            },
         },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         KeyFrames = {
            [0] = { 0, RH = { 20.33129966259, 0.157369733824877 }, Flags = { LockedY = true } },
            [61] = { 0.472156424952058, LH = { 40.66870033741, 0.31478669112718 }, RH = { 82.3311996459961, 0.637265653883077 }, Flags = { LockedY = true } },
            [125] = { 1, LH = { 103.668845480505, 0.818680780492412 }, Flags = { LockedY = true } }
         }
      },
      PacingActorGarbageMask = EllipseMask {
         NameSet = true,
         Inputs = {
            EffectMask = Input {
               SourceOp = "Ellipse1_3",
               Source = "Mask",
            },
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            PaintMode = Input { Value = FuID { "Subtract" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.1875, },
            Height = Input { Value = 0.675, },
         },
         ViewInfo = OperatorInfo { Pos = { 138, 227.575 } },
      },
      Markers = TextPlus {
         NameSet = true,
         Inputs = {
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.3671875, 0.5 }, },
            Red1 = Input { Value = 0.180999994277954, },
            Green1 = Input { Value = 0.0642549991607666, },
            Blue1 = Input { Value = 0.0642549991607666, },
            StyledText = Input { Value = "X      X\n\nX      X", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
            ManualFontKerningPlacement = Input {
               Value = StyledText {
                  Array = {
                  },
                  Value = ""
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { -123.333, 214.363 } },
      },
      Rectangle1_1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            JoinStyle = Input { Value = 0, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.447916666666667, },
            Height = Input { Value = 0.444444444444444, },
            CornerRadius = Input { Value = 0.181, },
         },
         ViewInfo = OperatorInfo { Pos = { -365.333, 208.909 } },
      },
      Rectangle1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            JoinStyle = Input { Value = 0, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            CornerRadius = Input { Value = 0.181, },
         },
         ViewInfo = OperatorInfo { Pos = { -550.334, 222.621 } },
      },
      DeltaKeyer1 = DeltaKeyer {
         Inputs = {
            BackgroundRed = Input { Value = 0.395080029964447, },
            BackgroundGreen = Input { Value = 1.04369342327118, },
            BackgroundBlue = Input { Value = 0.0436934009194374, },
            TuningRanges = Input {
               Value = ColorCurves {
                  Curves = {
                     {
                        Points = {
                           { 0, 1 },
                           { 0.4, 0.2 },
                           { 0.6, 0 },
                           { 1, 0 }
                        }
                     },
                     {
                        Points = {
                           { 0, 0 },
                           { 0.4, 0 },
                           { 0.6, 0.2 },
                           { 1, 1 }
                        }
                     }
                  }
               },
            },
            ["Garbage.Matte"] = Input {
               SourceOp = "PacingActorGarbageMask",
               Source = "Mask",
            },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 121, 321.515 } },
      },
      Ellipse1_3 = EllipseMask {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Ellipse1_2",
               Source = "Mask",
            },
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.419791666666667, 0.389814814814815 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
         },
         ViewInfo = OperatorInfo { Pos = { 138, 157 } },
      },
      Ellipse1_1 = EllipseMask {
         CtrlWZoom = false,
         Inputs = {
            EffectMask = Input {
               SourceOp = "Ellipse1",
               Source = "Mask",
            },
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.419791666666667, 0.610185185185185 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
         },
         ViewInfo = OperatorInfo { Pos = { 141.333, 87.9697 } },
      },
      Ellipse1 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.3171875, 0.610185185185185 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
         },
         ViewInfo = OperatorInfo { Pos = { 135.333, 59.2116 } },
      },
      Ellipse1_2 = EllipseMask {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Ellipse1_1",
               Source = "Mask",
            },
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.319270833333334, 0.383333333333333 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
         },
         ViewInfo = OperatorInfo { Pos = { 140.667, 122.181 } },
      },
      TelevisionPart1 = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Background1_1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { -234.333, 320.136 } },
      },
      Background1 = Background {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.181, },
            TopLeftGreen = Input { Value = 0.064255, },
            TopLeftBlue = Input { Value = 0.064255, },
         },
         ViewInfo = OperatorInfo { Pos = { -369, 320.47 } },
      },
      Background1_1 = Background {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Rectangle1_1",
               Source = "Mask",
            },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.272, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftAlpha = Input { Value = 0.32, },
         },
         ViewInfo = OperatorInfo { Pos = { -373.667, 264.984 } },
      },
      Note1 = Note {
         Inputs = {
            Comments = Input { Value = "If you passthrough the Pacing Actor Mask you can see what it does", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 247.333, 217.393 },
            Flags = {
               Expanded = true
            },
            Size = { 196, 42.5758 }
         },
      },
      Acartoonversionofyourscene = Underlay {
         NameSet = true,
         ViewInfo = UnderlayInfo {
            Pos = { -283.196, 133.366 },
            Size = { 650.004, 235.26 }
         },
      },
      TheseMasksRemoveTheTrackers = Underlay {
         NameSet = true,
         ViewInfo = UnderlayInfo {
            Pos = { 134.667, 36.1817 },
            Size = { 172, 164.121 }
         },
      }
   }
}


So with merge2 I tried putting a copy of the MediaIN1 in the foreground and I roto'd the shopping bag and the actors legs.
Minor comment: that's one of the major problems with a layer-based approach: making copies of things and placing them on layers under or over the original. If you really want a copy, you pull another line off of the original and route it to the node you want to use it.

So where you'd copy a layer, you route it to multiple places, and where you would pre-comp multiple layers -- because you want to apply one or more operations to affect all of them -- you put those operations after the (last) merge that brings the layers together.

You're right! I can see the benefit and I'm trying to get my brain to rewire to use it. I think in the long run I will actually like node compositing much better, it's just hard to think outside of layers since it's been beat into me for so long lol.

Copy/paste the following in your comp and see if it makes sense to you.
(select everything between 'code' and copy/paste in the area where your nodes are, this will create new nodes with tools etc)

Code: Select all

{
   Tools = ordered() {
      Ellipse1 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.365104166666667, 0.610185185185185 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
         },
         ViewInfo = OperatorInfo { Pos = { 785.333, -158.091 } },
      },
      Ellipse1_1 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.609375, 0.610185185185185 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
            EffectMask = Input {
               SourceOp = "Ellipse1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 791.333, -129.939 } },
      },
      Ellipse1_2 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.365104166666667, 0.383333333333333 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
            EffectMask = Input {
               SourceOp = "Ellipse1_1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 790.667, -95.7273 } },
      },
      Ellipse1_3 = EllipseMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input { Value = { 0.613541666666667, 0.389814814814815 }, },
            Width = Input { Value = 0.0640857850636334, },
            Height = Input { Value = 0.0640857850636334, },
            EffectMask = Input {
               SourceOp = "Ellipse1_2",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 788, -60.9091 } },
      },
      PacingActorGarbageMask = EllipseMask {
         NameSet = true,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            PaintMode = Input { Value = FuID { "Subtract" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.1875, },
            Height = Input { Value = 0.675, },
            EffectMask = Input {
               SourceOp = "Ellipse1_3",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 788, 9.66669 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { LockY = true, X = -0.416666666666667, Y = 0, RX = 0.268923611111111, RY = 0 },
                     { LockY = true, X = 0.390104166666667, Y = 0, LX = -0.268923611111111, LY = -0, RX = 0.256597222222222, RY = 0 },
                     { LockY = true, X = -0.3796875, Y = 0, LX = 0.513194444444444, LY = 0 }
                  }
               },
            },
         },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 20.33129966259, 0.157369733824877 }, Flags = { LockedY = true } },
            [61] = { 0.472156424952058, LH = { 40.66870033741, 0.31478669112718 }, RH = { 82.3311996459961, 0.637265653883077 }, Flags = { LockedY = true } },
            [125] = { 1, LH = { 103.668845480505, 0.818680780492412 }, Flags = { LockedY = true } }
         }
      },
      Actor = Background {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.105882352941176, },
            TopLeftGreen = Input { Value = 0.0705882352941176, },
            TopLeftBlue = Input { Value = 0.619607843137255, },
            EffectMask = Input {
               SourceOp = "PacingActorMask",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 623.333, -3.5455 } },
      },
      PacingActorMask = EllipseMask {
         NameSet = true,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            PaintMode = Input { Value = FuID { "Subtract" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.1875, },
            Height = Input { Value = 0.675, },
         },
         ViewInfo = OperatorInfo { Pos = { 622.667, -56.8788 } },
      },
      DeltaKeyer1 = DeltaKeyer {
         Inputs = {
            BackgroundRed = Input { Value = 0.395080029964447, },
            BackgroundGreen = Input { Value = 1.04369342327118, },
            BackgroundBlue = Input { Value = 0.0436934009194374, },
            TuningRanges = Input {
               Value = ColorCurves {
                  Curves = {
                     {
                        Points = {
                           { 0, 1 },
                           { 0.4, 0.2 },
                           { 0.6, 0 },
                           { 1, 0 }
                        }
                     },
                     {
                        Points = {
                           { 0, 0 },
                           { 0.4, 0 },
                           { 0.6, 0.2 },
                           { 1, 1 }
                        }
                     }
                  }
               },
            },
            ["Garbage.Matte"] = Input {
               SourceOp = "PacingActorGarbageMask",
               Source = "Mask",
            },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 771, 103.606 } },
      },
      Markers = TextPlus {
         NameSet = true,
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Center = Input { Value = { 0.3671875, 0.5 }, },
            Red1 = Input { Value = 0.180999994277954, },
            Green1 = Input { Value = 0.0642549991607666, },
            Blue1 = Input { Value = 0.0642549991607666, },
            StyledText = Input { Value = "X      X\n\nX      X", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
            ManualFontKerningPlacement = Input {
               Value = StyledText {
                  Array = {
                  },
                  Value = ""
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 526.667, -3.54546 } },
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "TelevisionPart2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Actor",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 627, 103.439 } },
      },
      TelevisionPart2 = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "TelevisionPart1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Markers",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 525.667, 102.227 } },
      },
      TelevisionPart1 = Merge {
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Background1_1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 415.667, 102.227 } },
      },
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.181, },
            TopLeftGreen = Input { Value = 0.064255, },
            TopLeftBlue = Input { Value = 0.064255, },
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 281, 102.561 } },
      },
      Background1_1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 125, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.272, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftAlpha = Input { Value = 0.32, },
            EffectMask = Input {
               SourceOp = "Rectangle1_1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 276.333, 47.0758 } },
      },
      Rectangle1_1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            JoinStyle = Input { Value = 0, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Width = Input { Value = 0.447916666666667, },
            Height = Input { Value = 0.444444444444444, },
            CornerRadius = Input { Value = 0.181, },
         },
         ViewInfo = OperatorInfo { Pos = { 284.667, -9 } },
      },
      Rectangle1 = RectangleMask {
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            JoinStyle = Input { Value = 0, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            CornerRadius = Input { Value = 0.181, },
         },
         ViewInfo = OperatorInfo { Pos = { 99.6667, 4.71212 } },
      },
      Note1 = Note {
         Inputs = {
            Comments = Input { Value = "If you passthrough the Pacing Actor Mask you can see what it does", }
         },
         ViewInfo = StickyNoteInfo {
            Pos = { 897.333, -0.515257 },
            Flags = {
               Expanded = true
            },
            Size = { 196, 42.5758 }
         },
      },
      TheseMasksRemoveTheTrackers = Underlay {
         CtrlWZoom = false,
         NameSet = true,
         ViewInfo = UnderlayInfo {
            Pos = { 784.667, -181.727 },
            Size = { 172, 164.121 }
         },
      }
   }
}

I saw the garbage matte input and originally used that to cut the markers out of the key. But then there was a huge hole in my actor that I couldn't figure out how to replace. So my layer based brain just went "pff just roto the actor and place him on top" couldn't get it to work lol. the masks kept interacting weirdly and I pulled all my hair out lol.

I'm going to try this script here later and see what I can make of it. If I understand correctly I just copy here and paste into my editor??? I've never used this kind of transference before.

Also thank you for this [praying hands emoji] lol

Yep, just click on SELECT ALL at the top of the box to copy it all, go to Fusion and in the nodes area paste. Pow, it all shows up. (Again, credit to Sander de Regt for taking the time to make it.) I copied/pasted it into standalone Fusion and the mattes to remove the markers were offset, so I added a version that works for me. I also added an underlay to indicate that a bunch of the nodes are Sander creating a cartoon version of your shot that's animated.

Also, it does not do a Planar Track, it's an example of a non-moving camera shot that has four mattes to cover four tracking points, a moving matte that stands in for a root of the actor that keeps the tracking point mattes from cutting holes in the foreground actor, and the keyer.

There are at least two ways to work where the camera moves. One is to do a tracking and then use the values in expressions in everything else you do so that they track with the shot. Another is to do a stabilize-work-destabilize approach:

1. Use the Planar Tracker to track the tracking markers and green screen, then:

Stabilize: link the tracker's values to a Transform that stabilizes the shot by shifting/skewing/etc the shot so that everything stays in place.

Work: Between the Stabilize and Destabilize Transforms, make your garbage matte, tracking marker masks, etc, in the stabilized workspace where the green screen and markers are not moving.

Destabilize: link the tracker's values to a Transform that puts all of the motion back in again. This carries all of the Work you've done along with it, so that it all moves along with the green screen.

In the main manual they show an example of fixing a blemish on an actor's skin that way. The one problem that I've encountered with this approach, which the manual warns about, is that motion that's too extreme can cause issues because the stabilization skewing gets out of hand.

In fact, Fusion can compress across nodes -- if you do a Transform followed by another Transform, it's smart enough to know about both and to combine them if possible into a single internal transformation operation. It doesn't literally have to do the first Transform, then take those pixels and do the second transform. (I'm pretty sure -- I don't think I'm thinking of other compositing software here.)

Yep, just click on SELECT ALL at the top of the box to copy it all,

Does the Select All link work for you? Every time I click it, it just sends me back to the top of the page. I have to drag-select code here. Might be a browser thing...

1. Use the Planar Tracker to track the tracking markers and green screen, then:

Stabilize: link the tracker's values to a Transform that stabilizes the shot by shifting/skewing/etc the shot so that everything stays in place.

Unless something's significantly changed in the Planar Tracker in the most recent version, this won't work. You'll need the Point Tracker instead. PlanarTracker doesn't produce any outputs that a Transform node can be connected to.

In fact, Fusion can compress across nodes -- if you do a Transform followed by another Transform, it's smart enough to know about both and to combine them if possible into a single internal transformation operation. It doesn't literally have to do the first Transform, then take those pixels and do the second transform. (I'm pretty sure -- I don't think I'm thinking of other compositing software here.)

The term you're looking for is concatenation. When multiple Transforms are next to one another, they pass the transform matrix from node to node and only apply it once at the end of the chain instead of at each step. This will preserve quality, as only the complete transformation gets filtered.

However, any operation that isn't a Transform breaks concatenation. So if you do something like stablize, paint, blur something (even locally), then destabilize, you're going to get two filtering hits on your image because concatenation broke at the point that you did something other than transform.

In that case, you should do your patching in a separate branch that's Merged on top of the stabilized plate. One really cool feature about Fusion is that a Merge is also a Transform, so Merging doesn't break concatenation!

And if at any time you want to apply a transform, stopping the concat, you can use the Flatten Transform switch in the Transform where you want to rasterize. It's pretty rare to need to do it, but every once in a while it's useful.

--

Now, on to the problem at hand, I think it would be useful if you did some practice with the Mask tools and a Bitmap. Make two overlapping Polygons and plug both of them into a Bitmap tool.

View the Bitmap node and play with the various paint modes to see how one mask affects another. Then swap the inputs to see how the priority of the two inputs affects its operation.

In this case, you'll probably want to Subtract the tracking markers from your keyed matte. You could then either Merge your roto into that result, or Subtract the roto from the tracking marker mattes prior to the Subtract.

I don't know how much of that was demonstrated in the example comps you were given—I'm too lazy to look at them.

Sure Bryan, that's the first thing that comes to mind when thinking of you, being lazy.

This complete Wikipedia entry on concatenation really proves your point

Listen...

Thank you guys/girls :crying emoji:

I didn't realize all the masks were supposed to go in the garbage matte. The nodes you send Sander de Regt really helped me understand the flow of it all and were very eloquently done. Thank you.

I'm excited to figure fusion out. It's a refreshing way of doing vfx and I appreciate all the help and suggestions.