Here is another short video of some more animation tests:
There are two behaviors being tested, motion-blur and flexible-cable dynamics.
Motion-blur is approximated by creating intermediate image frames that capture motion at a smaller incremental step (in other words, at a higher frame rate), and then selectively blending frames together to form the final still frames. In this case, ten intermediate frames were created for each final still frame. The imagemagick tool was used to compute the average of each set of ten successive intermediate frames, forming the final stills. Then the ffmpeg tool was used to create a video from the final still frames.
Motion-blur is helpful to represent high-speed motion that would otherwise have very odd timing appearances due to stroboscopic effects caused by the discrete sampling of each frame. As an example, look at the governor mechanism on the left side of the fifth clip (0:49 into the video). The larger gears seem to turn at reasonable rates, but the escapement wheel and rocking pallet appear very slow due to discrete sampling, when in fact they are moving very fast; no motion-blur was applied here.
The animation was created with a custom SketchUp script that supports a variable frame-rate. In this case, the frame rate was 4800 FPS at the beginning of the first three short clips (which condenses down to 480 FPS after intermediate frames are average), then gradually changing to 240 FPS near the end of the clips (which condenses down to 24 FPS). The net effect is that the motion speeds up; the simulated behavior goes from a 20x slow-motion start to real-time motion ending.
I wrote a separate SketchUp script that exports the scenes (aka pages) ten to a sub-directory on my computer. A macOS/Linux shell script then repeatedly invokes imagemagick to process the frames in each sub-directory into a final video frame. Then a simple ffmpeg command generates the video from the final frames.
The flexible-cable dynamics are simulated with more custom SketchUp scripting. In essence, the simulation begins with the initial cable path (hand-created of multiple segments), and incrementally computes changes due to movement of one end of the cable. The other end is held fixed. The change experienced by the final segment at the moving end of the cable is gradually propagated to all earlier segments of the cable, with various constraints. The simulation algorithm is re-applied from the fixed end back to the moving end of the cable, to attempt to hold the lengths of each segment constant (my simple hack, without a proper physics engine). With the new path of the cable thus computed, Follow-Me is used by the script to construct the cylindrical outline of the cable. Each successive simulated frame picks up from where the prior frame had evolved the cable shape.