Okay, I hope you will read this whole thing, because I'm trying

to go somewhere useful with it, and was hoping someone might have

answers that could help me.

In regards to 3D animation graphics, I'm not sure if you know

what Temporal Coherence is, but that's when each frame

smoothly and seamlessly transitions to the next one,

without any weird artifacts to distract the eye from

the smoothness.

An interpolated transformation ("tween") is a good

example of this. A good counter-example is when one

uses one of those painterly stroke-based renderers to

create an animation, and they end up with

creepy-crawly strokes that resemble what some call a

"shower door" effect. This is of course very

distracting to the viewer, and is often considered

undesirable.

3D animation can also be rendered as a sequence of

2D-projected vector geometry. In such a 2D vector-rendering

of a 3D animation, it is still possible to perceive

2 distinct levels of temporal coherence within the same

final animation output: the 2D and 3D levels.

In the "shower door effect" rendered animation example

I cited, there is 2D temporal decoherence, but

temporal coherence is still be there at the 3D level,

beause it's underlying 3D movement is being depicted

seamlessly (ie. there's no choppiness -- "shower door"

effect is not the same as choppiness)

So this then finally brings us to the exact opposite

case in 2D vector rendering of 3D animation: where you

have 2D Coherence with 3D decoherence.

That's where the 3D animation information is choppy,

but the final 2D-vector frames still maintain

seamless/smooth transition from one frame to the next,

which would be accomplished by 2D tweens spanning the

gaps in the 3d choppiness.

And so that's where I was thinking about the idea of

rendering to 2D-vector output, since only 2D vector

offers the possibility of further 2D-tweening even

when the underlying/preceding 3D information was

choppy (2D coherence with 3D decoherence).

So how would I achieve that today, by using a manual

approach. Well, I'd vector-render my 3D animation at a

very low framerate for choppiness (eg. 3 frames/sec?).

I'd then treat this resulting sparsely-rendered 2D

frameset as a set of of 2D keyframes intended for a

higher ultimate framerate (eg. 15fps). I would then

have to PAINSTAKINGLY AND LABORIOUSLY go through each

of these 2D-vector frames to then tweak it and lay down

appropriate shape-tweens (interpolated transforms), so

that the 2D geometry in each frame would smoothly

tween into that of the next frame. The end result would be an

animation having temporal coherence in 2D at 15fps),

even while having temporal decoherence at the 3D

level.

Why do this?

Well, if you've ever seen cel-shaded 3D animation on

TV or in the movies, it's very easily identifiable and

glaringly stands out from the regular 2D animation,

because that cel-shaded 3D animation is still

communicating 3D temporal coherence to the viewer. If

you were to render only a still image, then the

cel-shading looks believable as 2D. But as soon as you

try to render an animation with it, then the 3D

temporal coherence gives the whole thing away as 3D

CG.

But if you could achieve a fully smoothly 2D-tweened

animation, even while its underlying 3D information

was choppy, then you wouldn't have that troublesome 3D

temporal coherence that ruins the illusion of 2D.

How to achieve this?

Well, that's where you need to simultaneously deal

with the parent 3D geometry, as well as the

associated 2D child geometry derived from it.

Thus it would be conceivable to link/reference the 2D

curves in any 2D vector-rendering back to its 3D

parent geometry.

The purpose of doing so would be for determining how

to lay down the 2D vertices and their tweens to

achieve smooth 2D-tweening from one 2D frame to the

next.

So that last sentence sounds like the critical

blackbox devil-is-in-the-details step. They key word

here is TOPOLOGY, because that's what a 3D surface is.

Topology - Wikipedia, the free encyclopedia

Manifold - Wikipedia, the free encyclopedia

What one would look at is the dynamically animating 3D

geometry and the transition paths of their local

extrema used to create the 2D vector renders. What one

would have to test for is continuity/connectedness, in

regards to these transition paths. As with most

software algorithms, have to be able to do this using

linear algebra / matrix / numerical methods rather

than analytical methods.

Riemannian manifold - Wikipedia, the free encyclopedia

Hilbert space - Wikipedia, the free encyclopedia

So the reason I'm posting here is to ask if anyone has

any insight on how I might be able to achieve this, or

if you know anyone who would.