Displacement not tracking WritePosition + WriteLength

Hi all,

I'm trying to lock the center point of an image (via a Transform tool) to the endpoint of a line that's being defined on a Polygon tool and is animating its WritePosition and WriteLength controls. (So, not the end of the bezier curve, but the end as determined by the WritePosition and WriteLength).

I've added a Path to the center point control of my Transform node and connected that to the Polygon tool.

Then I've created the expression:

Code: Select all

MyPolygon.WritePosition + MyPolygon.WriteLength

for the displacement control on the Path.

This works, but it is very inaccurate. When the curve on the polygon tool gets curvy, the image jumps ahead or behind the end of the rendered line. I can't imagine why this would be as these numbers should be coming from the same source.

I spent all day writing code to do this instead, and ended up with the exact same inaccurate animation.

Is there a way to animate this accurately without manually keyframing? I have a LOT of this to do.

ALSO: BMD, please make it possible to copy via keyboard from the Console window! It's super frustrating to have to use the mouse context menu!

Is this the problem you found?

If so I think one of the issues is that aspect ratio not being square throws off the calculations. Probably a bug or unfinished feature. Not sure if it worked before. But one method involves using shapes or using cropped frame to a square to force calculations to be correct.

Hi Kruno,

Yep, that looks like the problem. Thanks for the video... it was very useful (if disappointing that it's an unresolved bug).

-- Chris

I don't think that is a bug, it's just unintuitive because 'Displacement' is purely time displacement unrelated to distance or speed.
The Displacement represents only time displacement from 0 at the start, to 1 at the end. It doesn't relate to distance at all. Speed is distance/time, so if the line is keyframed to draw from start to finish in a certain time, if you change the distance from start to finish then the speed will need to change.
Let say you and a friend regularly walk equal distances to the top of the street on opposite pavements. You must do it in one minute and you do it in sync with each other. One day a car blocks the pavement on your friends side, so he needs to go round the car. He will have to travel a greater distance. So to get to the top of the street in one minute, he will need to travel slightly faster than you and so get out of sync, so that you will both arrive at the same time.
Vertical 0-1 distance is different from horizontal 0-1 distance in a 16:9 Frame, So a line drawn from left to right must travel faster than a line drawn top to bottom, if they are to reach their end point in the same Displacement (time). If you mix vertical and horizontal movements in varying ways using 'Displacement', you may not see what you expect to see.

It is a bug, because it doesn't take the aspect ratio of the image into account. If it works with a 1:1 frame, it should also work in a 16:9 frame. Other tools like the off-set modifier and vector result allow for adjusting for aspect ratio, this should work the same way.

I am not familiar enough with the control to say whether it is affected by aspect ratio. In the other thread someone claimed that it was and had done tests so I accepted it.
I suspect the Displacement control functions in a similar way to the Keyframe Stretcher. The Keyframe Stretcher doesn't change the position of anything, it changes the time at which a position or event occurs. The Offset Modifiers offset position, distance and angle, the Displacement control I think does none of that, it simply defines the time that those changes of position, distance and angle occur. I'm curious enough now to do a few test later, it's another control that I routinely ignore but it may be quite useful depending on what's up.

Here is an example of what I am seeing. I created a path using a Polyline mask, connected the Rectangle mask to that path. If you go to the Path Modifier of the Rectangle mask and use the Displacement slider to move the mask, the mask will move from 0 - the start of the path to 1 - the end. Now move the Displacement slider to 0.5 and change the length of the Polygon line. The Rectangle mask moves to a position that is halfway along the new length of the whole path. The Displacement slider has no control over position etc but only on the proportional distance of the total line length. The rectangle will move to half way along the line no matter what length you make that line. If you keyframe the Displacement slider to lets say 0.25, 0.5, 0.75, I would expect the ratios along the line would be maintained as you change the line length. Something to play with for short while I suppose.
Have you an example of to show what you mean about the aspect ratio? I remember there was an example or two in some other thread but I didn't test it myself and just accepted it.

Code: Select all

{
   Tools = ordered() {
      Rectangle1 = RectangleMask {
         CtrlWZoom = false,
         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.045, },
            Height = Input { Value = 0.08, },
         },
         ViewInfo = OperatorInfo { Pos = { 105.333, 6.15151 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input { Value = 0.5, },
            PolyLine = Input {
               SourceOp = "Publish1",
               Source = "Value",
            },
         },
      },
      Publish1 = PublishPolyLine {
         CtrlWZoom = false,
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { X = -0.393992312834224, Y = -0.0890528974852013, RX = 0.0217053944503346, RY = -0.123507248223021 },
                     { X = -0.292460450089126, Y = -0.341509256117332, LX = -0.0532078420737546, LY = 0.0420063737279712, RX = 0.203510522228028, RY = -0.160666900236909 },
                     { X = 0.375559826203209, Y = -0.346083587829431, LX = -0.211592286623758, LY = -0.123333469743534, RX = 0.0840695220190424, RY = 0.0490026645854349 },
                     { X = 0.141441065062389, Y = -0.124828136585856, LX = -0.0133778563768603, LY = -0.155476719301268, RX = 0.0154082660563764, RY = 0.179074030179471 },
                     { X = 0.359636809269162, Y = 0.255496487325466, LX = 0.0830734870682629, LY = -0.10491254652064, RX = -0.139437184536378, RY = 0.176093608510248 },
                     { X = -0.153325534759358, Y = 0.277775264236072, LX = 0.144061830405235, LY = 0.163906347215232, RX = -0.058645993064335, RY = -0.0667244784752904 },
                     { X = -0.240274064171123, Y = -0.0598006133041762, LX = -0.0361912405099648, LY = 0.105747694785128, RX = 0.0510465818398678, RY = -0.149153725602196 },
                     { X = 0.0543226381461677, Y = -0.0588624338624338, LX = -0.131739743279157, LY = -0.0832950438545096 }
                  }
               },
            },
         },
      },
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.717, },
            EffectMask = Input {
               SourceOp = "Rectangle1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 104.667, 40.0909 } },
      },
      Polygon1 = PolylineMask {
         DrawMode = "ModifyOnly",
         DrawMode2 = "InsertAndModify",
         CtrlWZoom = false,
         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" }, },
            Polyline = Input {
               SourceOp = "Publish1",
               Source = "Value",
            },
            Polyline2 = Input {
               Value = Polyline {
               },
               Disabled = true,
            },
         },
         ViewInfo = OperatorInfo { Pos = { 266.667, 38.2727 } },
      }
   },
   ActiveTool = "Polygon1"
}

I went back and did another test the result of which suggests that the aspect ratio has no effect on the Displacement control result. I made a roughly rectangular polygon on a 16:9 background and moved the object 3/4 of the way round the path. So the object has moved along two shorter vertical moves and one horizontal. The object moved to the third corner. I then changed the background to 1:1 and the object still moved to the third corner. So the Displacement control appears to work on the 0-1 system both vertically and horizontally regardless of the background ratio.
No matter what ratio is used in Background1_1, moving the Displacement slider in Rectangle1_1 to 0.75
puts the object at the third corner. As far as I can see the 0-1 convention is being followed. Is there something I am overlooking?

Code: Select all

{
   Tools = ordered() {
      Rectangle1_1 = RectangleMask {
         CtrlWZoom = false,
         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 = "Path2",
               Source = "Position",
            },
            Width = Input { Value = 0.045, },
            Height = Input { Value = 0.08, },
         },
         ViewInfo = OperatorInfo { Pos = { 520.666, 44.9394 } },
      },
      Path2 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input { Value = 0.75, },
            PolyLine = Input {
               SourceOp = "Publish2",
               Source = "Value",
            },
         },
      },
      Publish2 = PublishPolyLine {
         CtrlWZoom = false,
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, X = -0.457219251336898, Y = 0.435889605248275, RX = -0.000445632798573995, RY = -0.293763903027561 },
                     { Linear = true, X = -0.45855614973262, Y = -0.445402103834408, LX = 0.000445632798573995, LY = 0.293763903027561, RX = 0.307040998217469, RY = -0.000786110168533027 },
                     { Linear = true, X = 0.462566844919786, Y = -0.447760434340007, LX = -0.307040998217469, LY = 0.000786110168533027, RX = -0.00215364498582702, RY = 0.294225290379813 },
                     { Linear = true, X = 0.456105909962305, Y = 0.434915436799432, LX = 0.00215364498582702, LY = -0.294225290379813, RX = -0.298648494051606, RY = 0.00111837360993193 },
                     { Linear = true, X = -0.439839572192513, Y = 0.438270557629227, LX = 0.298648494051606, LY = -0.00111837360993193 }
                  }
               },
            },
         },
      },
      Background1_1 = Background {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Rectangle1_1",
               Source = "Mask",
            },
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 0.717, },
         },
         ViewInfo = OperatorInfo { Pos = { 520.666, 79.4848 } },
      },
      Polygon2 = PolylineMask {
         DrawMode = "ModifyOnly",
         DrawMode2 = "InsertAndModify",
         CtrlWZoom = false,
         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" }, },
            Polyline = Input {
               SourceOp = "Publish2",
               Source = "Value",
            },
            Polyline2 = Input {
               Value = Polyline {
               },
               Disabled = true,
            },
         },
         ViewInfo = OperatorInfo { Pos = { 650, 80.0909 } },
      }
   },
   ActiveTool = "Polygon2"
}

It's not that the points on the displacement don't match. It's the fact that the 'timing' of the write on/write on (0-1) not correlates 1:1 if you use the same value for displacement. The fact that this problem does not exist on square images, points very strongly to it being an aspect ratio issue.

Ah yes i see what you mean, I tried a few different ways, one the same-ish from the video posted and one linked to the write on of the Paint node, both came out the same. It was interesting none the less.
There is another bug at least one I am seeing, when I reopen a saved comp of this type the keyframes are mixed up, I always suspect obsolete this hardware first but something is not right with this. These first nodes I posted are typical it should behave like the second but the keyframes changed , ho hum it a hard life. That's very weird those first nodes just will not save properly, it works until it's saved.

Code: Select all

{
   Tools = ordered() {
      Text1 = TextPlus {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            StyledText = Input { Value = "l", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
         },
         ViewInfo = OperatorInfo { Pos = { 183.333, 17.6667 } },
      },
      Background1 = Background {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Text1",
               Source = "Output",
            },
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
         },
         ViewInfo = OperatorInfo { Pos = { 183.333, 52.8182 } },
      },
      Transform1 = Transform {
         Inputs = {
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Angle = Input {
               SourceOp = "Path1",
               Source = "Heading",
            },
            Input = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 183.333, 86.1516 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement1",
               Source = "Value",
            },
            PolyLine = Input {
               SourceOp = "Publish1",
               Source = "Value",
            },
         },
      },
      Path1Displacement1 = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 166.666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true } },
            [500] = { 1, LH = { 333.333333333333, 0.666666666666667 }, Flags = { Linear = true } }
         }
      },
      Publish1 = PublishPolyLine {
         CtrlWZoom = false,
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { X = -0.415775401069519, Y = 0.347619047619048, RX = 0.0134074691820079, RY = -0.33564055825873 },
                     { X = -0.252673796791444, Y = -0.319047619047619, LX = -0.136286665914059, LY = -0.0046144498507929, RX = 0.141876202041804, RY = 0.00480370265830482 },
                     { X = -0.0641711229946524, Y = 0.35952380952381, LX = -0.140802274973642, LY = -0.0313452683572275, RX = 0.132634160045174, RY = 0.0295268903910089 },
                     { X = 0.164438502673797, Y = -0.226190476190476, LX = -0.132539944017789, LY = 0.0308350114289347, RX = 0.0986640068839675, RY = -0.0229538785642109 },
                     { X = 0.232620320855615, Y = 0.29047619047619, LX = -0.099256557417428, LY = 0.0124989738970094, RX = 0.121866939313206, RY = -0.0153462071727741 },
                     { X = 0.429144385026738, Y = -0.259523809523809, LX = -0.0373285624289586, LY = 0.267326896413613 }
                  }
               },
            },
         },
      },
      Merge1 = Merge {
         CtrlWZoom = false,
         Inputs = {
            Background = Input {
               SourceOp = "Transform1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Polygon1",
               Source = "Mask",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 343.333, 84.3333 } },
      },
      Polygon1 = PolylineMask {
         DrawMode = "ModifyOnly",
         DrawMode2 = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            BorderWidth = Input { Value = 0.0079, },
            WriteLength = Input {
               SourceOp = "Path1Displacement1",
               Source = "Value",
            },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Polyline = Input {
               SourceOp = "Publish1",
               Source = "Value",
            },
            Polyline2 = Input {
               Value = Polyline {
               },
               Disabled = true,
            },
         },
         ViewInfo = OperatorInfo { Pos = { 343.333, 47.9697 } },
      }
   },
   ActiveTool = "Merge1"
}

Code: Select all

{
   Tools = ordered() {
      Text1 = TextPlus {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            StyledText = Input { Value = "l", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
         },
         ViewInfo = OperatorInfo { Pos = { 602.667, 15.2424 } },
      },
      Background2 = Background {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
            EffectMask = Input {
               SourceOp = "Text1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 602, 48.5758 } },
      },
      Transform1 = Transform {
         CtrlWZoom = false,
         Inputs = {
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Angle = Input {
               SourceOp = "Path1",
               Source = "Heading",
            },
            Input = Input {
               SourceOp = "Background2",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 602, 83.7273 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               Value = 0.588867072,
               Expression = "PolylineStroke1.WriteOnEnd",
            },
            PolyLine = Input {
               SourceOp = "Publish2",
               Source = "Value",
            },
         },
      },
      Publish2 = PublishPolyLine {
         CtrlWZoom = false,
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { X = -0.415989861853832, Y = 0.182209465998064, RX = -0.000199752789095638, RY = -0.271725349280978 },
                     { X = -0.309249665775401, Y = -0.356932348024985, LX = -0.107165869581566, LY = -0.000929351714527638, RX = 0.115396076267352, RY = 0.00100072478063838 },
                     { X = -0.140769830659537, Y = 0.180760095011877, LX = -0.115378240563351, LY = 0.00374300861519493, RX = 0.111835230492732, RY = -0.00362806911574149 },
                     { X = -0.0101242201426026, Y = -0.368687868390956, LX = -0.11148798072016, LY = 0.0160703395632684, RX = 0.115395783285678, RY = -0.0166336264195572 },
                     { X = 0.161238302139037, Y = 0.168441541303774, LX = -0.115749359532679, LY = 0.00428701331602459, RX = 0.10084917151871, RY = -0.00373515450069296 },
                     { X = 0.290792112299465, Y = -0.317759743116038, LX = -0.100674616352779, LY = 0.0111860684836416, RX = 0.0935477182167888, RY = -0.0103941909129765 },
                     { X = 0.399980503565062, Y = 0.142918096243512, LX = -0.00825586902702895, LY = -0.242792228373067 }
                  }
               },
            },
         },
      },
      Paint1 = Paint {
         Inputs = {
            Input = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            Paint = Input {
               SourceOp = "PolylineStroke1",
               Source = "Out",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 733.333, 35.8485 } },
      },
      PolylineStroke1 = PolylineStroke {
         Points = {
         },
         IsThreaded = true,
         Brushes = { "SoftBrush" },
         ApplyModes = { "PaintApplyColor" },
         CtrlWZoom = false,
         Inputs = {
            BrushControls = Input { Value = 1, },
            StrokeControls = Input { Value = 1, },
            WriteOnStart = Input {
               SourceOp = "PolylineStroke1Start",
               Source = "Value",
            },
            WriteOnEnd = Input {
               SourceOp = "PolylineStroke1End",
               Source = "Value",
            },
            Polyline = Input {
               SourceOp = "Publish2",
               Source = "Value",
            },
         },
      },
      PolylineStroke1Start = BezierSpline {
         SplineColor = { Red = 232, Green = 6, Blue = 244 },
         CtrlWZoom = false,
         KeyFrames = {
            [0] = { 0, RH = { 166.666666666667, 0 }, Flags = { Linear = true } },
            [500] = { 0, LH = { 333.333333333333, 0 }, Flags = { Linear = true } }
         }
      },
      PolylineStroke1End = BezierSpline {
         SplineColor = { Red = 72, Green = 233, Blue = 54 },
         CtrlWZoom = false,
         KeyFrames = {
            [0] = { 0, RH = { 166.666666666667, 0.329344 }, Flags = { Linear = true } },
            [500] = { 0.988032, LH = { 333.333333333333, 0.658688 }, Flags = { Linear = true } }
         }
      },
      Merge1 = Merge {
         CtrlWZoom = false,
         Inputs = {
            Background = Input {
               SourceOp = "Transform1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Paint1",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 733.333, 83.7273 } },
      },
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftAlpha = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 734, -1.12115 } },
      }
   },
   ActiveTool = "Merge1"
}

If you make the aspect ratio 1:1 in background node for the arrow tip and path stroke, that it kind of works, but its cumbersome to try to adjust it later and not get cut offs and sometimes I get some weird rendering that looks a bit like a glitch. Probably best done with shape system. Maybe if someone made a clever macro for it.

sshot-1176.jpg (56.06 KiB) Viewed 1892 times

Code: Select all

{
   Tools = ordered() {
      Transform1 = Transform {
         Inputs = {
            Center = Input {
               SourceOp = "Pathtransform",
               Source = "Position",
            },
            Size = Input { Value = 0.111, },
            Angle = Input {
               SourceOp = "Pathtransform",
               Source = "Heading",
            },
            Input = Input {
               SourceOp = "Transform2",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 770.558, 34.4104 } },
      },
      Pathtransform = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         NameSet = true,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               SourceOp = "Publish1",
               Source = "Value",
            }
         },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 7.99951604509974, 0.101177772769108 }, Flags = { LockedY = true } },
            [24] = { 0.303551681472793, LH = { 15.9996082313232, 0.202362832563504 }, RH = { 49.3327653235242, 0.905263793724965 }, Flags = { LockedY = true } },
            [100] = { 1, LH = { 74.6693529299191, 0.891054168739095 }, Flags = { LockedY = true } }
         }
      },
      Publish1 = PublishPolyLine {
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { LockY = true, X = -0.304658266513937, Y = -0.27108784176847, RX = 0.19774473936942, RY = 0.0207427197916986 },
                     { LockY = true, X = 0.30497946249322, Y = -0.139114570508098, LX = 0.00212454882211532, LY = -0.214034022775253, RX = -0.002021029811079, RY = 0.203605177774059 },
                     { X = -0.360145922360261, Y = 0.0574436740251497, LX = 0.00512087520727561, LY = -0.206118861118502, RX = -0.00608215502773517, RY = 0.244811056063573 },
                     { LockY = true, X = 0.325925925925926, Y = 0.366666666666667, LX = -0.244032764410593, LY = -0.0594918336899918 }
                  }
               },
            }
         },
      },
      Background4 = Background {
         Inputs = {
            GlobalOut = Input { Value = 100, },
            Width = Input { Value = 1080, },
            Height = Input { Value = 1080, },
            Depth = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftGreen = Input { Value = 0.666666666666667, },
            TopLeftBlue = Input { Value = 1, },
            GradientType = Input { Value = FuID { "Radial" }, },
            Start = Input { Value = { 0.5, 0.5 }, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 1, 1, 1, 1 },
                     [1] = { 0, 0, 0, 1 }
                  }
               },
            },
            EffectMask = Input {
               SourceOp = "BSpline1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 380.544, 111.116 } },
      },
      Merge3 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Transform1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Background4",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 770.558, 111.116 } },
      },
      Transform2 = Transform {
         HoldOutput = true,
         Inputs = {
            Angle = Input { Value = -90, },
            Input = Input {
               SourceOp = "Background4_1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 392.492, 34.4104 } },
      },
      Background4_1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 100, },
            Width = Input { Value = 1080, },
            Height = Input { Value = 1080, },
            Depth = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
            GradientType = Input { Value = FuID { "Radial" }, },
            Start = Input { Value = { 0.5, 0.5 }, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 1, 1, 1, 1 },
                     [1] = { 0, 0, 0, 1 }
                  }
               },
            },
            EffectMask = Input {
               SourceOp = "Triangle1",
               Source = "Mask",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 224.981, 34.4104 } },
      },
      Triangle1 = TriangleMask {
         CtrlWZoom = false,
         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" }, }
         },
         ViewInfo = OperatorInfo { Pos = { 224.981, -70.9191 } },
      },
      BSpline1 = BSplineMask {
         DrawMode = "ClickAppend",
         DrawMode2 = "InsertAndModify",
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            BorderWidth = Input { Value = 0.02, },
            Solid = Input { Value = 0, },
            WriteLength = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            OutputSize = Input { Value = FuID { "Custom" }, },
            MaskWidth = Input { Value = 1080, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            Depth = Input { Value = 1, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Polyline = Input {
               SourceOp = "Publish1",
               Source = "Value",
            },
            Polyline2 = Input {
               Value = BSplinePolyline {
                  Order = 4,
                  Type = "Tensioned",
                  Knots = { }
               },
               Disabled = true,
            }
         },
         ViewInfo = OperatorInfo { Pos = { 220.267, 111.116 } },
      },
      Merge2 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Background4_2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Merge3",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { 770.558, 233.702 } },
      },
      Background4_2 = Background {
         Inputs = {
            GlobalOut = Input { Value = 100, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            Depth = Input { Value = 3, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            Type = Input { Value = FuID { "Gradient" }, },
            TopLeftAlpha = Input { Value = 0, },
            GradientType = Input { Value = FuID { "Radial" }, },
            Start = Input { Value = { 0.5, 0.5 }, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 0.666666666666667, 0, 0, 1 },
                     [1] = { 0, 0, 0, 1 }
                  }
               },
            },
            Offset = Input { Value = -0.254, }
         },
         ViewInfo = OperatorInfo { Pos = { 228.498, 233.702 } },
      }
   }
}

Just to take a more simple view of the problem, I stripped the function down to a very basic move, two points and a straight line and the sync problem doesn't occur. I then took a copy of that set up and adjusted one point to make a curve and there was the problem again. Maybe my...parable about you and your friend walking down the street wasn't complete gibberish, although I guess it's more to do with how curves are handled. Changing the line back to linear and the problem is gone.

Code: Select all

{
   Tools = ordered() {
      Text1 = TextPlus {
         Inputs = {
            GlobalOut = Input { Value = 200, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            StyledText = Input { Value = "l", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
         },
         ViewInfo = OperatorInfo { Pos = { 163.333, 18.8788 } },
      },
      Background1 = Background {
         Inputs = {
            GlobalOut = Input { Value = 200, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
            EffectMask = Input {
               SourceOp = "Text1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { 164, 52.8182 } },
      },
      Polygon1 = PolylineMask {
         DrawMode = "ClickAppend",
         DrawMode2 = "InsertAndModify",
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            BorderWidth = Input { Value = 0.008, },
            WriteLength = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Polyline = Input {
               SourceOp = "Publish1",
               Source = "Value",
            },
            Polyline2 = Input {
               Value = Polyline {
               },
               Disabled = true,
            },
         },
         ViewInfo = OperatorInfo { Pos = { 326.667, 53.4242 } },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 66.6666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true } },
            [200] = { 1, LH = { 133.333333333333, 0.666666666666667 }, Flags = { Linear = true } }
         }
      },
      Publish1 = PublishPolyLine {
         CtrlWZoom = false,
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, X = -0.389705882352941, Y = 0.395128240613906, RX = 0.270276292335116, RY = -0.258787798336068 },
                     { Linear = true, X = 0.421122994652406, Y = -0.381235154394299, LX = -0.270276292335116, LY = 0.258787798336068 }
                  }
               },
            },
         },
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Transform1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Polygon1",
               Source = "Mask",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 325.333, 87.9697 } },
      },
      Transform1 = Transform {
         Inputs = {
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Angle = Input {
               SourceOp = "Path1",
               Source = "Heading",
            },
            Input = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 162.667, 88.5758 } },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               SourceOp = "Publish1",
               Source = "Value",
            },
         },
      },
      Background1_1 = Background {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Text1_1",
               Source = "Output",
            },
            GlobalOut = Input { Value = 200, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
         },
         ViewInfo = OperatorInfo { Pos = { 456.667, 50.3939 } },
      },
      Text1_1 = TextPlus {
         Inputs = {
            GlobalOut = Input { Value = 200, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            StyledText = Input { Value = "l", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, },
         },
         ViewInfo = OperatorInfo { Pos = { 456, 16.4545 } },
      },
      Transform1_1 = Transform {
         Inputs = {
            Center = Input {
               SourceOp = "Path1_1",
               Source = "Position",
            },
            Angle = Input {
               SourceOp = "Path1_1",
               Source = "Heading",
            },
            Input = Input {
               SourceOp = "Background1_1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 455.334, 86.1515 } },
      },
      Path1_1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1_1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               SourceOp = "Publish1_1",
               Source = "Value",
            },
         },
      },
      Path1_1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         CtrlWZoom = false,
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 66.6666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true } },
            [200] = { 1, LH = { 133.333333333333, 0.666666666666667 }, Flags = { Linear = true } }
         }
      },
      Publish1_1 = PublishPolyLine {
         CtrlWZoom = false,
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, X = -0.389705882352941, Y = 0.395128240613906, RX = 0.270276292335116, RY = -0.258787798336068 },
                     { X = 0.421122994652406, Y = -0.381235154394299, LX = -0.624554367201426, LY = 0.00463102873986848 }
                  }
               },
            },
         },
      },
      Merge1_1 = Merge {
         CtrlWZoom = false,
         Inputs = {
            Background = Input {
               SourceOp = "Transform1_1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Polygon1_1",
               Source = "Mask",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 618, 85.5454 } },
      },
      Polygon1_1 = PolylineMask {
         DrawMode = "ClickAppend",
         DrawMode2 = "InsertAndModify",
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            BorderWidth = Input { Value = 0.008, },
            WriteLength = Input {
               SourceOp = "Path1_1Displacement",
               Source = "Value",
            },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1080, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Polyline = Input {
               SourceOp = "Publish1_1",
               Source = "Value",
            },
            Polyline2 = Input {
               Value = Polyline {
               },
               Disabled = true,
            },
         },
         ViewInfo = OperatorInfo { Pos = { 619.334, 50.9999 } },
      }
   },
   ActiveTool = "Merge1_1"
}

Just to take a more simple view of the problem, I stripped the function down to a very basic move, two points and a straight line and the sync problem doesn't occur.

So far the only way to make it work seems to be to change aspect ratio to 1:1.

sshot-1184.jpg (56.05 KiB) Viewed 1110 times

Here is with your example.

Code: Select all

{
   Tools = ordered() {
      Transform1_1 = Transform {
         Inputs = {
            Center = Input {
               SourceOp = "Path1_1",
               Source = "Position",
            },
            Aspect = Input { Value = 1.77777777777778, },
            Angle = Input {
               SourceOp = "Path1_1",
               Source = "Heading",
            },
            Input = Input {
               SourceOp = "Background1_1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { -673.115, -57.5747 } },
      },
      Path1_1 = PolyPath {
         DrawMode = "InsertAndModify",
         CtrlWZoom = false,
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1_1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               SourceOp = "Publish1_1",
               Source = "Value",
            }
         },
      },
      Path1_1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255 },
         KeyFrames = {
            [0] = { 0, RH = { 66.6666666666667, 0.333333333333333 }, Flags = { Linear = true, LockedY = true } },
            [200] = { 1, LH = { 133.333333333333, 0.666666666666667 }, Flags = { Linear = true } }
         }
      },
      Publish1_1 = PublishPolyLine {
         Inputs = {
            Value = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, X = -0.408455882352941, Y = 0.207628240613906, RX = 0.261248514557337, RY = -0.099760020558296 },
                     { X = 0.375289661319073, Y = -0.0916518210609656, LX = -0.52271790761585, LY = -0.265497243401648 }
                  }
               },
            }
         },
      },
      Crop1 = Crop {
         Inputs = {
            YOffset = Input { Value = 420, },
            XSize = Input { Value = 1920, },
            YSize = Input { Value = 1080, },
            KeepCentered = Input { Value = 1, },
            Input = Input {
               SourceOp = "Merge1_1",
               Source = "Output",
            }
         },
         ViewInfo = OperatorInfo { Pos = { -359.6, -57.5747 } },
      },
      Merge1_1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Transform1_1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Polygon1_1",
               Source = "Mask",
            },
            PerformDepthMerge = Input { Value = 0, }
         },
         ViewInfo = OperatorInfo { Pos = { -510.449, -57.5747 } },
      },
      Polygon1_1 = PolylineMask {
         DrawMode = "InsertAndModify",
         DrawMode2 = "InsertAndModify",
         Inputs = {
            Filter = Input { Value = FuID { "Fast Gaussian" }, },
            BorderWidth = Input { Value = 0.008, },
            WriteLength = Input {
               SourceOp = "Path1_1Displacement",
               Source = "Value",
            },
            OutputSize = Input { Value = FuID { "Custom" }, },
            MaskWidth = Input { Value = 1920, },
            MaskHeight = Input { Value = 1920, },
            PixelAspect = Input { Value = { 1, 1 }, },
            ClippingMode = Input { Value = FuID { "None" }, },
            Polyline = Input {
               SourceOp = "Publish1_1",
               Source = "Value",
            },
            Polyline2 = Input {
               Value = Polyline {
               },
               Disabled = true,
            }
         },
         ViewInfo = OperatorInfo { Pos = { -510.449, -189.575 } },
      },
      Background1_1 = Background {
         Inputs = {
            EffectMask = Input {
               SourceOp = "Text1_1",
               Source = "Output",
            },
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1920, },
            Depth = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, }
         },
         ViewInfo = OperatorInfo { Pos = { -673.115, -139.612 } },
      },
      Text1_1 = TextPlus {
         CtrlWZoom = false,
         Inputs = {
            GlobalOut = Input { Value = 500, },
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            UseFrameFormatSettings = Input { Value = 1, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2" }, },
            StyledText = Input { Value = "l", },
            Font = Input { Value = "Open Sans", },
            Style = Input { Value = "Bold", },
            VerticalJustificationNew = Input { Value = 3, },
            HorizontalJustificationNew = Input { Value = 3, }
         },
         ViewInfo = OperatorInfo { Pos = { -673.115, -194.979 } },
      }
   }
}

Yes, I remember that square frame solution/workround was suggested in a thread of about a year ago. I don't remember the title of the thread but Sander de Regt posted in it, so maybe he can remember. I suppose you could get the task done in a separate line and merge over any background dimension required.
Something I noticed this morning that likely is a clue to what is going on, is that with a clockwise curve the line lags behind the text element and clockwise curve the line is ahead of the text element, that is in a 16:9 frame. A 9:16 frame or some such might be the opposite, I didn't try.

Never mind the ohter workarounds. Just crop it to a larger square, do your merge and crop back to the original resolution. It's the quickest and cleanest workaround (crop only works with whole pixels, so there is no resampling involved)