some help with adjusting the beauty image on a primatte shot

Actually, on any matte comp...I haven't figured out how I can adjust saturation, contrast, etc. without affecting the matte surround green. Brand new to Fusion but but have figured out most other parts I need in comping.

Thanks,
Rick

Color correct after pulling your key but before you Merge with the rest of your composite. If you're doing anything that would affect the black level—lift, brightness, or contrast—use the Pre-Divide/Post-Multiply button in the Options tab. This will divide by your alpha, perform the operation, then remultiply, knocking the black transparent pixels back down to zero. It also makes the correction more accurate in the semi-transparent fringe areas.

Here's a screenshot of a simplified keying procedure I use often. MADKey is a custom-built keyer that I use in Fusion 7 & 8 since they don't have Delta Keyer. Can't show a result because I don't have any footage handy.

Untitled.png (56.49 KiB) Viewed 1364 times

Ahhh....Thanks so much. It's always one little click in a box somewhere isn't it...

And sorry for the double post....didn't realize admins had to approve first and thought it didn't post.

Best,
Rick

MADKey is a custom-built keyer that I use in Fusion 7 & 8 since they don't have Delta Keyer. Can't show a result because I don't have any footage handy.

Hey Bryan,
Regardless to the fact I'm a bit off-topic for the OP has its answer, and also to the fact I don't use delta keyer but Primatte for some reasons, I had an interested look into your attachment and 2 particular points popped up in my mind, since I'm very often into keys too :
1/ I'd be interested in seeing what you tweak in the EdgeDetect and Lightwrap nodes ;
2/ you should be looking at the Greg Chalenko's BlurredEdgesRestoration (macro) node available for Fusion. I think you may have great results and efficiency (I mean in term of spared time) especially in your keyerless context.

Take care

Thanks, Sam. I'm aware of Blurred Edges Restoration. We've got a similar macro in house that does pretty much the same thing, but without the typos.

The edge detect is just a Filter set to Sobel. I usually put in an Erode/Dilate and a Blur right after to adjust the qualities of the edge mask. Here's the macro that wraps all of that in a handy single package. Just feed it the composite and the foreground alpha:

Code: Select all

{
   Tools = ordered() {
      EdgeBlur = MacroOperator {
         CtrlWZoom = false,
         NameSet = true,
         Inputs = ordered() {
            Comments = Input { Value = "Muse Tools Library\r\nby Bryan Ray\r\nwww.musevfx.com", },
            Blur = Input { Value = 7.3, },
            EdgeWidth = Input { Value = 0.00675, },
            EdgePosition = Input { Value = 0.00068, },
            Input = InstanceInput {
               SourceOp = "edgeBlurInput",
               Source = "Input",
            },
            Matte = InstanceInput {
               SourceOp = "MatteIn",
               Source = "Image",
               Name = "Matte In",
            }
         },
         Outputs = {
            Output = InstanceOutput {
               SourceOp = "Blend",
               Source = "Output",
            }
         },
         ViewInfo = GroupInfo { Pos = { 550, 214.5 } },
         Tools = ordered() {
            EdgeLoc = ErodeDilate {
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  XAmount = Input {
                     Value = 0.00068,
                     Expression = "EdgeBlur.EdgePosition",
                  },
                  Input = Input {
                     SourceOp = "MatteIn",
                     Source = "Mask",
                  },
               },
               ViewInfo = OperatorInfo { Pos = { -220, 142.15 } },
            },
            edgeBlurInput = BrightnessContrast {
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  Red = Input { Value = 0, },
                  Green = Input { Value = 0, },
                  Blue = Input { Value = 0, },
               },
               ViewInfo = OperatorInfo { Pos = { 110, 10.15 } },
            },
            Blend = Dissolve {
               Transitions = {
                  [0] = "DFTDissolve"
               },
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  Mix = Input { Expression = "EdgeBlur.Blend", },
                  Background = Input {
                     SourceOp = "edgeBlurInput",
                     Source = "Output",
                  },
                  Foreground = Input {
                     SourceOp = "Switch",
                     Source = "Output",
                  },
               },
               ViewInfo = OperatorInfo { Pos = { 330, 76.15 } },
            },
            MatteIn = BitmapMask {
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  MaskWidth = Input { Value = 1920, },
                  MaskHeight = Input { Value = 1080, },
                  PixelAspect = Input { Value = { 1, 1 }, },
                  ClippingMode = Input { Value = FuID { "None" }, },
               },
               ViewInfo = OperatorInfo { Pos = { -330, 142.15 } },
            },
            edgeDetect = Filter {
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  FilterType = Input { Value = 3, },
                  Input = Input {
                     SourceOp = "EdgeLoc",
                     Source = "Output",
                  },
               },
               ViewInfo = OperatorInfo { Pos = { -110, 142.15 } },
            },
            DilateMask = ErodeDilate {
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  XAmount = Input {
                     Value = 0.00675,
                     Expression = "EdgeBlur.EdgeWidth",
                  },
                  ClippingMode = Input { Value = FuID { "None" }, },
                  Input = Input {
                     SourceOp = "edgeDetect",
                     Source = "Output",
                  },
               },
               ViewInfo = OperatorInfo { Pos = { 0, 142.15 } },
            },
            BlurComp = Blur {
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  XBlurSize = Input {
                     Value = 7.3,
                     Expression = "EdgeBlur.Blur",
                  },
                  ClippingMode = Input { Value = FuID { "None" }, },
                  Input = Input {
                     SourceOp = "edgeBlurInput",
                     Source = "Output",
                  },
                  EffectMask = Input {
                     SourceOp = "BlurMask",
                     Source = "Output",
                  }
               },
               ViewInfo = OperatorInfo { Pos = { 110, 76.15 } },
            },
            BlurMask = Blur {
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  XBlurSize = Input {
                     Value = 0,
                     Expression = "EdgeBlur.EdgeMaskBlur",
                  },
                  ClippingMode = Input { Value = FuID { "None" }, },
                  Input = Input {
                     SourceOp = "DilateMask",
                     Source = "Output",
                  },
               },
               ViewInfo = OperatorInfo { Pos = { 110, 142.15 } },
            },
            Switch = Dissolve {
               Transitions = {
                  [0] = "DFTDissolve"
               },
               CtrlWShown = false,
               NameSet = true,
               Inputs = {
                  Mix = Input {
                     Value = 0,
                     Expression = "EdgeBlur.MaskView",
                  },
                  Background = Input {
                     SourceOp = "BlurComp",
                     Source = "Output",
                  },
                  Foreground = Input {
                     SourceOp = "BlurMask",
                     Source = "Output",
                  },
               },
               ViewInfo = OperatorInfo { Pos = { 220, 76.15 } },
            }
         },
         UserControls = ordered() {
            Blur = {
               INP_MaxAllowed = 10000,
               INP_Integer = false,
               INPID_InputControl = "SliderControl",
               INP_MaxScale = 100,
               INP_Default = 0,
               INP_MinScale = 0,
               INP_MinAllowed = 0,
               LINKID_DataType = "Number",
               ICS_ControlPage = "Controls",
               LINKS_Name = "Blur"
            },
            EdgeWidth = {
               INP_MaxAllowed = 10,
               INP_Integer = false,
               INPID_InputControl = "SliderControl",
               INP_MaxScale = 0.01,
               INP_Default = 0,
               INP_MinScale = -0.01,
               INP_MinAllowed = -10,
               LINKID_DataType = "Number",
               ICS_ControlPage = "Controls",
               LINKS_Name = "Edge Mask Erode/Dilate"
            },
            EdgePosition = {
               INP_MaxAllowed = 1,
               INPID_InputControl = "SliderControl",
               INP_MaxScale = 0.01,
               INP_Default = 0,
               INP_MinScale = -0.01,
               INP_MinAllowed = -1,
               LINKID_DataType = "Number",
               ICS_ControlPage = "Controls",
               LINKS_Name = "Edge Position"
            },
            EdgeMaskBlur = {
               INP_MaxAllowed = 10000,
               INP_Integer = false,
               INPID_InputControl = "SliderControl",
               INP_MaxScale = 100,
               INP_Default = 0,
               INP_MinScale = 0,
               INP_MinAllowed = 0,
               LINKID_DataType = "Number",
               ICS_ControlPage = "Controls",
               LINKS_Name = "Edge Mask Blur"
            },
            Blend = {
               INP_MaxAllowed = 10,
               INP_Integer = false,
               INPID_InputControl = "SliderControl",
               INP_MaxScale = 1,
               INP_Default = 1,
               INP_MinScale = 0,
               INP_MinAllowed = 0,
               LINKID_DataType = "Number",
               ICS_ControlPage = "Controls",
               LINKS_Name = "Blend"
            },
            MaskView = {
               INP_MaxAllowed = 1,
               INP_Integer = true,
               INPID_InputControl = "CheckboxControl",
               INP_MaxScale = 1,
               INP_Default = 0,
               INP_MinScale = 0,
               INP_MinAllowed = 0,
               LINKID_DataType = "Number",
               ICS_ControlPage = "Controls",
               CBC_TriState = false,
               LINKS_Name = "Mask View"
            }
         }
      }
   }
}


My Lightwrap is pretty basic. Invert the alpha and soften it, then multiply by the original alpha—that's what the two Bitmaps are doing. The result is an edge matte with falloff only to the inside. The Lightwrap Merge node has Alpha Gain turned all the way down, making it an Add. The Luma Keyer isolates the bright parts of the background—only the highlights create lightwrap. There should also be a Blur right after the LumaKeyer—you don't want any detail coming through there.

Usually the Lightwrap Merge node has its Blend turned down to almost nothing.

Hey, thx for this detailed answer... I'll check that the sooner I can, and compare to my own WF (given that maybe a bit more than 50% of you nodes purposes are provided by the options inside the Primatte node only) and check a few improvements if needed.
Very interesting anyway, I appreciate this input... Thx again Bryan.

I find Primatte difficult to control. Sometimes it gives a terrific one-click key, but if that doesn't happen I very quickly move onto other options. It's a different sort of keyer than I'm used to.

I learned on Keylight, which is a color difference keyer very similar to the new DeltaKeyer, and when The Foundry pulled the plug on new OFX licenses I decided to fill in the hole with a custom-built color difference keyer. The basic formula's available in Brinkmann's Art and Science of Digital Compositing, although I think the spill suppression in that implementation is too harsh. I believe it's the same one that Keylight's Hard Color mode uses—the one that tends to add a lot of red-brown noise.

Anyway, Delta's strictly superior to Keylight and does at least as good a job as my own MADKey most of the time. A hand-rolled keyer is still sometimes a nice thing to have in your pocket, though.

That Edge Blur macro I posted above is available in Reactor, as is a lightwrap that one of our other artists made: FastLightWrap. I think that one uses a soft glow approach rather than the LumaKeyer that I use.