You can achieve this by using particles to trace out the path of the motion and converting each particle system into a Curve object. The curves can then be used to draw the trails and animated using keyframes to match the motion.
Start by adding particle systems to the mesh. It's important to have a separate particle system for each 'trail'. The order the particles are emitted will control the order of the points in that trail.
There are two ways of achieving this.
Create a mesh with a single vertex and add a particle system. This can then be duplicated, positioned, and parented to the moving mesh so that it follows the motion. You can create as many of these 'trace' objects as are required.
Emit the particles directly from the mesh being traced. It's important that each particle system emits from a single vertex - so use Vertex Groups to limit the emission for each particle system, adding a particle system for each.
Ensure the particle systems are set to emit the particles with no initial velocity and that the relevant Field Weights are set to zero so they are not affected by any forces present. This should result in the particles 'hanging' at the point they are emitted.
Once you have the emitted particles, open a Text Editor window and paste the following python code :
import bpy
def particles_to_path(objName, tracks=1, particleSystem=0, curveResolution=0, bevelDepth=0.1):
object = bpy.context.scene.objects[objName]
particles = object.particle_systems[particleSystem].particles
trackNo = 0
trackPoint = 0
curves = []
splines = []
for p in particles:
if trackPoint == 0:
# Create new track
curve = bpy.data.curves.new('particlePath', type='CURVE')
curve.dimensions = '3D'
curve.resolution_u = curveResolution
curve.bevel_depth = bevelDepth
spline = curve.splines.new('NURBS')
curves.append(curve)
splines.append(spline)
#set first point
print(spline.points[0])
print(spline.points[0].co)
spline.points[0].co = (p.location[0], p.location[1], p.location[2],1)
else:
# Add point
splines[trackNo].points.add()
splines[trackNo].points[trackPoint].co = (p.location[0], p.location[1], p.location[2],1)
trackNo += 1
if trackNo >= tracks:
trackNo = 0
trackPoint += 1
# deselect all
for curve in curves:
curveObject = bpy.data.objects.new('particlePath', curve)
bpy.context.scene.objects.link(curveObject)
#...select it?
particles_to_path('Trace',particleSystem=0, curveResolution=8)
The code defines a function (particles_to_path) which will use the particles emitted by a particle system on an object to create a Curve object. Note the last line in the script which invokes the function, specifying the object 'Trace'. This will use the first particle system on the 'Trace' object and will create a Curve. To invoke the function on multiple particle systems, simply duplicate the last line and change each as appropriate.
For example, for multiple objects named 'Trace', 'Trace.001', 'Trace.002', 'Trace.003', etc. use the following lines :
particles_to_path('Trace',particleSystem=0, curveResolution=8)
particles_to_path('Trace.001',particleSystem=0, curveResolution=8)
particles_to_path('Trace.002',particleSystem=0, curveResolution=8)
particles_to_path('Trace.003',particleSystem=0, curveResolution=8)
If you have multiple particle systems on the same object, each emitting from a single vertex then you can use the 'particleSystem' parameter to indicate which particle system to use (0 = the first one, 1 = the second one, 2 = the third one, etc.) :
particles_to_path('myMesh',particleSystem=0, curveResolution=8)
particles_to_path('myMesh',particleSystem=1, curveResolution=8)
particles_to_path('myMesh',particleSystem=2, curveResolution=8)
particles_to_path('myMesh',particleSystem=3, curveResolution=8)
particles_to_path('myMesh',particleSystem=4, curveResolution=8)
Once you have generated the curves, simply adjust the curve properties to generate the required trails. For example, set Resolution and Fill in the Shape settings to generate a curved shape...
...and use the Geometry Bevel settings to adjust the 'trail' - setting Start and End to position it along the curve :
Note that the Taper Object can be used to specify an additional curve object which defines the shape of the bevel along the curve (with Map Taper enabled to taper the bevel along the Start-End interval rather than the whole curve).
Carefully keyframing the Start and End will allow the trail to be animating. Ensure to set the Interpolation of the animation curves to Linear so it matches the motion of the particle emitting mesh.
For the material, you can use a combination of Emission and Scatter on the Volume. This will allow the trails to be partially opaque while still emitting light. Mixing in a Transparent shader based on the light path allows them to be hidden from all but the camera (so they don't reflect off of the surfaces). Including variation based on the Random object info provides automatic variation for each trail (you could assign individual materials manually in you prefer more control).
This can produce the following result :
Blend file : 
Applying this to the example 'dancer' mesh can produce the following effect :
EDIT: I have since packaged the above script as an add-on as part of this answer, available from here. This makes it much simpler to run and avoids the need to create and edit a custom script.
and I would like something closer to this: (I'd be delighted with something far more simple)
