double-zoom corner positioner/tracker

feels like i'm missing something obvious, i just can't wrap my head around it

i tracked a picture frame, corner positioned a video on top of it, all good. Now i want to make an animated zoom in on the frame until it fits the screen, but that obviously makes the video super-blurry.

what would be a good workflow to retain the quality of the video?

Assuming the inserted picture is of a high enough resolution i would assume you would just track backwards from zooming the frame into full screen and then use a full raster corner pin.
Is this what you mean, i assume you are using the transform node to zoom your original frame right in. You will need to retrack this as the tracking data makes the post too large.

Code: Select all

{
   Tools = ordered() {
      Text2 = TextPlus {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            StyledText = Input { Value = "THING ON TOP", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            Size = Input { Value = 0.1109, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
         },
         ViewInfo = OperatorInfo { Pos = { 522.667, -3.54546 } },
      },
      Merge2 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Text2",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 523.333, 31.6061 } },
      },
      PlanarTracker1 = Dimension.PlanarTracker {
         CtrlWZoom = false,
         Inputs = {
            Background = Input {
               SourceOp = "Transform1",
               Source = "Output",
            },
            ReferenceTime = Input { Value = 300, },
            ["Pattern.Polygon"] = Input {
               Value = Polyline {
                  Closed = true,
                  Points = {
                     { Linear = true, X = -0.511342155009452, Y = 0.516835016835017, LX = 0.34341524889729, LY = 0.00112233445566775, RX = 0.00126023944549466, RY = -0.343434343434343 },
                     { Linear = true, X = -0.507561436672968, Y = -0.513468013468014, LX = -0.00126023944549466, LY = 0.343434343434343, RX = 0.339634530560807, RY = -0.00224466891133557 },
                     { Linear = true, X = 0.511342155009452, Y = -0.52020202020202, LX = -0.339634530560807, LY = 0.00224466891133557, RX = 0.00252047889098924, RY = 0.346801346801347 },
                     { Linear = true, X = 0.51890359168242, Y = 0.52020202020202, LX = -0.00252047889098924, LY = -0.346801346801347, RX = -0.34341524889729, RY = -0.00112233445566775 }
                  }
               },
            },
            Track = Input {
               SourceOp = "PlanarTracker1TrackDummy",
               Source = "Value",
            },
            TrackDummy = Input { Value = Matrix { RefTime = 300, IsBogus = true, ToRef = { [0] = 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } }, },
            ["CornerPin1.Nest"] = Input { Value = 1, },
            ["CornerPin1.Image"] = Input {
               SourceOp = "Merge2",
               Source = "Output",
            },
            ["CornerPin1.TopLeft"] = Input { Value = { 0, 1 }, },
            ["CornerPin1.TopRight"] = Input { Value = { 1, 1 }, },
            ["CornerPin1.BottomLeft"] = Input { Value = { 0, 0 }, },
            ["CornerPin1.BottomRight"] = Input { Value = { 1, 0 }, },
            StableTrack = Input { Value = Matrix { RefTime = 0, IsBogus = true, ToRef = { [0] = 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } }, },
         },
         ViewInfo = OperatorInfo { Pos = { 544.667, 81.9091 } },
      },
      PlanarTracker1TrackDummy = BezierSpline {
         SplineColor = { Red = 244, Green = 1, Blue = 129 },
         PlanarTrackWidth = 1920,
         PlanarTrackHeight = 1080,
         PlanarTrackPixelAspectX = 1,
         PlanarTrackPixelAspectY = 1,
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [300] = { 0, Flags = { LockedY = true }, Value = Matrix { RefTime = 300, IsBogus = true, ToRef = { [0] = 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } }
         }
      },
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftBlue = Input { Value = 1, },
         },
         ViewInfo = OperatorInfo { Pos = { 412, 32.2121 } },
      },
      Transform1 = Transform {
         Inputs = {
            Center = Input {
               SourceOp = "Path2",
               Source = "Position",
            },
            Size = Input {
               SourceOp = "Transform1Size",
               Source = "Value",
            },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 286, 80.697 } },
      },
      Path2 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path2Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, LockY = true, X = -0.195139037433155, Y = 0.158503562945368, RX = 0.100713012477718, RY = -0.00950118764845605 },
                     { Linear = true, LockY = true, X = 0.107, Y = 0.13, LX = -0.100713012477718, LY = 0.00950118764845605, RX = -0.0356666666666667, RY = -0.0433333333333333 },
                     { Linear = true, LockY = true, X = 0, Y = 0, LX = 0.0356666666666667, LY = 0.0433333333333333 }
                  }
               },
            },
         },
      },
      Path2Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 178 },
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 65.6666666666667, 0.2143895750445 }, Flags = { Linear = true, LockedY = true } },
            [197] = { 0.6431687251335, LH = { 131.333333333333, 0.428779150089 }, RH = { 231.333333333333, 0.762112483422333 }, Flags = { Linear = true, LockedY = true } },
            [300] = { 1, LH = { 265.666666666667, 0.881056241711167 }, Flags = { Linear = true, LockedY = true } }
         }
      },
      Transform1Size = BezierSpline {
         SplineColor = { Red = 225, Green = 0, Blue = 225 },
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0.342, RH = { 65.6666666666667, 0.421 }, Flags = { Linear = true } },
            [197] = { 0.579, LH = { 131.333333333333, 0.5 }, RH = { 231.333333333333, 0.719333333333333 }, Flags = { Linear = true } },
            [300] = { 1, LH = { 265.666666666667, 0.859666666666667 }, Flags = { Linear = true } }
         }
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Background2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Text1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 162.667, 79.4848 } },
      },
      Text1 = TextPlus {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Blue1 = Input { Value = 0, },
            Alpha1 = Input { Value = 0, },
            StyledText = Input { Value = "ZOOM IN", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            Size = Input { Value = 0.1654, },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
         },
         ViewInfo = OperatorInfo { Pos = { 163.333, 45.5455 } },
      },
      Background2 = Background {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.827, },
         },
         ViewInfo = OperatorInfo { Pos = { 56, 79.4848 } },
      }
   },
   ActiveTool = "PlanarTracker1"
}

Corner positioning filters/resizes the image destructively i.e. it makes actual new pixels i.e. your new image is of lower resolution. Zooming in on the picture frame will make that footage look blurry as well, depending on how much you need to zoom into it.

Fusion will retain the original source resolution if you use contatenated tools like regular transforms and merge without any pixel changing tools between them, so in this case the best way to do this probably is by *starting* with the zoomed in image as big as what will allow for tracking, then use a corner positioner based on those tracks, then use the corner positioner over a transparent background, merge that over the original zoomed in footage and then put a transform after that merge to zoom out and back in again.

thanks for the advice guys. The camera motion is quite big, so to retain as much pixels as possible (or 100% actually), i eventually did it a little different. I tracked the picture frame the "normal" way, with the 4 trackers on the original footage, corner positioned the new video on the frame, and did the zoom animation, just like before with the eventually blurry video.

After that i merged the original, high quality video over the DVE with the zoom animation with another corner positioner, and manually repositioned the corners frame by frame to exactly match the zoom animation. So basically scaled it down, and back up, to exactly the canvas resolution. I only did that in the timeframe of the zoom, about 20 frames so not too much work. Then gradually animated the blend of that merge. feels a bit cumbersome, but it works..

A suggestion for the next time you want to do this manually: if you're going to replace the corner tracked image anyway, why not cornerposition a black image with white dots at its corners, so matching it by hand afterwards is even easier?