Spline with multiple durations - lua

Question

I'm trying to make a spline that has multiple durations. Basically, I want to create a spline generated through user supplied key frames. There may be multiple key frames with different durations. So I ask, how would I make a that travels at different speeds through different key frames. Let's say I want there to be 1 second between key frame A and B, but 5 seconds between B and C. Similar to the way animation editors like Source Filmmaker, or Autodesk Maya do it. Every time I've seen someone make a spline, it always has one, constant speed. Always X seconds between key frames, but this is not how animation editors work, as they have different speeds, that's what I want.
Just to note, I have tried. I made the duration change once it gets to a different key frame, but that just instantly slows it down, like some slow motion movie effect, which is not what I'm looking for. Do I just gradually transition the speed to fit that of the next key frame? Is there just some equation?
function smooth( points, steps ) --points is an array, steps is how many frames inbetween spline points
if #points < 3 then
return points
end
local steps = steps or 5
local spline = {}
local count = #points - 1
local p0, p1, p2, p3, x, y, z
for i = 1, count do
if i == 1 then
p0, p1, p2, p3 = points[i], points[i], points[i + 1], points[i + 2]
elseif i == count then
p0, p1, p2, p3 = points[#points - 2], points[#points - 1], points[#points], points[#points]
else
p0, p1, p2, p3 = points[i - 1], points[i], points[i + 1], points[i + 2]
end
for t = 0, 1, 1 / steps do
-- Main spline equation
x = 1 * ( ( 2 * p1.x ) + ( p2.x - p0.x ) * t + ( 2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x ) * t * t + ( 3 * p1.x - p0.x - 3 * p2.x + p3.x ) * t * t * t )
y = 1 * ( ( 2 * p1.y ) + ( p2.y - p0.y ) * t + ( 2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y ) * t * t + ( 3 * p1.y - p0.y - 3 * p2.y + p3.y ) * t * t * t )
z = 1 * ( ( 2 * p1.z ) + ( p2.z - p0.z ) * t + ( 2 * p0.z - 5 * p1.z + 4 * p2.z - p3.z ) * t * t + ( 3 * p1.z - p0.z - 3 * p2.z + p3.z ) * t * t * t )
if not(#spline > 0 and spline[#spline].x == x and spline[#spline].y == y and spline[#spline].z == z) then
table.insert( spline , { x = x , y = y, z = z } )
end
end
end
return spline
end

Answer 1

Straightforward approach was used:
local zero_vector = {0, 0, 0}
local function get_slope(is_edge, left, right)
if is_edge then
return zero_vector
else
local t = right.time - left.time
assert(t > 0, "Non-increasing time sequence")
return {(right[1] - left[1])/t,
(right[2] - left[2])/t,
(right[3] - left[3])/t}
end
end
function smooth(checkpoints, frames_per_second)
frames_per_second = frames_per_second or 5
if #checkpoints < 2 then
return checkpoints
end
-- Prepare formulas for each segment of spline
local formulas = {}
for segment = 1, #checkpoints - 1 do
local left = checkpoints[segment]
local right = checkpoints[segment + 1]
local t = right.time - left.time
assert(t > 0, "Non-increasing time sequence")
local left_deriv = get_slope(segment == 1,
checkpoints[segment - 1], right)
local right_deriv = get_slope(segment == #checkpoints - 1,
left, checkpoints[segment + 2])
formulas[segment] = {}
for j = 1, 3 do
local d = left[j]
local c = left_deriv[j]
local a = (right[j] - d - c*t) / (t*t)
local b = 3*a + (c - right_deriv[j])/t
formulas[segment][j] = {(a - b)/t, b, c, d}
end
end
-- Calculate spline points
local total_seconds = checkpoints[#checkpoints].time - checkpoints[1].time
local segment = 1
local spline = {}
for frame_no = 0, total_seconds * frames_per_second do
local t = checkpoints[1].time + frame_no / frames_per_second
local point = {time = t}
while segment < #formulas and t > checkpoints[segment + 1].time do
segment = segment + 1
end
t = t - checkpoints[segment].time
for j = 1, 3 do
local c = formulas[segment][j]
point[j] = ((c[1]*t + c[2])*t + c[3])*t + c[4]
end
table.insert(spline, point)
end
return spline
end
Usage example:
-- x y z "timestamp in seconds"
local checkpoint_A = {11, 12, 13, time = 0}
local checkpoint_B = {21, 15, 18, time = 1} -- 1 second between A and B
local checkpoint_C = {13, 24, 20, time = 6} -- 5 seconds between B and C
local checkpoints = {checkpoint_A, checkpoint_B, checkpoint_C}
-- total duration is 6 seconds, 10 frames per second, 61 points returned
local array_of_61_points = smooth(checkpoints, 10)
for _, point in ipairs(array_of_61_points) do
print(string.format("time = %.1f, x = %.3f, y = %.3f, z = %.3f",
point.time, point[1], point[2], point[3]))
end