cloning
link-mesh-array.py
link-mesh.py

mesh fabrication
staircase.py
triangle-donut.py
vertexAccumulator.py
randomSquareArray.py
meshFromBathymetry.py
cylinders-from-list-of-radii.py
binary-image-to-mesh.py
sphere-minecraft-schematic.py
spikify.py
add-to-mesh.py
mobius-strip.py
split-copy-mesh.py

fabricating other objects
create-text.py
text-from-file.py
create-camera.py
create-bezier.py
helix-bezier.py

material slots
cube-copy-blue.py
cube-turns-red.py
red-blue-per-object.py

animation and fcurves
csv-to-fcurve-loc-rot.py
csv-to-fcurve.py
pop-in-material.py
spike-wiggle-2.py
spike-wiggle.py
sweep-animate-size.py
animate-cycles-lamp-strength.py

incorporating python libraries
exec-text-library.py
exec-external-python.py
import-python.py

constraints
camera-track-object.py
text-track-camera.py

shape keys
explore-shape-keys.py
shape-key-fin.py
docking-tube.py

animating curve bevel
data-graph.py

drivers
scan-drivers.py
copy-drivers.py
driver-fin.py
driver-multi-chain.py

UV layers
barber-pole.py
expand-uv-to-fit.py
uv-from-geometry-cubic.py
flip-texture-v-coordinate.py

modifiers
hook-modifier-curve.py
rounded-prisms.py
make-tile.py
remove-action-modifiers.py

NLAs
explore-NLAs.py
spinning-frogs.py

video sequence editor (VSE)
create-vse-image-strips.py
slide-show.py
vse-strip-gap.py

images and textures
image-on-mesh.py
image-to-material-node.py
load-image-texture.py
texture-one-cube-face.py
condense-duplicate-images.py

analytic geometry
animate-random-spin.py
camera-cone-exp-2.py
camera-cone-exp.py
compute-circle-center.py
dihedral-angle-from-xy.py
extrude-edge-along-custom-axis.py
orientation-matrix.py
two-spheres.py
bezier-interpolate.py
rotate-to-match.py

node trees
change-diffuse-to-emission-node.py

etc
add-plane-from-selected-vertices.py
adjust-all-materials.py
all-nodes-cycles-materials.py
bit_shift.py
bone-orientation-demo.py
cannonball-packing.py
comb.py
convert-quaternion-keyframes-to-euler.py
copy-location-from-vertex-group.py
create-cycles-material.py
demonstrate-decomposition-instability.py
dump-point-cache.py
dump-screen-layout-info.py
expand-nla-strips.py
explore-edge-bevel-weight.py
find-action-users.py
find-green-rectangle.py
find-new-objects.py
fix-scene-layers.py
generate-makefile.py
link-external-data-blocks.py
list-referenced-files.py
material-readout.py
movie-card-stack.py
movies-on-faces.py
next-file-name.py
object-font-from-regular-font.py
operator-mesh-gridify.py
particle-animator.py
particle_loop.py
pose-match.py
pose-sequence-to-fbx.py
prepare-texture-bake.py
raining-physics.py
random-pebble-material.py
reverse-keyframes.py
scale-parallelogram.py
screenshot-sequence.py
select-objects-in-modifiers.py
select-vertices.py
shift-layers.py
snapshot-keyframes-as-mesh.py
sphere-project-texture.py
squish-mesh-axis.py
subdivide-fcurve.py
thicken-texture.py
transform-selected.py
voronoi-madness.py

__author__ = 'thoth'

# http://blender.stackexchange.com/questions/63878/how-to-map-a-pose-to-the-restpose-of-another-rig-with-same-topology


import bpy
from mathutils import *

def explore_matrices(arm):
    for bone in arm.data.bones:
        #print ( [ bone.name, bone.head_local, bone.matrix_local*Vector([0,0,0])])
        print ( [ bone.name, bone.tail_local, bone.matrix_local*Vector([0,bone.length,0])])


def scene_link(obj, scn):
    try:
        scn.objects.link(obj)
    except:
        pass


def check1(arm):
    bone = arm.pose.bones[2]

    e1 = bpy.data.objects.get("head")
    if e1 is None:
        e1 = bpy.data.objects.new("head", None)
    scn = bpy.context.scene
    scene_link(e1, scn)
    e2 = bpy.data.objects.get("tail")
    if e2 is None:
        e2 = bpy.data.objects.new("tail", None)
    scene_link(e2, scn)
    e1.location = arm.matrix_world * bone.matrix * Vector([0,0,0])
    e2.location = arm.matrix_world * bone.matrix * Vector([0,arm.data.bones[bone.name].length,0])


def matrix_scale(scale_vec):
    return Matrix([[scale_vec[0],0,0,0],
                   [0,scale_vec[1],0,0],
                   [0,0,scale_vec[2],0],
                   [0,0,0,1]
    ])

def matrix_for_bone_from_parent(bone, ao):
    eb1 = ao.data.bones[bone.name]
    E = eb1.matrix_local # * Matrix.Scale(eb1.length,4)
    ebp = ao.data.bones[bone.name].parent
    E_p = ebp.matrix_local # * Matrix.Scale(ebp.length,4)
    return E_p.inverted() * E

def matrix_the_hard_way(pose_bone, ao):
    if pose_bone.rotation_mode == 'QUATERNION':
        mr = pose_bone.rotation_quaternion.to_matrix().to_4x4()
    else:
        mr = pose_bone.rotation_euler.to_matrix().to_4x4()
    m1 = Matrix.Translation(pose_bone.location) * mr * matrix_scale(pose_bone.scale)

    E = ao.data.bones[pose_bone.name].matrix_local
    if pose_bone.parent is None:
        return E * m1
    else:
        m2 = matrix_the_hard_way(pose_bone.parent, ao)
        E_p = ao.data.bones[pose_bone.parent.name].matrix_local
        return m2 * E_p.inverted() * E * m1

def pose_to_match(arm, goal):
    """
    pose arm so that its bones line up with the REST pose of goal
    """

    matrix_os= {}
    for to_match in goal.data.bones:
        matrix_os[to_match.name] = to_match.matrix_local
        #print([ "matrix", to_match.name, matrix_os[to_match.name] ] )

    #xyz' = s * m * m(parent) * xyz

    for to_pose in arm.pose.bones:
        if to_pose.parent is None:
            len2 = arm.data.bones[to_pose.name].length
            len1 = goal.data.bones[to_pose.name].length
            to_pose.matrix = matrix_os[to_pose.name] * Matrix.Scale(len1/len2, 4)
        else:
            # we can not set .matrix, because a lot of stuff behind the scenes has not yet
            # caught up with our alterations, and it ends up doing math on outdated numbers
            mp = matrix_the_hard_way(to_pose.parent, arm) * matrix_for_bone_from_parent(to_pose, arm)
            m2 = mp.inverted()* matrix_os[to_pose.name] * Matrix.Scale(goal.data.bones[to_pose.name].length, 4)
            loc,rot,scale = m2.decompose()
            to_pose.location = loc
            if 'QUATERNION' == to_pose.rotation_mode:
                to_pose.rotation_quaternion = rot
            else:
                to_pose.rotation_euler = rot.to_euler(to_pose.rotation_mode)
            to_pose.scale = scale / arm.data.bones[to_pose.name].length



#
#
#

#explore_matrices(bpy.data.objects['beta'])

#pose_to_match(bpy.data.objects['Armature.001'], bpy.data.objects['Armature'])

pose_to_match(bpy.data.objects['gamma'], bpy.data.objects['beta'])


#check1(bpy.data.objects['gamma'])

Blender python API quick-start

Syntax highlighting by Pygments.