Planar Tracker "Track Forward" does nothing

I should say "does nothing most of the time."

It worked once, but the track went off the rails because of some occlusion. So I adjusted the tracking area and tried to re-track. It did nothing.

I deleted the PlanarTracker node, re-added, and did it again. Again it worked once. Never again.

Now, deleting and restarting doesn't work. I insert the tracker, draw the shape, and press Track Forward. Nothing happens.

What is wrong with this thing? Resolve Studio 19.1.4, on Apple Silicon.

Without seeing the rest of your screen and optional error messages in the console it's really difficult to see why this wouldn't work. It could be a case of not having wired everything up in the correct way. But it could also be something else. Posting a video that says something is worthless while it's working for a lot of people seems a bit harsh, but I can imaging being frustrated by this.

Can you show us the rest of the setup and some screenshots of the error messages (if any) in the console window?

It looks like pilot error to me. In that area you are trying to track I can see only three possible features, at a stretch, that could be tracked. Those rounded features may or may not be trackable. When tracking in perspective you need at least four trackable features, that is why the tracker will not start. You might get away with Affine or you might have to use Translation, Rotation, Scale. Depending on how many trackers you can get you might have to go even looser or use a different tracker.

What is wrong with this thing... is that you are almost certianly using it for something that is not intended. Your traceable area is limited in tradable features as Iain mentioned.

Still, it *should* start and then give errors. If it's not starting it might be a sign something else is wrong.

No, here try a simple test yourself. Move the search area so that it covers only three corners and try Perspective. Then so that it covers just two corners, now Affine doesn't start and all the way to one corner covered and see what you can do.

Code: Select all

{
   Tools = ordered() {
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 300, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
         },
         ViewInfo = OperatorInfo { Pos = { 84, 10.3939 } },
      },
      Background2 = Background {
         Inputs = {
            GlobalOut = Input { Value = 300, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 1, },
         },
         ViewInfo = OperatorInfo { Pos = { 84, 54.0303 } },
      },
      Merge1 = Merge {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            },
            Background = Input {
               SourceOp = "Background2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 219.333, 54.6364 } },
      },
      Rectangle1 = RectangleMask {
         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 {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.09, },
            Height = Input { Value = 0.16, },
         },
         ViewInfo = OperatorInfo { Pos = { 218.667, 84.9394 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { LockY = true, X = -0.321373551693405, Y = -0.247508137591273, RX = 0.0375932739350918, RY = -0.136966282434122 },
                     { LockY = true, X = 0.413874264705882, Y = -0.253241400545439, LX = 0.137810547187489, LY = -0.276352912483443, RX = -0.0690971918129052, RY = 0.0352213774460087 },
                     { X = 0.405885181152247, Y = -0.0944172268571967, LX = -0.0147120711233306, LY = -0.0711849425861277, RX = 0.0393279953475341, RY = 0.344599760507643 },
                     { X = 0.266738323195796, Y = -0.11666669343458, LX = -0.030943079874374, LY = 0.145438873753268, RX = 0.0566920992802611, RY = -0.308904355341198 },
                     { LockY = true, X = -0.089572192513369, Y = 0.0237529691211401, LX = -0.0963583558750425, LY = -0.203401329595518, RX = 0.0627639477803465, RY = 0.210995186222716 },
                     { LockY = true, X = 0.329771056149733, Y = 0.232574557930852, LX = 0.0377738295802234, LY = -0.115396985030781, RX = -0.0265837776637721, RY = 0.109158586587075 },
                     { LockY = true, X = -0.335069622101252, Y = 0.287427378420736, LX = 0.0490282839708146, LY = 0.0551569953423556, RX = -0.0575352883693742, RY = -0.0641865982721178 },
                     { LockY = true, X = -0.238598417098997, Y = -0.0608208365272486, LX = -0.151709278152855, LY = -0.132879120324601 }
                  }
               },
            },
         },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         CtrlWZoom = false,
         KeyFrames = {
            [0] = { 0, RH = { 20, 0.077536470769376 }, Flags = { Linear = true, LockedY = true } },
            [60] = { 0.232609412308128, LH = { 40, 0.155072941538752 }, RH = { 80, 0.343253832101726 }, Flags = { Linear = true, LockedY = true } },
            [120] = { 0.564542671688922, LH = { 100, 0.453898251895324 }, RH = { 140, 0.60882326800362 }, Flags = { Linear = true, LockedY = true } },
            [180] = { 0.697384460633017, LH = { 160, 0.653103864318319 }, RH = { 200, 0.757397154248254 }, Flags = { Linear = true, LockedY = true } },
            [240] = { 0.877422541478729, LH = { 220, 0.817409847863492 }, RH = { 260, 0.918281694319153 }, Flags = { Linear = true, LockedY = true } },
            [300] = { 1, LH = { 280, 0.959140847159576 }, Flags = { Linear = true, LockedY = true } }
         }
      },
      PlanarTracker1 = Dimension.PlanarTracker {
         CtrlWZoom = false,
         NameSet = true,
         Inputs = {
            Background = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
            ["Pattern.Polygon"] = Input {
               Value = Polyline {
                  Closed = true,
                  Points = {
                     { Linear = true, X = -0.377005347593583, Y = -0.160332541567696, LX = 0.0374331550802139, LY = 0.00158353127474267, RX = 0.000891265597147954, RY = -0.058590657165479 },
                     { Linear = true, X = -0.374331550802139, Y = -0.336104513064133, LX = -0.000891265597147954, LY = 0.058590657165479, RX = 0.0352049910873441, RY = -0.000791765637371341 },
                     { Linear = true, X = -0.268716577540107, Y = -0.338479809976247, LX = -0.0352049910873441, LY = 0.000791765637371341, RX = 0.00133689839572187, RY = 0.060965954077593 },
                     { Linear = true, X = -0.264705882352941, Y = -0.155581947743468, LX = -0.00133689839572187, LY = -0.060965954077593, RX = -0.0374331550802139, RY = -0.00158353127474267 }
                  }
               },
            },
            MotionType = Input { Value = FuID { "Affine" }, },
            Track = Input {
               SourceOp = "PlanarTracker1Track",
               Source = "Value",
            },
            TrackDummy = 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 } }, },
            NumberOfCornerPins = Input { Value = 2, },
            ["CornerPin1.Nest"] = Input { Value = 1, },
            ["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 } }, },
            ["CornerPin2.Nest"] = Input { Value = 1, },
            ["CornerPin2.TopLeft"] = Input { Value = { 0, 1 }, },
            ["CornerPin2.TopRight"] = Input { Value = { 1, 1 }, },
            ["CornerPin2.BottomLeft"] = Input { Value = { 0, 0 }, },
            ["CornerPin2.BottomRight"] = Input { Value = { 1, 0 }, },
         },
         ViewInfo = OperatorInfo { Pos = { 347.333, 54.6364 } },
      },
      PlanarTracker1Track = BezierSpline {
         SplineColor = { Red = 244, Green = 1, Blue = 129 },
         PlanarTrackWidth = 1920,
         PlanarTrackHeight = 1080,
         PlanarTrackPixelAspectX = 1,
         PlanarTrackPixelAspectY = 1,
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0, Flags = { Linear = true, LockedY = true }, Value = Matrix { RefTime = 0, IsBogus = true, ToRef = { [0] = 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } }
         }
      }
   },
   ActiveTool = "PlanarTracker1"
}

Thanks for the replies. It looked to me like there was enough of a pattern there to track.

The problem is indeed, however, the tracker's attempt to automatically find extra points. I'm used to trackers where you explicitly add and position the tracking points. In this example it looked to me like there was enough for the tracker to work with. Expanding the tracking area (and/or switching to point tracking) gave the thing enough to work with, and all was well.

Actually, I would say the issue was the lack of sufficient tracking points. The problem is that Resolve neglected to display an error message. Based on threads found elsewhere, I learned that you have to dig up the console and check it for a message in this case. Why allow the user to press Go on a process that immediately fails, and not notify him? Baffling.