def test_penalty_contact():
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
wcfg.useDefaultContactModel = False
vpWorld = cvw.VpWorld(wcfg)
body = cvb.VpBody(vpWorld)
body.addBoxGeom((1,.1,1), 1)
body.setFrame(mm.p2T((0,.1,0)))
vpWorld.initialize()
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.]*len(bodyIDsToCheck)
Ks = 1000; Ds = 2*(Ks**.5)
viewer = ysv.SimpleViewer()
viewer.doc.addRenderer('box', yr.VpBodyRenderer(body, (255,0,0)))
viewer.setMaxFrame(100)
def simulateCallback(frame):
for i in range(stepsPerFrame):
bodyIDs, positions, positionLocals, forces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)
vpWorld.applyPenaltyForce(bodyIDs, positionLocals, forces)
vpWorld.step()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer((1/30.)*.4)
viewer.show()
Fl.run()
def test_body_force_funcs():
bvhFilePath = '../samples/chain_1.bvh'
# bvhFilePath = '../samples/chain_6.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 100.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.gravity = (0,0,0)
stepsPerFrame = 60
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.setBodyPositionGlobal(0, (0,1,0))
###################################################################
# apply force == add force
# controlModel.applyBodyGenForceGlobal(0, (0,0,100), (0,-100,0), (0,0,0))
# above 1 line == below 2 lines
controlModel.applyBodyTorqueGlobal(0, (0,0,100))
controlModel.applyBodyForceGlobal(0, (0,-100,0))
p = [mm.O_Vec3()]*controlModel.getBodyNum()
forces = [mm.O_Vec3()] * controlModel.getBodyNum()
netForces = [mm.O_Vec3()] * controlModel.getBodyNum()
gravityForces = [mm.O_Vec3()] * controlModel.getBodyNum()
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
# viewer.doc.addRenderer('forces', yr.VectorsRenderer(forces, p, (255,0,0)))
# viewer.doc.addRenderer('netForces', yr.VectorsRenderer(netForces, p, (0,255,0)))
# viewer.doc.addRenderer('gravityForces', yr.VectorsRenderer(gravityForces, p, (0,0,255)))
viewer.setMaxFrame(500)
def simulateCallback(frame):
p[:] = controlModel.getBodyPositionsGlobal()
forces[0] = controlModel.getBodyForceLocal(0)
netForces[0] = controlModel.getBodyNetForceLocal(0)
gravityForces[0] = controlModel.getBodyGravityForceLocal(0)
for i in range(stepsPerFrame):
vpWorld.step()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_hybridDynamics_gravity():
bvhFilePath = '../samples/chain_1.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
# wcfg.gravity = (0,0,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
controlModel2 = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
controlModel2.initializeHybridDynamics()
controlModel2.translateByOffset((1,0,0))
p = []
torques = []
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_FILL))
viewer.doc.addRenderer('model2', cvr.VpModelRenderer(controlModel2, (255,240,255), yr.POLYGON_FILL))
viewer.doc.addRenderer('torques', yr.VectorsRenderer(torques, p, (255,0,0)))
viewer.setMaxFrame(100)
def simulateCallback(frame):
p[:] = controlModel.getInternalJointPositionsGlobal() + controlModel2.getInternalJointPositionsGlobal()
for i in range(stepsPerFrame):
controlModel.solveHybridDynamics()
print 'a', controlModel2.getBodyForceLocal(0)
controlModel2.applyBodyForceGlobal(0, (0,10,0))
print 'b', controlModel2.getBodyForceLocal(0)
controlModel2.solveHybridDynamics()
torques[:] = controlModel.getInternalJointTorquesLocal() + controlModel2.getInternalJointTorquesLocal()
vpWorld.step()
print 'c', controlModel2.getBodyForceLocal(0)
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_getInternalJointOrientationsGlobal():
# bvhFilePath = '../samples/block_tree_rotate.bvh'
bvhFilePath = '../samples/chain_3_rotate_expt_root.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
wcfg.gravity = (0,0,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.translateByOffset((0,0,1))
controlModel.fixBody(0)
jointPositions = []
localFrames = []
globalFrames = []
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('localFrames', yr.FramesRenderer(localFrames, (255,0,0)))
viewer.doc.addRenderer('globalFrames', yr.FramesRenderer(globalFrames, (0,255,0)))
def simulateCallback(frame):
controlModel.setJointAngVelocityLocal(1, (0,.5,0))
controlModel.setJointAngVelocityLocal(2, (0,.5,0))
for i in range(stepsPerFrame):
vpWorld.step()
jointPositions[:] = motion[frame].getInternalJointPositionsGlobal() + controlModel.getInternalJointPositionsGlobal()
localFrames[:] = motion.getInternalJointOrientationsLocal(frame) + controlModel.getInternalJointOrientationsLocal()
localFrames[:] = map(mm.Rp2T, localFrames, jointPositions)
globalFrames[:] = motion[frame].getInternalJointOrientationsGlobal() + controlModel.getInternalJointOrientationsGlobal()
globalFrames[:] = map(mm.Rp2T, globalFrames, jointPositions)
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_joint_force_funcs():
bvhFilePath = '../samples/block_tree_rotate.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
wcfg.gravity = (0,0,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.fixBody(0)
joint_p = []
joint_t = []
viewer = ysv.SimpleViewer()
viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('joint_p', yr.PointsRenderer(joint_p, (0,255,0)))
viewer.doc.addRenderer('joint_t', yr.VectorsRenderer(joint_t, joint_p, (0,255,0)))
def simulateCallback(frame):
controlModel.setJointTorqueLocal(1, (0,0,1))
joint_p[:] = controlModel.getInternalJointPositionsGlobal()
joint_t[:] = controlModel.getInternalJointTorquesLocal()
for i in range(stepsPerFrame):
vpWorld.step()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_inertia_matrix():
bvhFilePath = '../samples/chain_1.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 100.
mcfg.defaultBoneRatio = 1.
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.useDefaultContactModel = False
wcfg.gravity = (0,0,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
controlModel2 = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel2.translateByOffset((0,0,1))
controlModel2.rotate(mm.exp(mm.v3(0,1,0), math.pi/2))
print 'model local'
print controlModel.getBodyInertiasLocal()
print
print 'model global'
print controlModel.getBodyInertiasGlobal()
print
print 'model2 global'
print controlModel2.getBodyInertiasGlobal()
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
# viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('model2', cvr.VpModelRenderer(controlModel2, (255,240,255), yr.POLYGON_LINE))
viewer.setMaxFrame(100)
viewer.show()
Fl.run()
def test_VpMotionModel():
bvhFilePath = '../samples/block_3_rotate.bvh'
motion = yf.readBvhFile(bvhFilePath)
wcfg = ypc.WorldConfig()
vpWorld = cvw.VpWorld(wcfg)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
node = mcfg.getNode('body1')
node.mass = 1.
node = mcfg.getNode('body2')
node.mass = 1.
node.boneRatio = .5
node.offset = (0,0,.1)
node = mcfg.getNode('body3')
node.mass = 1.
node.length = .1
# mcfg.delNode('body2')
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(motionModel, (255,240,255), cvr.POLYGON_LINE))
def preFrameCallback(frame):
motionModel.update(motion[frame])
viewer.setPreFrameCallback(preFrameCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_stack():
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
boxNum = 10
bodies = [None]*boxNum
for i in range(boxNum):
bodies[i] = cvb.VpBody(vpWorld)
bodies[i].addBoxGeom((1,1,1), 1)
bodies[i].setPosition((10,i,11))
bodies[i].setOrientation(mm.rotY(10*mm.RAD*random.random()))
# bodies[i].setFrame(mm.Rp2T( mm.rotY(10*mm.RAD*random.random()), (10,i,11)))
bodies2 = [None]*(boxNum*boxNum)
count = 0
for i in range(boxNum):
for j in range(boxNum):
bodies2[count] = cvb.VpBody(vpWorld)
bodies2[count].addBoxGeom((1,1,1), 1)
bodies2[count].setPosition((.1*random.random(),i,j))
# bodies2[count].setOrientation(mm.rotY(10*mm.RAD*random.random()))
count += 1
vpWorld.initialize()
viewer = ysv.SimpleViewer()
viewer.doc.addRenderer('box', yr.VpBodiesRenderer(bodies, (255,0,0)))
viewer.doc.addRenderer('box2', yr.VpBodiesRenderer(bodies2, (0,0,255)))
viewer.setMaxFrame(100)
def simulateCallback(frame):
for i in range(stepsPerFrame):
vpWorld.step()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer((1/30.)*.4)
viewer.show()
Fl.run()
def test_VpControlModel():
bvhFilePath = '../samples/block_3_rotate.bvh'
# bvhFilePath = '../samples/block_tree_rotate.bvh'
motion = yf.readBvhFile(bvhFilePath)
motion = motion[30:]
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
node = mcfg.getNode('body2')
node.length = 1
node.offset = (0,0,.2)
# mcfg.delNode('body2')
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
viewer = ysv.SimpleViewer()
# viewer.record(False)
viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_FILL))
def simulateCallback(frame):
for i in range(stepsPerFrame):
vpWorld.step()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_default_contact():
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
body = cvb.VpBody(vpWorld)
body.addBoxGeom((1,1,1), 1)
vpWorld.initialize()
viewer = ysv.SimpleViewer()
viewer.doc.addRenderer('box', yr.VpBodyRenderer(body, (255,0,0)))
viewer.setMaxFrame(100)
def simulateCallback(frame):
for i in range(stepsPerFrame):
vpWorld.step()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer((1/30.)*.4)
viewer.show()
Fl.run()
def main():
np.set_printoptions(precision=4, linewidth=200)
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_5()
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
mcfg_motion = mit.normal_mcfg()
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
motionModel.recordVelByFiniteDiff()
motionOriModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
footPartNum = config['FootPartNum']
if footPartNum > 1:
elasticity = 2000
damping = 2 * (elasticity**.5)
springBody1 = 5
springBody2 = 6
springBody1Pos = motionModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]))
springBody2Pos = motionModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]))
initialDist = mm.length(springBody1Pos - springBody2Pos) * 1.
node = mcfg.getNode(mit.LEFT_PHALANGE_1)
initialDist -= node.width #0.084
v1 = (-node.width * 0.5, 0.0, node.length * 0.4)
v2 = (node.width * 0.5, 0.0, node.length * 0.4)
controlModel.setSpring(
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]),
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]),
elasticity, damping, v2, v1, initialDist)
controlModel.setSpring(
motion[0].skeleton.getJointIndex(config['FootRPart'][springBody1]),
motion[0].skeleton.getJointIndex(config['FootRPart'][springBody2]),
elasticity, damping, v1, v2, initialDist)
#elasticity = 10
#damping = 2*(elasticity**.5)
#springBody1 = 3
#springBody2 = 4
#node = mcfg.getNode(mit.LEFT_PHALANGE_1)
#springBody1Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]))
#springBody2Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]))
#initialDist = mm.length(springBody1Pos - springBody2Pos)*1.
#initialDist -= node.width#0.084
#v1 = (-node.width*0.5,0.0,-node.length*0.4)
#v2 = (node.width*0.5,0.0,-node.length*0.4)
##controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]), elasticity, damping, v2, v1, initialDist)
##controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootRPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootRPart'][springBody2]), elasticity, damping, v1, v2, initialDist)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
#ModelOffset = (1.5, -0.01, 0)
ModelOffset = (1.5, 0.04, 0)
controlModel.translateByOffset(ModelOffset)
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
# parameter
Kt = config['Kt']
Dt = config['Dt'] # tracking gain
Kl = config['Kl']
Dl = config['Dl'] # linear balance gain
Kh = config['Kh']
Dh = config['Dh'] # angular balance gain
Ks = config['Ks']
Ds = config['Ds'] # penalty force spring gain
Bt = config['Bt']
Bl = config['Bl']
Bh = config['Bh']
w = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap'])
w2 = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap2'])
#w_IK = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['IKweightMap'])
supL = motion[0].skeleton.getJointIndex(config['supLink'])
supR = motion[0].skeleton.getJointIndex(config['supLink2'])
rootB = motion[0].skeleton.getJointIndex(config['root'])
selectedBody = motion[0].skeleton.getJointIndex(config['end'])
#constBody = motion[0].skeleton.getJointIndex('LeftForeArm')
constBody = motion[0].skeleton.getJointIndex(config['const'])
# jacobian
Jsup = yjc.makeEmptyJacobian(DOFs, 1)
dJsup = Jsup.copy()
JsupPre = Jsup.copy()
Jsys_IK = yjc.makeEmptyJacobian(DOFs, controlModel.getBodyNum())
Jsys = yjc.makeEmptyJacobian(DOFs, controlModel.getBodyNum())
dJsys = Jsys.copy()
JsysPre = Jsys.copy()
Jconst = yjc.makeEmptyJacobian(DOFs, 1)
dJconst = Jconst.copy()
Jcom = yjc.makeEmptyJacobian(DOFs, 1, False)
dJcom = Jcom.copy()
JcomAng = yjc.makeEmptyJacobian(DOFs, 1, False)
dJcomAng = JcomAng.copy()
###############
jFootL_IK = [None] * footPartNum
jFootR_IK = [None] * footPartNum
indexFootL = [None] * footPartNum
indexFootR = [None] * footPartNum
jFootL = [None] * footPartNum
dJFootL = [None] * footPartNum
jFootR = [None] * footPartNum
dJFootR = [None] * footPartNum
jointMasksFootL = [None] * footPartNum
jointMasksFootR = [None] * footPartNum
for i in range(footPartNum):
jFootL[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootL[i] = jFootL[i].copy()
jFootR[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootR[i] = jFootR[i].copy()
indexFootL[i] = motion[0].skeleton.getJointIndex(
config['FootLPart'][i])
indexFootR[i] = motion[0].skeleton.getJointIndex(
config['FootRPart'][i])
jointMasksFootL[i] = [
yjc.getLinkJointMask(motion[0].skeleton, indexFootL[i])
]
jointMasksFootR[i] = [
yjc.getLinkJointMask(motion[0].skeleton, indexFootR[i])
]
constJointMasks = [
yjc.getLinksJointMask(motion[0].skeleton,
[indexFootL[0], indexFootR[0]])
]
#constJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [indexFootL[0]])]
#constJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, constBody)]
allLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)
#comLowerJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [motion[0].skeleton.getJointIndex('LeftLeg'), motion[0].skeleton.getJointIndex('RightLeg')])]
comUpperJointMasks = [
yjc.getLinkJointMask(motion[0].skeleton, selectedBody)
]
#comLowerJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [motion[0].skeleton.getJointIndex('LeftLeg'), motion[0].skeleton.getJointIndex('RightLeg')])]
comUpperJointMasks[0][0] = 0
#comUpperJointMasks[0][1] = 1
#comUpperJointMasks[0][10] = 1
comUpperJointMasks[0][2] = 1
comUpperJointMasks[0][11] = 1
#print(comUpperJointMasks)
comLowerJointMasks = [
yjc.getLinksJointMask(motion[0].skeleton, [
motion[0].skeleton.getJointIndex('LeftLeg'),
motion[0].skeleton.getJointIndex('RightLeg')
])
]
'''
maskArray = [foreSupLJointMasks, foreSupRJointMasks, rearSupLJointMasks, rearSupRJointMasks]
parentArray = [supL, supR, supL, supR]
effectorArray = [foreSupL, foreSupR, rearSupL, rearSupR]
for j in range(4) :
for i in range(len(foreSupLJointMasks)) :
if i == parentArray[j] or i == effectorArray[j] :
maskArray[j][0][i] = 1
else :
maskArray[j][0][i] = 0
'''
# momentum matrix
linkMasses = controlModel.getBodyMasses()
totalMass = controlModel.getTotalMass()
TO = ymt.make_TO(linkMasses)
dTO = ymt.make_dTO(len(linkMasses))
# optimization
qps = hqp.QPSimulator()
problem = yac.LSE(totalDOF, 6)
a_sup = (0, 0, 0, 0, 0, 0) #L
#a_sup2 = (0,0,0, 0,0,0)#R
a_sup2 = [0, 0, 0, 0, 0, 0] #R
a_sup_2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
CP_old = [mm.v3(0., 0., 0.)]
# penalty method
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.] * len(bodyIDsToCheck)
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
dth_IK = ype.makeNestedList(DOFs)
d_th_IK = ype.makeNestedList(DOFs)
d_th_IK_L = ype.makeNestedList(DOFs)
d_th_IK_R = ype.makeNestedList(DOFs)
dd_th_IK = ype.makeNestedList(DOFs)
dd_th_IK_flat = ype.makeFlatList(totalDOF)
d_th_IK_flat = ype.makeFlatList(totalDOF)
ddth_c_flat = ype.makeFlatList(totalDOF)
# viewer
rd_footCenter = [None]
rd_footCenter_ref = [None]
rd_footCenterL = [None]
rd_footCenterR = [None]
rd_CM_plane = [None]
rd_CM_plane_ref = [None]
rd_CM_ref = [None]
rd_CM_des = [None]
rd_CM = [None]
rd_CM_vec = [None]
rd_CM_ref_vec = [None]
rd_CP = [None]
rd_CP_des = [None]
rd_dL_des_plane = [None]
rd_dH_des = [None]
rd_grf_des = [None]
rd_footCenter_des = [None]
rd_exf_des = [None]
rd_root_des = [None]
rd_soft_const_vec = [None]
rd_root = [None]
rd_footL_vec = [None]
rd_footR_vec = [None]
rd_CMP = [None]
rd_DesPosL = [None]
rd_DesPosR = [None]
rd_DesForePosL = [None]
rd_DesForePosR = [None]
rd_DesRearPosL = [None]
rd_DesRearPosR = [None]
rd_Joint = [None]
rd_Joint2 = [None]
rd_Joint3 = [None]
rd_Joint4 = [None]
rd_desPoints = [None]
#rd_contactForces = [None]*10000
#rd_contactPositions = [None]*10000
rd_virtualForce = [None]
rootPos = [None]
selectedBodyId = [selectedBody]
extraForce = [None]
applyedExtraForce = [None]
applyedExtraForce[0] = [0, 0, 0]
normalVector = [[0, 2, 0]]
if MULTI_VIEWER:
viewer = ymv.MultiViewer(800, 655)
#viewer = ymv.MultiViewer(1600, 1255)
viewer.setRenderers1([
cvr.VpModelRenderer(motionModel, CHARACTER_COLOR, yr.POLYGON_FILL)
])
viewer.setRenderers2([
cvr.VpModelRenderer(controlModel, CHARACTER_COLOR, yr.POLYGON_FILL)
])
else:
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,255,255), yr.LINK_BONE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer(
'motionModel',
cvr.VpModelRenderer(motionModel, (100, 100, 100),
yr.POLYGON_FILL)) #(150,150,255)
viewer.doc.addRenderer(
'controlModel',
cvr.VpModelRenderer(controlModel, CHARACTER_COLOR,
yr.POLYGON_FILL))
#viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(controlModel, CHARACTER_COLOR, yr.POLYGON_LINE))
#viewer.doc.addRenderer('rd_footCenter', yr.PointsRenderer(rd_footCenter))
#viewer.doc.addRenderer('rd_footCenter_des', yr.PointsRenderer(rd_footCenter_des, (150,0,150)) )
#viewer.doc.addRenderer('rd_footCenterL', yr.PointsRenderer(rd_footCenterL))
#viewer.doc.addRenderer('rd_footCenterR', yr.PointsRenderer(rd_footCenterR))
viewer.doc.addRenderer('rd_CM_plane',
yr.PointsRenderer(rd_CM_plane, (255, 255, 0)))
viewer.doc.addRenderer('rd_CM',
yr.PointsRenderer(rd_CM, (255, 0, 255)))
viewer.doc.addRenderer('rd_CM_des',
yr.PointsRenderer(rd_CM_des, (64, 64, 255)))
viewer.doc.addRenderer(
'rd_CM_vec',
yr.VectorsRenderer(rd_CM_vec, rd_CM_plane, (255, 0, 0), 3))
#viewer.doc.addRenderer('rd_CP_des', yr.PointsRenderer(rd_CP_des, (0,255,0)))
viewer.doc.addRenderer('rd_CP_des',
yr.PointsRenderer(rd_CP_des, (255, 0, 128)))
# viewer.doc.addRenderer('rd_dL_des_plane', yr.VectorsRenderer(rd_dL_des_plane, rd_CM, (255,255,0)))
# viewer.doc.addRenderer('rd_dH_des', yr.VectorsRenderer(rd_dH_des, rd_CM, (0,255,0)))
#viewer.doc.addRenderer('rd_grf_des', yr.ForcesRenderer(rd_grf_des, rd_CP, (0,255,255), .001))
viewer.doc.addRenderer(
'rd_exf_des',
yr.ForcesRenderer(rd_exf_des, rd_root_des, (0, 255, 0), .009,
0.04))
#viewer.doc.addRenderer('rd_CMP', yr.PointsRenderer(rd_CMP, (0,0,255)))
#viewer.doc.addRenderer('rd_DesPosL', yr.PointsRenderer(rd_DesPosL, (0,0,255)))
#viewer.doc.addRenderer('rd_DesPosR', yr.PointsRenderer(rd_DesPosR, (0,100,255)))
#viewer.doc.addRenderer('rd_DesForePosL', yr.PointsRenderer(rd_DesForePosL, (150,0,200)))
#viewer.doc.addRenderer('rd_DesForePosR', yr.PointsRenderer(rd_DesForePosR, (150,0,250)))
#viewer.doc.addRenderer('rd_DesRearPosL', yr.PointsRenderer(rd_DesRearPosL, (0,150,200)))
#viewer.doc.addRenderer('rd_DesRearPosR', yr.PointsRenderer(rd_DesRearPosR, (0,150,250)))
#viewer.doc.addRenderer('softConstraint', yr.VectorsRenderer(rd_soft_const_vec, rd_CMP, (150,100,100), 3))
#viewer.doc.addRenderer('rd_footLVec', yr.VectorsRenderer(rd_footL_vec, rd_footCenterL, (255,0,0), 3))
#viewer.doc.addRenderer('rd_footRVec', yr.VectorsRenderer(rd_footR_vec, rd_footCenterR, (255,255,0), 3))
#viewer.doc.addRenderer('rd_footCenter_ref', yr.PointsRenderer(rd_footCenter_ref))
#viewer.doc.addRenderer('rd_CM_plane_ref', yr.PointsRenderer(rd_CM_plane_ref, (255,255,0)))
#viewer.doc.addRenderer('rd_refNormalVec', yr.VectorsRenderer(normalVector, rd_footCenter_ref, (255,0,0), 3))
#viewer.doc.addRenderer('rd_refCMVec', yr.VectorsRenderer(rd_CM_ref_vec, rd_footCenter_ref, (255,0,255), 3))
#viewer.doc.addRenderer('rd_curNormalVec', yr.VectorsRenderer(normalVector, rd_footCenter, (255,0,0), 3))
#viewer.doc.addRenderer('rd_CMVec', yr.VectorsRenderer(rd_CM_vec, rd_footCenter, (255,0,255), 3))
#viewer.doc.addRenderer('rd_contactForces', yr.ForcesRenderer(rd_contactForces, rd_contactPositions, (0,255,0), .009, 0.009))
#viewer.doc.addRenderer('rd_virtualForce', yr.ForcesRenderer(rd_virtualForce, rd_CM, (50,255,0), 0.5, 0.02))
#viewer.doc.addRenderer('rd_Joint', yr.PointsRenderer(rd_Joint, (255,0,0)))
#viewer.doc.addRenderer('rd_Joint2', yr.PointsRenderer(rd_Joint2, (0,255,0)))
#viewer.doc.addRenderer('rd_Joint3', yr.PointsRenderer(rd_Joint3, (0,0,255)))
#viewer.doc.addRenderer('rd_Joint4', yr.PointsRenderer(rd_Joint4, (255,255,0)))
viewer.doc.addRenderer('rd_desPoints',
yr.PointsRenderer(rd_desPoints, (255, 0, 0)))
stage = STATIC_BALANCING
contactRendererName = []
for i in range(motion[0].skeleton.getJointNum()):
print(i, motion[0].skeleton.getJointName(i))
desCOMOffset = 0.0
pt = [0.]
timeReport = [0.] * 7
viewer.objectInfoWnd.comOffsetY.value(-0.05)
viewer.objectInfoWnd.comOffsetZ.value(0.00)
viewer.objectInfoWnd.begin()
viewer.objectInfoWnd.Bc = Fl_Value_Input(100, 450, 40, 10, 'Bc')
viewer.objectInfoWnd.Bc.value(0.1)
viewer.objectInfoWnd.ankleAngleX = Fl_Value_Input(50, 510, 40, 10,
'Ankle X')
viewer.objectInfoWnd.ankleAngleX.value(0)
viewer.objectInfoWnd.ankleAngleY = Fl_Value_Input(110, 510, 40, 10, 'Y')
viewer.objectInfoWnd.ankleAngleY.value(1)
viewer.objectInfoWnd.ankleAngleZ = Fl_Value_Input(170, 510, 40, 10, 'Z')
viewer.objectInfoWnd.ankleAngleZ.value(0)
viewer.objectInfoWnd.end()
viewer.objectInfoWnd.labelKt.value(50)
viewer.objectInfoWnd.labelKk.value(17)
config['Phalange'] = [ motion[0].skeleton.getJointIndex('LeftPhalange_1'),\
motion[0].skeleton.getJointIndex('LeftPhalange_2'),\
motion[0].skeleton.getJointIndex('RightPhalange_1'),\
motion[0].skeleton.getJointIndex('RightPhalange_2')]
config['Talus'] = [ motion[0].skeleton.getJointIndex('LeftTalus_1'),\
motion[0].skeleton.getJointIndex('LeftTalus_2'),\
motion[0].skeleton.getJointIndex('RightTalus_1'),\
motion[0].skeleton.getJointIndex('RightTalus_2')]
config['Calcaneus'] = [ motion[0].skeleton.getJointIndex('LeftCalcaneus_1'),\
motion[0].skeleton.getJointIndex('LeftCalcaneus_2'),\
motion[0].skeleton.getJointIndex('RightCalcaneus_1'),\
motion[0].skeleton.getJointIndex('RightCalcaneus_2')]
pose = motion[0].copy()
timeReport = [0.] * 2
def simulateCallback(frame):
curTime = time.time()
Ke = 0.0
Kt, Kk, Kl, Kh, Ksc, Bt, Bl, Bh, B_CM, B_CMSd, B_Toe = viewer.GetParam(
)
motionModel.update(motion[frame])
controlToMotionOffset = [-2.0, 0., 0.]
motionModel.translateByOffset(controlToMotionOffset)
stepsPerFrame = 10
for i in range(stepsPerFrame):
Kt, Kk, Kl, Kh, Ksc, Bt, Bl, Bh, B_CM, B_CMSd, B_Toe = viewer.GetParam(
)
#Kt, Kl, Kh, Bl, Bh, Ke = viewer.GetParam()
#qps.setupWeight(Kt, Kl, Kh, Ke, Bt, Btau, Bcon, Bl, Bh, Be)
qps.setupWeight(Kt, Kl, Kh, Ke, 10., .1, .1, Bl, Bh, 10.)
cPositions, CP, CM, footCenter, dL_des, CM_ref = qps.setupQP(
frame, motion, mcfg, controlModel, vpWorld, config,
1. / (30. * stepsPerFrame))
CM_ref[1] = 0.
timeReport[0] += time.time() - curTime
curTime = time.time()
#forceforce = np.array([viewer.objectInfoWnd.labelForceX.value(), viewer.objectInfoWnd.labelForceY.value(), viewer.objectInfoWnd.labelForceZ.value()])
#extraForce[0] = viewer.objectInfoWnd.labelFm.value() * mm.normalize2(forceforce)
#extraForcePos[0] = controlModel.getBodyPositionGlobal(selectedBody)
#if viewer.GetForceState() :
# qps.addExternalForces(extraForce[0], selectedBody, viewer.objectInfoWnd.labelForceDur.value());
# viewer.ResetForceState()
x, cForce = qps.stepQP(controlModel, 1. / (30. * stepsPerFrame))
timeReport[1] += time.time() - curTime
curTime = time.time()
print timeReport
if frame % 30 == 0:
print 'elapsed time for 30 frames:', time.time() - pt[0]
# rendering
#rd_footCenter[0] = footCenter
#
#rd_CM[0] = CM.copy()
#
#rd_CM_plane[0] = CM_plane.copy()
#
#rd_footCenter_ref[0] = footCenter_ref
#rd_CM_plane_ref[0] = CM_ref.copy()
#rd_CM_ref[0] = CM_ref.copy()
#rd_CM_ref_vec[0] = (CM_ref - footCenter_ref)*3.
#rd_CM_vec[0] = (CM - CM_plane)
#rd_CM_des[0] = CM_ref_plane.copy()
#rd_CM_des[0][1] = .01
#rd_CM_plane[0][1] = 0.
#if CP!=None and dCP!=None:
# # rd_CP[0] = CP
# # rd_CP_des[0] = CP_des
# #
# #rd_dL_des_plane[0] = dL_des_plane
# #rd_dH_des[0] = dH_des
# #
# #rd_grf_des[0] = totalNormalForce# - totalMass*mm.s2v(wcfg.gravity)#dL_des_plane - totalMass*mm.s2v(wcfg.gravity)
# #
# #rd_exf_des[0] = applyedExtraForce[0]
# #rd_root_des[0] = rootPos[0]
#
# #rd_CMP[0] = softConstPoint
#
# #rd_soft_const_vec[0] = controlModel.getBodyPositionGlobal(constBody)-softConstPoint
#
#
# ##indexL = motion[0].skeleton.getJointIndex('Hips')
# ##indexR = motion[0].skeleton.getJointIndex('Spine1')
# #indexL = indexFootL[0]
# #indexR = indexFootR[0]
#
# #curAng = [controlModel.getBodyOrientationGlobal(indexL)]
# #curAngY = np.dot(curAng, np.array([0,0,1]))
#
# #rd_footL_vec[0] = np.copy(curAngY[0])
# #rd_footCenterL[0] = controlModel.getBodyPositionGlobal(indexL)
# #
# #curAng = [controlModel.getBodyOrientationGlobal(indexR)]
# #curAngY = np.dot(curAng, np.array([0,0,1]))
#
#rd_footR_vec[0] = np.copy(curAngY[0])
#rd_footCenterR[0] = controlModel.getBodyPositionGlobal(indexR)
#
#if (forceApplyFrame == 0) :
# applyedExtraForce[0] = [0, 0, 0]
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1 / 30.)
viewer.show()
Fl.run()
def push_simbicon_mass():
# Trunk 29.27
# Head 5.89
# Pelvis 16.61
# Thigh 8.35
# Shank 4.16
# Foot 1.34
# Arm 2.79
# Forearm 1.21
# Hand 0.55
class ForceInfo:
def __init__(self, startFrame, duration, force):
self.startFrame = startFrame # frame
self.duration = duration # sec
self.force = force # Newton
self.targetBody = None
#===============================================================================
# load motion
#===============================================================================
MULTI_VIEWER = False
CAMERA_TRACKING = True
TORQUE_PLOT = False
# global parameters
Kt = 60.; Dt = 2*(Kt**.5)
Ks = 4000.; Ds = 2*(Ks**.5)
K_stb_vel = .1
mu = 2.
# constaants
c_min_contact_vel = 100.
# c_min_contact_vel = 2.
c_min_contact_time = .7
c_landing_duration = .2
c_taking_duration = .3
# c_swf_mid_offset = .0
c_swf_mid_offset = .02
c_swf_stability = .5
c_locking_vel = .05
# c_swf_offset = .0
c_swf_offset = .01
# c_swf_offset = .005
K_stp_pos = 0.
# c5 = .5; c6 = .01
c5 = .5; c6 = .02
# c5 = .5; c6 = .05
# c5 = 1.; c6 = .05
# c5 = .0; c6 = .0
K_stb_vel = .1
K_stb_pos = .1
OLD_SWING_HEIGHT = False
# OLD_SWING_HEIGHT = True
HIGHER_OFFSET = True
# HIGHER_OFFSET = False
dir = './ppmotion/'
# max push
# forceInfos = []
# maximum
# forceInfos = [ForceInfo(4*i*30, .4, (160,0,0)) for i in range(2,12)]
# forceInfos = [ForceInfo(4*i*30, .4, (-130,0,0)) for i in range(2,12)]
# forceInfos = [ForceInfo(4*i*30, .4, (0,0,80)) for i in range(2,12)]
forceInfos = [ForceInfo(4*i*30+1, .4, (0,0,-105)) for i in range(2,12)]
# # maximum with more checking
# forceInfos = [ForceInfo(4*i*30, .4, (145,0,0)) for i in range(2,12)]
# forceInfos = [ForceInfo(4*i*30+1, .4, (-120,0,0)) for i in range(2,12)]
# forceInfos = [ForceInfo(4*i*30+1, .4, (0,0,80)) for i in range(2,12)]
# forceInfos = [ForceInfo(4*i*30, .4, (0,0,-105)) for i in range(2,12)]
# # for video
# forceInfos = [ForceInfo(4*i*30+2, .4, (160,0,0)) for i in range(2,4)] \
# + [ForceInfo(4*i*30+2, .4, (0,0,-105)) for i in range(4,6)] \
# + [ForceInfo(4*i*30+2, .4, (-130,0,0)) for i in range(6,8)] \
# + [ForceInfo(4*i*30+2, .4, (0,0,80)) for i in range(8,10)]
# Kt = 40.; Dt = 2*(Kt**.5)
# Ks = 3000.; Ds = 2*(Ks**.5)
# mu = 1.
# c_swf_mid_offset = .04
# K_swp_vel_sag = .0; K_swp_vel_sag_faster = .0;
# K_swp_pos_sag = 1.5; K_swp_pos_sag_faster = .1;
# K_swp_vel_cor = .25; K_swp_pos_cor = .3
# K_stp_pos = 0.
# K_stb_vel = .02
# K_stb_pos = .15
Kt = 40.; Dt = 2*(Kt**.5)
Ks = 3000.; Ds = 2*(Ks**.5)
mu = 1.5
c_swf_mid_offset = .04
K_swp_vel_sag = .05; K_swp_vel_sag_faster = .0;
K_swp_pos_sag = 1.7; K_swp_pos_sag_faster = .1;
K_swp_vel_cor = .25; K_swp_pos_cor = .3
# K_stb_vel = .02
# K_stb_pos = .15
filename = 'wd2_WalkSameSame01_REPEATED.bvh'
motion_ori = yf.readBvhFile(dir+filename)
frameTime = 1/motion_ori.fps
if 'REPEATED' in filename:
REPEATED = True
CAMERA_TRACKING = True
else:
REPEATED = False
#===============================================================================
# options
#===============================================================================
SEGMENT_EDITING = True
STANCE_FOOT_STABILIZE = True
MATCH_STANCE_LEG = True
SWING_FOOT_PLACEMENT = True
SWING_FOOT_HEIGHT = True
if '_FOOT' in filename:
SWING_FOOT_ORIENTATION = True
else:
SWING_FOOT_ORIENTATION = False
STANCE_FOOT_PUSH = True
STANCE_FOOT_BALANCING = True
stitch_func = lambda x : 1. - yfg.hermite2nd(x)
stf_stabilize_func = yfg.concatenate([yfg.hermite2nd, yfg.one], [c_landing_duration])
match_stl_func = yfg.hermite2nd
# match_stl_func_y = yfg.hermite2nd
swf_placement_func = yfg.hermite2nd
swf_height_func = yfg.hermite2nd
swf_height_sine_func = yfg.sine
# stf_balancing_func = yfg.concatenate([yfg.hermite2nd, yfg.one], [c_landing_duration])
stf_balancing_func = yfg.hermite2nd
#===============================================================================
# initialize character
#===============================================================================
# mcfgfile = open(dir + 'mcfg', 'r')
mcfgfile = open('mcfg_simbicon', 'r')
mcfg = cPickle.load(mcfgfile)
mcfgfile.close()
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.useDefaultContactModel = False
wcfg.lockingVel = c_locking_vel
stepsPerFrame = 30
wcfg.timeStep = (frameTime)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion_ori[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion_ori[0], mcfg)
vpWorld.initialize()
print controlModel
motionModel.recordVelByFiniteDiff()
controlModel.initializeHybridDynamics()
#===============================================================================
# load segment info
#===============================================================================
skeleton = motion_ori[0].skeleton
segname = os.path.splitext(filename)[0]+'.seg'
segfile = open(dir+segname, 'r')
seginfo = cPickle.load(segfile)
segfile.close()
intervals = [info['interval'] for info in seginfo]
states = [info['state'] for info in seginfo]
temp_motion = copy.deepcopy(motion_ori)
segments = yma.splitMotionIntoSegments(temp_motion, intervals)
print len(intervals), 'segments'
for i in range(len(intervals)):
print '%dth'%i, yba.GaitState.text[states[i]], intervals[i], ',',
print
motion_seg_orig = ym.JointMotion()
motion_seg_orig += segments[0]
motion_seg = ym.JointMotion()
motion_seg += segments[0]
motion_stitch = ym.JointMotion()
motion_stitch += segments[0]
motion_stf_stabilize = ym.JointMotion()
motion_match_stl = ym.JointMotion()
motion_swf_placement = ym.JointMotion()
motion_swf_height = ym.JointMotion()
motion_swf_orientation = ym.JointMotion()
motion_stf_balancing = ym.JointMotion()
motion_stf_push = ym.JointMotion()
motion_control = ym.JointMotion()
motion_debug1 = ym.JointMotion()
motion_debug2 = ym.JointMotion()
motion_debug3 = ym.JointMotion()
P = ym.JointMotion()
P_hat = ym.JointMotion()
M_tc = ym.JointMotion()
M_hat_tc_1 = ym.JointMotion()
#===============================================================================
# loop variable
#===============================================================================
seg_index = [0]
acc_offset = [0]
extended = [False]
prev_R_swp = [None]
stl_y_limit_num = [0]
stl_xz_limit_num = [0]
avg_dCM = [mm.O_Vec3()]
# avg_stf_v = [mm.O_Vec3()]
# avg_stf_av = [mm.O_Vec3()]
# stf_push_func = [yfg.zero]
step_length_cur = [0.]
step_length_tar = [0.]
step_axis = [mm.O_Vec3()]
#===============================================================================
# information
#===============================================================================
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [mu]*len(bodyIDsToCheck)
bodyMasses = controlModel.getBodyMasses()
totalMass = controlModel.getTotalMass()
lID = controlModel.name2id('LeftFoot'); rID = controlModel.name2id('RightFoot')
lUpLeg = skeleton.getJointIndex('LeftUpLeg');rUpLeg = skeleton.getJointIndex('RightUpLeg')
lKnee = skeleton.getJointIndex('LeftLeg'); rKnee = skeleton.getJointIndex('RightLeg')
lFoot = skeleton.getJointIndex('LeftFoot'); rFoot = skeleton.getJointIndex('RightFoot')
spine = skeleton.getJointIndex('Spine')
uppers = [skeleton.getJointIndex(name) for name in ['Hips', 'Spine', 'Spine1', 'LeftArm', 'LeftForeArm', 'RightArm', 'RightForeArm']]
upperMass = sum([bodyMasses[i] for i in uppers])
lLegs = [skeleton.getJointIndex(name) for name in ['LeftUpLeg', 'LeftLeg', 'LeftFoot']]
rLegs = [skeleton.getJointIndex(name) for name in ['RightUpLeg', 'RightLeg', 'RightFoot']]
allJoints = set(range(skeleton.getJointNum()))
halfFootHeight = controlModel.getBodyShape(lFoot)[1] / 2.
for fi in forceInfos:
fi.targetBody = spine
#===========================================================================
# data collection
#===========================================================================
rhip_torques = []
rknee_torques = []
rankle_torques = []
#===============================================================================
# rendering
#===============================================================================
rd_CM = [None]; rd_CP = [None]; rd_CMP = [None]
rd_forces = [None]; rd_force_points = [None]
rd_torques = []; rd_joint_positions = []
rd_point1 = [None]
rd_point2 = [None]
rd_vec1 = [None]; rd_vecori1 = [None]
rd_vec2 = [None]; rd_vecori2 = [None]
rd_frame1 = [None]
rd_frame2 = [None]
if MULTI_VIEWER:
viewer = ymv.MultiViewer(800, 655, True, wheelWork=True)
# viewer = ymv.MultiViewer(1600, 1255)
viewer.setRenderers1([cvr.VpModelRenderer(motionModel, MOTION_COLOR, yr.POLYGON_FILL)])
viewer.setRenderers2([cvr.VpModelRenderer(controlModel, CHARACTER_COLOR, yr.POLYGON_FILL),
yr.ForcesRenderer(rd_forces, rd_force_points, (255,0,0), ratio=.01, lineWidth=.04, fromPoint=False)])
# viewer.glWindow2.groundOffset[0] -= 10
viewer.glWindow2.groundSize = 100
else:
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(motionModel, (0,150,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(controlModel, (200,200,200), yr.POLYGON_LINE))
# viewer.doc.addObject('motion_ori', motion_ori)
# viewer.doc.addRenderer('motion_ori', yr.JointMotionRenderer(motion_ori, (0,100,255), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_seg_orig', yr.JointMotionRenderer(motion_seg_orig, (0,100,255), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_seg', yr.JointMotionRenderer(motion_seg, (0,150,255), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_stitch', yr.JointMotionRenderer(motion_stitch, (0,255,200), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_stf_stabilize', yr.JointMotionRenderer(motion_stf_stabilize, (255,0,0), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_match_stl', yr.JointMotionRenderer(motion_match_stl, (255,200,0), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_swf_placement', yr.JointMotionRenderer(motion_swf_placement, (255,100,255), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_swf_height', yr.JointMotionRenderer(motion_swf_height, (50,255,255), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_swf_orientation', yr.JointMotionRenderer(motion_swf_orientation, (255,100,0), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_stf_push', yr.JointMotionRenderer(motion_stf_push, (50,255,200), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_stf_balancing', yr.JointMotionRenderer(motion_stf_balancing, (255,100,255), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_control', yr.JointMotionRenderer(motion_control, (255,0,0), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_debug1', yr.JointMotionRenderer(motion_debug1, (0,255,0), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_debug2', yr.JointMotionRenderer(motion_debug2, (255,0,255), yr.LINK_BONE))
# viewer.doc.addRenderer('motion_debug3', yr.JointMotionRenderer(motion_debug3, (255,255,0), yr.LINK_BONE))
# viewer.doc.addRenderer('M_tc', yr.JointMotionRenderer(M_tc, (255,255,0), yr.LINK_BONE))
# viewer.doc.addRenderer('P_hat', yr.JointMotionRenderer(P_hat, (255,255,0), yr.LINK_BONE))
# viewer.doc.addRenderer('P', yr.JointMotionRenderer(P, (255,255,0), yr.LINK_BONE))
# viewer.doc.addRenderer('M_hat_tc_1', yr.JointMotionRenderer(M_hat_tc_1, (255,255,0), yr.LINK_BONE))
# viewer.doc.addRenderer('rd_CM', yr.PointsRenderer(rd_CM, (255,255,0)))
# viewer.doc.addRenderer('rd_CP', yr.PointsRenderer(rd_CP, (255,0,0)))
# viewer.doc.addRenderer('rd_CMP', yr.PointsRenderer(rd_CMP, (0,255,0)))
viewer.doc.addRenderer('forces', yr.ForcesRenderer(rd_forces, rd_force_points, (255,0,0), ratio=.01, lineWidth=.04, fromPoint=False))
# viewer.doc.addRenderer('torques', yr.VectorsRenderer(rd_torques, rd_joint_positions, (255,0,0)))
# viewer.doc.addRenderer('rd_point1', yr.PointsRenderer(rd_point1, (0,255,0)))
# viewer.doc.addRenderer('rd_point2', yr.PointsRenderer(rd_point2, (255,0,0)))
# viewer.doc.addRenderer('rd_vec1', yr.VectorsRenderer(rd_vec1, rd_vecori1, (255,0,0)))
# viewer.doc.addRenderer('rd_vec2', yr.VectorsRenderer(rd_vec2, rd_vecori2, (0,255,0)))
# viewer.doc.addRenderer('rd_frame1', yr.FramesRenderer(rd_frame1, (0,200,200)))
# viewer.doc.addRenderer('rd_frame2', yr.FramesRenderer(rd_frame2, (200,200,0)))
# viewer.setMaxFrame(len(motion_ori)-1)
if not REPEATED:
viewer.setMaxFrame(len(motion_ori)-1)
else:
viewer.setMaxFrame(1440)
if CAMERA_TRACKING:
if MULTI_VIEWER:
cameraTargets1 = [None] * (viewer.getMaxFrame()+1)
cameraTargets2 = [None] * (viewer.getMaxFrame()+1)
else:
cameraTargets = [None] * (viewer.getMaxFrame()+1)
if TORQUE_PLOT:
rhip_torques = [0.]*viewer.getMaxFrame()
rknee_torques = [0.]*viewer.getMaxFrame()
rankle_torques = [0.]*viewer.getMaxFrame()
pt = [0.]
def postFrameCallback_Always(frame):
if frame==1: pt[0] = time.time()
if frame==31: print 'elapsed time for 30 frames:', time.time()-pt[0]
if CAMERA_TRACKING:
if MULTI_VIEWER:
if cameraTargets1[frame]==None:
cameraTargets1[frame] = motionModel.getBodyPositionGlobal(0)
# cameraTargets1[frame] = motion_ori[frame].getJointPositionGlobal(0)
viewer.setCameraTarget1(cameraTargets1[frame])
if cameraTargets2[frame]==None:
cameraTargets2[frame] = controlModel.getJointPositionGlobal(0)
viewer.setCameraTarget2(cameraTargets2[frame])
else:
if cameraTargets[frame]==None:
cameraTargets[frame] = controlModel.getJointPositionGlobal(0)
viewer.setCameraTarget(cameraTargets[frame])
if plot!=None:
plot.updateVline(frame)
viewer.setPostFrameCallback_Always(postFrameCallback_Always)
plot = None
# plot = ymp.InteractivePlot()
if plot!=None:
plot.setXlimit(0, len(motion_ori))
plot.setYlimit(0., 1.)
plot.addDataSet('zero')
plot.addDataSet('diff')
plot.addDataSet('debug1')
plot.addDataSet('debug2')
def viewer_onClose(data):
if plot!=None:
plot.close()
viewer.onClose(data)
viewer.callback(viewer_onClose)
def simulateCallback(frame):
# seginfo
segIndex = seg_index[0]
curState = seginfo[segIndex]['state']
curInterval = yma.offsetInterval(acc_offset[0], seginfo[segIndex]['interval'])
stanceLegs = seginfo[segIndex]['stanceHips']
swingLegs = seginfo[segIndex]['swingHips']
stanceFoots = seginfo[segIndex]['stanceFoots']
swingFoots = seginfo[segIndex]['swingFoots']
swingKnees = seginfo[segIndex]['swingKnees']
groundHeight = seginfo[segIndex]['ground_height']
# maxStfPushFrame = seginfo[segIndex]['max_stf_push_frame']
prev_frame = frame-1 if frame>0 else 0
# prev_frame = frame
# information
# dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(frame), bodyMasses, upperMass, uppers)
# CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(frame), bodyMasses, upperMass, uppers)
## dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(frame), bodyMasses, totalMass)
## CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(frame), bodyMasses, totalMass)
# stf_tar = motion_seg.getJointPositionGlobal(stanceFoots[0], frame)
# CMr_tar = CM_tar - stf_tar
dCM_tar = motion_seg.getJointVelocityGlobal(0, prev_frame)
CM_tar = motion_seg.getJointPositionGlobal(0, prev_frame)
# dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(prev_frame), bodyMasses, upperMass, uppers)
# CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(prev_frame), bodyMasses, upperMass, uppers)
# dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(prev_frame), bodyMasses, totalMass)
# CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(prev_frame), bodyMasses, totalMass)
stf_tar = motion_seg.getJointPositionGlobal(stanceFoots[0], prev_frame)
CMr_tar = CM_tar - stf_tar
dCM = avg_dCM[0]
CM = controlModel.getJointPositionGlobal(0)
# CM = yrp.getCM(controlModel.getJointPositionsGlobal(), bodyMasses, upperMass, uppers)
# CM = yrp.getCM(controlModel.getJointPositionsGlobal(), bodyMasses, totalMass)
CMreal = yrp.getCM(controlModel.getJointPositionsGlobal(), bodyMasses, totalMass)
stf = controlModel.getJointPositionGlobal(stanceFoots[0])
CMr = CM - stf
diff_dCM = mm.projectionOnPlane(dCM-dCM_tar, (1,0,0), (0,0,1))
diff_dCM_axis = np.cross((0,1,0), diff_dCM)
rd_vec1[0] = diff_dCM; rd_vecori1[0] = CM_tar
diff_CMr = mm.projectionOnPlane(CMr-CMr_tar, (1,0,0), (0,0,1))
# rd_vec1[0] = diff_CMr; rd_vecori1[0] = stf_tar
diff_CMr_axis = np.cross((0,1,0), diff_CMr)
direction = mm.normalize2(mm.projectionOnPlane(dCM_tar, (1,0,0), (0,0,1)))
# direction = mm.normalize2(mm.projectionOnPlane(dCM, (1,0,0), (0,0,1)))
directionAxis = np.cross((0,1,0), direction)
diff_dCM_sag, diff_dCM_cor = mm.projectionOnVector2(diff_dCM, direction)
# rd_vec1[0] = diff_dCM_sag; rd_vecori1[0] = CM_tar
diff_dCM_sag_axis = np.cross((0,1,0), diff_dCM_sag)
diff_dCM_cor_axis = np.cross((0,1,0), diff_dCM_cor)
diff_CMr_sag, diff_CMr_cor = mm.projectionOnVector2(diff_CMr, direction)
diff_CMr_sag_axis = np.cross((0,1,0), diff_CMr_sag)
diff_CMr_cor_axis = np.cross((0,1,0), diff_CMr_cor)
t = (frame-curInterval[0])/float(curInterval[1]-curInterval[0])
t_raw = t
if t>1.: t=1.
p_root = motion_stitch[frame].getJointPositionGlobal(0)
R_root = motion_stitch[frame].getJointOrientationGlobal(0)
motion_seg_orig.goToFrame(frame)
motion_seg.goToFrame(frame)
motion_stitch.goToFrame(frame)
motion_debug1.append(motion_stitch[frame].copy())
motion_debug1.goToFrame(frame)
motion_debug2.append(motion_stitch[frame].copy())
motion_debug2.goToFrame(frame)
motion_debug3.append(motion_stitch[frame].copy())
motion_debug3.goToFrame(frame)
# paper implementation
M_tc.append(motion_stitch[prev_frame])
M_tc.goToFrame(frame)
P_hat.append(M_tc[frame].copy())
P_hat.goToFrame(frame)
p_temp = ym.JointPosture(skeleton)
p_temp.rootPos = controlModel.getJointPositionGlobal(0)
p_temp.setJointOrientationsLocal(controlModel.getJointOrientationsLocal())
P.append(p_temp)
P.goToFrame(frame)
# stance foot stabilize
motion_stf_stabilize.append(motion_stitch[frame].copy())
motion_stf_stabilize.goToFrame(frame)
if STANCE_FOOT_STABILIZE:
for stanceFoot in stanceFoots:
R_target_foot = motion_seg[frame].getJointOrientationGlobal(stanceFoot)
R_current_foot = motion_stf_stabilize[frame].getJointOrientationGlobal(stanceFoot)
motion_stf_stabilize[frame].setJointOrientationGlobal(stanceFoot, cm.slerp(R_current_foot, R_target_foot , stf_stabilize_func(t)))
# R_target_foot = motion_seg[frame].getJointOrientationLocal(stanceFoot)
# R_current_foot = motion_stf_stabilize[frame].getJointOrientationLocal(stanceFoot)
# motion_stf_stabilize[frame].setJointOrientationLocal(stanceFoot, cm.slerp(R_current_foot, R_target_foot , stf_stabilize_func(t)))
# match stance leg
motion_match_stl.append(motion_stf_stabilize[frame].copy())
motion_match_stl.goToFrame(frame)
if MATCH_STANCE_LEG:
if curState!=yba.GaitState.STOP:
for i in range(len(stanceLegs)):
stanceLeg = stanceLegs[i]
stanceFoot = stanceFoots[i]
# # motion stance leg -> character stance leg as time goes
R_motion = motion_match_stl[frame].getJointOrientationGlobal(stanceLeg)
R_character = controlModel.getJointOrientationGlobal(stanceLeg)
motion_match_stl[frame].setJointOrientationGlobal(stanceLeg, cm.slerp(R_motion, R_character, match_stl_func(t)))
# t_y = match_stl_func_y(t)
# t_xz = match_stl_func(t)
#
# R_motion = motion_match_stl[frame].getJointOrientationGlobal(stanceLeg)
# R_character = controlModel.getJointOrientationGlobal(stanceLeg)
# R = np.dot(R_character, R_motion.T)
# R_y, R_xz = mm.projectRotation((0,1,0), R)
# motion_match_stl[frame].mulJointOrientationGlobal(stanceLeg, mm.scaleSO3(R_xz, t_xz))
# motion_match_stl[frame].mulJointOrientationGlobal(stanceLeg, mm.scaleSO3(R_y, t_y))
# swing foot placement
motion_swf_placement.append(motion_match_stl[frame].copy())
motion_swf_placement.goToFrame(frame)
if SWING_FOOT_PLACEMENT:
t_swing_foot_placement = swf_placement_func(t);
if extended[0]:
R_swp_sag = prev_R_swp[0][0]
R_swp_cor = prev_R_swp[0][1]
else:
R_swp_sag = mm.I_SO3(); R_swp_cor = mm.I_SO3()
R_swp_cor = np.dot(R_swp_cor, mm.exp(diff_dCM_cor_axis * K_swp_vel_cor * -t_swing_foot_placement))
if np.dot(direction, diff_CMr_sag) < 0:
R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_dCM_sag_axis * K_swp_vel_sag * -t_swing_foot_placement))
R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_CMr_sag_axis * K_swp_pos_sag * -t_swing_foot_placement))
else:
R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_dCM_sag_axis * K_swp_vel_sag_faster * -t_swing_foot_placement))
R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_CMr_sag_axis * K_swp_pos_sag_faster * -t_swing_foot_placement))
R_swp_cor = np.dot(R_swp_cor, mm.exp(diff_CMr_cor_axis * K_swp_pos_cor * -t_swing_foot_placement))
for i in range(len(swingLegs)):
swingLeg = swingLegs[i]
swingFoot = swingFoots[i]
# save swing foot global orientation
# R_swf = motion_swf_placement[frame].getJointOrientationGlobal(swingFoot)
# rotate swing leg
motion_swf_placement[frame].mulJointOrientationGlobal(swingLeg, R_swp_sag)
motion_swf_placement[frame].mulJointOrientationGlobal(swingLeg, R_swp_cor)
# restore swing foot global orientation
# motion_swf_placement[frame].setJointOrientationGlobal(swingFoot, R_swf)
prev_R_swp[0] = (R_swp_sag, R_swp_cor)
# swing foot height
motion_swf_height.append(motion_swf_placement[frame].copy())
motion_swf_height.goToFrame(frame)
if SWING_FOOT_HEIGHT:
for swingFoot in swingFoots:
stanceFoot = stanceFoots[0]
# save foot global orientation
R_foot = motion_swf_height[frame].getJointOrientationGlobal(swingFoot)
R_stance_foot = motion_swf_height[frame].getJointOrientationGlobal(stanceFoot)
if OLD_SWING_HEIGHT:
height_tar = motion_swf_height[frame].getJointPositionGlobal(swingFoot)[1] - motion_swf_height[frame].getJointPositionGlobal(stanceFoot)[1]
else:
height_tar = motion_swf_height[prev_frame].getJointPositionGlobal(swingFoot)[1] - groundHeight
d_height_tar = motion_swf_height.getJointVelocityGlobal(swingFoot, prev_frame)[1]
# height_tar += c_swf_mid_offset * swf_height_sine_func(t)
# motion_debug1[frame] = motion_swf_height[frame].copy()
# rotate
motion_swf_height[frame].rotateByTarget(controlModel.getJointOrientationGlobal(0))
# motion_debug2[frame] = motion_swf_height[frame].copy()
# motion_debug2[frame].translateByTarget(controlModel.getJointPositionGlobal(0))
if OLD_SWING_HEIGHT:
height_cur = motion_swf_height[frame].getJointPositionGlobal(swingFoot)[1] - motion_swf_height[frame].getJointPositionGlobal(stanceFoot)[1]
else:
height_cur = controlModel.getJointPositionGlobal(swingFoot)[1] - halfFootHeight - c_swf_offset
d_height_cur = controlModel.getJointVelocityGlobal(swingFoot)[1]
if OLD_SWING_HEIGHT:
offset_height = (height_tar - height_cur) * swf_height_func(t) * c5
else:
offset_height = ((height_tar - height_cur) * c5
+ (d_height_tar - d_height_cur) * c6) * swf_height_func(t)
offset_sine = c_swf_mid_offset * swf_height_sine_func(t)
# offset_sine = 0.
offset = 0.
offset += offset_height
offset += offset_sine
if offset > 0.:
newPosition = motion_swf_height[frame].getJointPositionGlobal(swingFoot)
newPosition[1] += offset
aik.ik_analytic(motion_swf_height[frame], swingFoot, newPosition)
else:
if HIGHER_OFFSET:
newPosition = motion_swf_height[frame].getJointPositionGlobal(stanceFoot)
newPosition[1] -= offset
aik.ik_analytic(motion_swf_height[frame], stanceFoot, newPosition)
# return
# motion_debug3[frame] = motion_swf_height[frame].copy()
# motion_debug3[frame].translateByTarget(controlModel.getJointPositionGlobal(0))
motion_swf_height[frame].rotateByTarget(R_root)
# restore foot global orientation
motion_swf_height[frame].setJointOrientationGlobal(swingFoot, R_foot)
motion_swf_height[frame].setJointOrientationGlobal(stanceFoot, R_stance_foot)
if plot!=None:
plot.addDataPoint('debug1', frame, offset_height)
plot.addDataPoint('debug2', frame, height_tar - height_cur)
# plot.addDataPoint('diff', frame, diff)
# swing foot orientation
motion_swf_orientation.append(motion_swf_height[frame].copy())
motion_swf_orientation.goToFrame(frame)
if SWING_FOOT_ORIENTATION:
swf_orientation_func = yfg.concatenate([yfg.zero, yfg.hermite2nd, yfg.one], [.25, .75])
for swingFoot in swingFoots:
R_target_foot = motion_seg[curInterval[1]].getJointOrientationGlobal(swingFoot)
R_current_foot = motion_swf_orientation[frame].getJointOrientationGlobal(swingFoot)
motion_swf_orientation[frame].setJointOrientationGlobal(swingFoot, cm.slerp(R_current_foot, R_target_foot, swf_orientation_func(t)))
# swf_stabilize_func = yfg.concatenate([yfg.hermite2nd, yfg.one], [c_taking_duration])
# push orientation
# for swingFoot in swingFoots:
# R_target_foot = motion_seg[frame].getJointOrientationGlobal(swingFoot)
# R_current_foot = motion_swf_orientation[frame].getJointOrientationGlobal(swingFoot)
# motion_swf_orientation[frame].setJointOrientationGlobal(swingFoot, cm.slerp(R_current_foot, R_target_foot , swf_stabilize_func(t)))
# stance foot push
motion_stf_push.append(motion_swf_orientation[frame].copy())
motion_stf_push.goToFrame(frame)
if STANCE_FOOT_PUSH:
for swingFoot in swingFoots:
# max_t = (maxStfPushFrame)/float(curInterval[1]-curInterval[0])
# stf_push_func = yfg.concatenate([yfg.sine, yfg.zero], [max_t*2])
stf_push_func = yfg.concatenate([yfg.sine, yfg.zero], [c_taking_duration*2])
R_swp_sag = mm.I_SO3()
# R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_dCM_sag_axis * K_stp_vel * -stf_push_func(t)))
# if step_length_cur[0] < step_length_tar[0]:
# ratio = step_length_cur[0] / step_length_tar[0]
# R_max = maxmaxStfPushFrame
# R_zero =
R_swp_sag = np.dot(R_swp_sag, mm.exp((step_length_tar[0] - step_length_cur[0])*step_axis[0] * K_stp_pos * -stf_push_func(t)))
motion_stf_push[frame].mulJointOrientationGlobal(swingFoot, R_swp_sag)
# stance foot balancing
motion_stf_balancing.append(motion_stf_push[frame].copy())
motion_stf_balancing.goToFrame(frame)
if STANCE_FOOT_BALANCING:
R_stb = mm.exp(diff_dCM_axis * K_stb_vel * stf_balancing_func(t))
R_stb = np.dot(R_stb, mm.exp(diff_CMr_axis * K_stb_pos * stf_balancing_func(t)))
for stanceFoot in stanceFoots:
if frame < 5: continue
motion_stf_balancing[frame].mulJointOrientationGlobal(stanceFoot, R_stb)
# control trajectory
motion_control.append(motion_stf_balancing[frame].copy())
motion_control.goToFrame(frame)
#=======================================================================
# tracking with inverse dynamics
#=======================================================================
th_r = motion_control.getDOFPositions(frame)
th = controlModel.getDOFPositions()
dth_r = motion_control.getDOFVelocities(frame)
dth = controlModel.getDOFVelocities()
ddth_r = motion_control.getDOFAccelerations(frame)
ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt)
#=======================================================================
# simulation
#=======================================================================
CP = mm.v3(0.,0.,0.)
F = mm.v3(0.,0.,0.)
avg_dCM[0] = mm.v3(0.,0.,0.)
# external force rendering info
del rd_forces[:]; del rd_force_points[:]
for fi in forceInfos:
if fi.startFrame <= frame and frame < fi.startFrame + fi.duration*(1/frameTime):
rd_forces.append(fi.force)
rd_force_points.append(controlModel.getBodyPositionGlobal(fi.targetBody) + -mm.normalize2(fi.force)*.2)
for i in range(stepsPerFrame):
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)
vpWorld.applyPenaltyForce(bodyIDs, contactPositionLocals, contactForces)
# apply external force
for fi in forceInfos:
if fi.startFrame <= frame and frame < fi.startFrame + fi.duration*(1/frameTime):
controlModel.applyBodyForceGlobal(fi.targetBody, fi.force)
controlModel.setDOFAccelerations(ddth_des)
controlModel.solveHybridDynamics()
# # apply external force
# for fi in forceInfos:
# if fi.startFrame <= frame and frame < fi.startFrame + fi.duration*(1/frameTime):
# controlModel.applyBodyForceGlobal(fi.targetBody, fi.force)
vpWorld.step()
# yvu.align2D(controlModel)
if len(contactForces) > 0:
CP += yrp.getCP(contactPositions, contactForces)
F += sum(contactForces)
avg_dCM[0] += controlModel.getJointVelocityGlobal(0)
# avg_dCM[0] += yrp.getCM(controlModel.getJointVelocitiesGlobal(), bodyMasses, upperMass, uppers)
# avg_dCM[0] += yrp.getCM(controlModel.getJointVelocitiesGlobal(), bodyMasses, totalMass)
# if len(stanceFoots)>0:
# avg_stf_v[0] += controlModel.getJointVelocityGlobal(stanceFoots[0])
# avg_stf_av[0] += controlModel.getJointAngVelocityGlobal(stanceFoots[0])
CP /= stepsPerFrame
F /= stepsPerFrame
avg_dCM[0] /= stepsPerFrame
# if len(stanceFoots)>0:
# avg_stf_v[0] /= stepsPerFrame
# avg_stf_av[0] /= stepsPerFrame
# rd_vec1[0] = avg_stf_av[0]; rd_vec1[0][0] = 0.; rd_vec1[0][2] = 0.
# rd_vecori1[0]= controlModel.getJointPositionGlobal(stanceFoots[0])
#=======================================================================
# segment editing
#=======================================================================
lastFrame = False
if SEGMENT_EDITING:
if curState==yba.GaitState.STOP:
if frame == len(motion_seg)-1:
lastFrame = True
elif (curState==yba.GaitState.LSWING or curState==yba.GaitState.RSWING) and t>c_min_contact_time:
swingID = lID if curState==yba.GaitState.LSWING else rID
contact = False
if swingID in bodyIDs:
minContactVel = 1000.
for i in range(len(bodyIDs)):
if bodyIDs[i]==swingID:
vel = controlModel.getBodyVelocityGlobal(swingID, contactPositionLocals[i])
vel[1] = 0
contactVel = mm.length(vel)
if contactVel < minContactVel: minContactVel = contactVel
if minContactVel < c_min_contact_vel: contact = True
extended[0] = False
if contact:
# print frame, 'foot touch'
lastFrame = True
acc_offset[0] += frame - curInterval[1]
elif frame == len(motion_seg)-1:
print frame, 'extend frame', frame+1
preserveJoints = []
# preserveJoints = [lFoot, rFoot]
# preserveJoints = [lFoot, rFoot, lKnee, rKnee]
# preserveJoints = [lFoot, rFoot, lKnee, rKnee, lUpLeg, rUpLeg]
stanceKnees = [rKnee] if curState==yba.GaitState.LSWING else [lKnee]
preserveJoints = [stanceFoots[0], stanceKnees[0], stanceLegs[0]]
diff = 3
motion_seg_orig.extend([motion_seg_orig[-1]])
motion_seg.extend(ymt.extendByIntegration_root(motion_seg, 1, diff))
motion_stitch.extend(ymt.extendByIntegration_constant(motion_stitch, 1, preserveJoints, diff))
# # extend for swing foot ground speed matching & swing foot height lower
## extendedPostures = ymt.extendByIntegration(motion_stitch, 1, preserveJoints, diff)
## extendedPostures = [motion_stitch[-1]]
##
# extendFrameNum = frame - curInterval[1] + 1
# k = 1.-extendFrameNum/5.
# if k<0.: k=0.
# extendedPostures = ymt.extendByIntegrationAttenuation(motion_stitch, 1, preserveJoints, diff, k)
#
## if len(swingFoots)>0 and np.inner(dCM_tar, dCM)>0.:
## print frame, 'speed matching'
## R_swf = motion_stitch[-1].getJointOrientationGlobal(swingFoots[0])
##
## p_swf = motion_stitch[-1].getJointPositionGlobal(swingFoots[0])
## v_swf = motion_stitch.getJointVelocityGlobal(swingFoots[0], frame-diff, frame)
## a_swf = motion_stitch.getJointAccelerationGlobal(swingFoots[0], frame-diff, frame)
## p_swf += v_swf * (frameTime) + a_swf * (frameTime)*(frameTime)
## aik.ik_analytic(extendedPostures[0], swingFoots[0], p_swf)
##
## extendedPostures[0].setJointOrientationGlobal(swingFoots[0], R_swf)
#
# motion_stitch.extend(extendedPostures)
extended[0] = True
else:
if frame == len(motion_seg)-1: lastFrame = True
if lastFrame:
if segIndex < len(segments)-1:
print '%d (%d): end of %dth seg (%s, %s)'%(frame, frame-curInterval[1],segIndex, yba.GaitState.text[curState], curInterval)
if plot!=None: plot.addDataPoint('diff', frame, (frame-curInterval[1])*.01)
if len(stanceFoots)>0 and len(swingFoots)>0:
# step_cur = controlModel.getJointPositionGlobal(swingFoots[0]) - controlModel.getJointPositionGlobal(stanceFoots[0])
# step_tar = motion_seg[curInterval[1]].getJointPositionGlobal(swingFoots[0]) - motion_seg[curInterval[1]].getJointPositionGlobal(stanceFoots[0])
step_cur = controlModel.getJointPositionGlobal(0) - controlModel.getJointPositionGlobal(stanceFoots[0])
step_tar = motion_seg[curInterval[1]].getJointPositionGlobal(0) - motion_seg[curInterval[1]].getJointPositionGlobal(stanceFoots[0])
step_cur = mm.projectionOnPlane(step_cur, (1,0,0), (0,0,1))
step_tar = mm.projectionOnPlane(step_tar, (1,0,0), (0,0,1))
step_cur_sag, step_cur_cor = mm.projectionOnVector2(step_cur, direction)
step_tar_sag, step_tar_cor = mm.projectionOnVector2(step_tar, direction)
step_length_tar[0] = mm.length(step_tar_sag)
if np.inner(step_tar_sag, step_cur_sag) > 0:
step_length_cur[0] = mm.length(step_cur_sag)
else:
step_length_cur[0] = -mm.length(step_cur_sag)
step_axis[0] = directionAxis
# rd_vec1[0] = step_tar_sag
# rd_vecori1[0] = motion_seg[curInterval[1]].getJointPositionGlobal(stanceFoots[0])
# rd_vec2[0] = step_cur_sag
# rd_vecori2[0] = controlModel.getJointPositionGlobal(stanceFoots[0])
seg_index[0] += 1
curSeg = segments[seg_index[0]]
stl_y_limit_num[0] = 0
stl_xz_limit_num[0] = 0
del motion_seg_orig[frame+1:]
motion_seg_orig.extend(ymb.getAttachedNextMotion(curSeg, motion_seg_orig[-1], False, False))
del motion_seg[frame+1:]
del motion_stitch[frame+1:]
transitionLength = len(curSeg)-1
# motion_seg.extend(ymb.getAttachedNextMotion(curSeg, motion_seg[-1], False, False))
# motion_stitch.extend(ymb.getStitchedNextMotion(curSeg, motion_control[-1], transitionLength, stitch_func, True, False))
d = motion_seg[-1] - curSeg[0]
d.rootPos[1] = 0.
motion_seg.extend(ymb.getAttachedNextMotion(curSeg, d, True, False))
d = motion_control[-1] - curSeg[0]
d.rootPos[1] = 0.
motion_stitch.extend(ymb.getStitchedNextMotion(curSeg, d, transitionLength, stitch_func, True, False))
# motion_seg.extend(ymb.getAttachedNextMotion(curSeg, motion_seg[-1], False, True))
# motion_stitch.extend(ymb.getStitchedNextMotion(curSeg, motion_control[-1], transitionLength, stitch_func, True, True))
else:
motion_seg_orig.append(motion_seg_orig[-1])
motion_seg.append(motion_seg[-1])
motion_stitch.append(motion_control[-1])
# rendering
motionModel.update(motion_ori[frame])
# motionModel.update(motion_seg[frame])
rd_CP[0] = CP
rd_CMP[0] = (CMreal[0] - (F[0]/F[1])*CMreal[1], 0, CMreal[2] - (F[2]/F[1])*CMreal[1])
if plot!=None:
plot.addDataPoint('zero', frame, 0)
plot.updatePoints()
viewer.setSimulateCallback(simulateCallback)
if MULTI_VIEWER:
viewer.startTimer(frameTime / 1.4)
else:
viewer.startTimer(frameTime * .1)
viewer.show()
Fl.run()
def main():
np.set_printoptions(precision=4, linewidth=200)
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_5()
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
#controlModel2 = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
controlModel.translateByOffset((1.5, 0, 0))
#controlModel2.initializeHybridDynamics()
#controlModel2.translateByOffset((2.5,0,0))
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
# parameter
Kt = config['Kt']
Dt = config['Dt'] # tracking gain
Kl = config['Kl']
Dl = config['Dl'] # linear balance gain
Kh = config['Kh']
Dh = config['Dh'] # angular balance gain
Ks = config['Ks']
Ds = config['Ds'] # penalty force spring gain
Bt = config['Bt']
Bl = config['Bl']
Bh = config['Bh']
w = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap'])
sup = motion[0].skeleton.getJointIndex(config['supLink'])
sup2 = motion[0].skeleton.getJointIndex(config['supLink2'])
# jacobian
Jsup = yjc.makeEmptyJacobian(DOFs, 1)
dJsup = Jsup.copy()
Jsys = yjc.makeEmptyJacobian(DOFs, controlModel.getBodyNum())
dJsys = Jsys.copy()
supJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, sup)]
allLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)
Jsup2 = yjc.makeEmptyJacobian(DOFs, 1)
dJsup2 = Jsup2.copy()
supJointMasks2 = [yjc.getLinkJointMask(motion[0].skeleton, sup2)]
CMJointMask = supJointMasks
for iMask in range(len(CMJointMask[0])):
if supJointMasks2[0][iMask] == 1:
CMJointMask[0][iMask] = 1
Jt = yjc.makeEmptyJacobian(DOFs, 1)
# momentum matrix
linkMasses = controlModel.getBodyMasses()
totalMass = controlModel.getTotalMass()
TO = ymt.make_TO(linkMasses)
dTO = ymt.make_dTO(len(linkMasses))
# optimization
problem = yac.LSE(totalDOF, 6)
a_sup = (0, 0, 0, 0, 0, 0)
CP_old = [mm.v3(0., 0., 0.)]
# penalty method
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.] * len(bodyIDsToCheck)
##### Parameter
'''
(0, 'Hips')
(1, 'LeftUpLeg')
(2, 'LeftLeg')
(3, 'LeftFoot')
(4, 'RightUpLeg')
(5, 'RightLeg')
(6, 'RightFoot')
(7, 'Spine')
(8, 'Spine1')
(9, 'LeftArm')
(10, 'LeftForeArm')
(11, 'RightArm')
(12, 'RightForeArm')
'''
Kp = [None] * len(bodyIDsToCheck)
Kd = [None] * len(bodyIDsToCheck)
#Kp = [0, 400, 450, 400, 400, 450, 400, 300, 250, 60, 25, 60, 25]
#Kp = [0, 450, 450, 400, 450, 450, 400, 450, 300, 100, 25, 100, 25]
UpLeg = 310
Leg = 400
Foot = 310
Spine = 350
Neck = 200
Arm = 10
Hand = 10
Kp = [
0, UpLeg, Leg, Foot, UpLeg, Leg, Foot, Spine, Neck, Arm, Hand, Arm,
Hand
]
'''
for i in range(0, len(Kp)) :
Kp[i] = Kp[i]*0.8
'''
#Kd = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
#Kd = [0, 2.0, 1.5, 1.2, 2.0, 1.5, 1.2, 2.0, 0.1, 0.1, 0.1, 0.1, 0.1]
#Kd = [0, 1.5, 2.0, 1.2, 1.5, 2.0, 1.2, 1.5, 0.4, 0.5, 0.2, 0.5, 0.2]
'''
dUpLeg = 1.7
dLeg = 1.7
dFoot = 1.2
dSpine = 1.4
dNeck = 0.9
dArm = 0.8
dHand = 0.2
'''
dUpLeg = 2 * (UpLeg**.5)
dLeg = 2 * (Leg**.5)
dFoot = 2 * (Foot**.5)
dSpine = 2 * (Spine**.5)
dNeck = 2 * (Neck**.5)
dArm = 2 * (Arm**.5)
dHand = 2 * (Hand**.5)
Kd = [
0, dUpLeg, dLeg, dFoot, dUpLeg, dLeg, dFoot, dSpine, dNeck, dArm,
dHand, dArm, dHand
]
for i in range(0, len(Kd)):
Kd[i] = Kd[i] * 0.022
'''
for ii in bodyIDsToCheck :
print(ii, controlModel.index2name(ii))
'''
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
# viewer
rd_footCenter = [None]
rd_footCenter1 = [None]
rd_footCenter2 = [None]
rd_CM_plane = [None]
rd_CM = [None]
rd_CP = [None]
rd_CP_des = [None]
rd_dL_des_plane = [None]
rd_dH_des = [None]
rd_grf_des = [None]
rd_vf = [None]
rd_contactPoint1 = [None]
rd_contactPoint2 = [None]
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('control', yr.JointMotionRenderer(motion, (0,255,255), yr.LINK_BONE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer(
'motionModel',
cvr.VpModelRenderer(motionModel, (150, 150, 255), yr.POLYGON_FILL))
viewer.doc.addRenderer(
'controlModel',
cvr.VpModelRenderer(controlModel, (255, 240, 255), yr.POLYGON_FILL))
#viewer.doc.addRenderer('controlModel2', cvr.VpModelRenderer(controlModel2, (155,100,100), yr.POLYGON_FILL))
#viewer.doc.addRenderer('rd_footCenter', yr.PointsRenderer(rd_footCenter))
#viewer.doc.addRenderer('rd_footCenter1', yr.PointsRenderer(rd_footCenter1, (255, 0, 255)))
#viewer.doc.addRenderer('rd_footCenter2', yr.PointsRenderer(rd_footCenter2, (0, 255, 255)))
#viewer.doc.addRenderer('rd_CM_plane', yr.PointsRenderer(rd_CM_plane, (255,255,0)))
#viewer.doc.addRenderer('rd_CM', yr.PointsRenderer(rd_CM, (255,255,0)))
#viewer.doc.addRenderer('rd_contactPoint', yr.PointsRenderer(rd_contactPoint1, (0,0,255)))
#viewer.doc.addRenderer('rd_contactPoint2', yr.PointsRenderer(rd_contactPoint2, (0,255,255)))
#viewer.doc.addRenderer('rd_CP', yr.PointsRenderer(rd_CP, (255,0,255)))
# viewer.doc.addRenderer('rd_CP_des', yr.PointsRenderer(rd_CP_des, (255,0,255)))
# viewer.doc.addRenderer('rd_dL_des_plane', yr.VectorsRenderer(rd_dL_des_plane, rd_CM, (255,255,0)))
# viewer.doc.addRenderer('rd_dH_des', yr.VectorsRenderer(rd_dH_des, rd_CM, (0,255,0)))
#viewer.doc.addRenderer('rd_grf_des', yr.ForcesRenderer(rd_grf_des, rd_CP_des, (0,255,0), .001))
viewer.doc.addRenderer('rd_vf',
yr.ForcesRenderer(rd_vf, rd_CM, (0, 0, 255), .005))
global stage
stage = 0
def simulateCallback(frame):
motionModel.update(motion[frame])
# tracking
th_r = motion.getDOFPositions(frame)
th = controlModel.getDOFPositions()
dth_r = motion.getDOFVelocities(frame)
dth = controlModel.getDOFVelocities()
ddth_r = motion.getDOFAccelerations(frame)
ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r,
Kt, Dt)
'''
th2 = controlModel2.getDOFPositions()
dth2 = controlModel2.getDOFVelocities()
ddth_des2 = yct.getDesiredDOFAccelerations(th_r, th2, dth_r, dth2, ddth_r, Kt, Dt)
'''
#ype.flatten(ddth_des, ddth_des_flat)
#ype.flatten(dth, dth_flat)
#Control
#tracking control
#print(Kt, Dt)
#Tpd = yct.getDesiredDOFTorques(th_r, th, dth_r, dth, 100.0, 0.1)#0.65, 0.031)
linkPositions = controlModel.getBodyPositionsGlobal()
linkVelocities = controlModel.getBodyVelocitiesGlobal()
linkAngVelocities = controlModel.getBodyAngVelocitiesGlobal()
linkInertias = controlModel.getBodyInertiasGlobal()
jointPositions = controlModel.getJointPositionsGlobal()
jointAxeses = controlModel.getDOFAxeses()
CM = yrp.getCM(linkPositions, linkMasses, totalMass)
dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)
footCenter1 = controlModel.getBodyPositionGlobal(sup)
footCenter2 = controlModel.getBodyPositionGlobal(sup2)
footCenter = (footCenter1 + footCenter2) / 2
'''
yjc.computeJacobian2(Jt, DOFs, jointPositions, jointAxeses, [CM], CMJointMask)
pHatCom = CM - footCenter
vCom = dCM
'''
CM_plane = copy.copy(CM)
CM_plane[1] = 0.
dCM_plane = copy.copy(dCM)
dCM_plane[1] = 0.
CM_ref_plane = footCenter
dL_des_plane = Kl * totalMass * (CM_ref_plane -
CM_plane) - Dl * totalMass * dCM_plane
dL_des_plane[1] = 0.
CP_ref = footCenter
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(
bodyIDsToCheck, mus, Ks, Ds)
CP = yrp.getCP(contactPositions, contactForces)
if CP_old[0] == None or CP == None:
dCP = None
else:
dCP = (CP - CP_old[0]) / (1 / 30.)
CP_old[0] = CP
if CP != None and dCP != None:
ddCP_des = Kh * (CP_ref - CP) - Dh * (dCP)
CP_des = CP + dCP * (1 / 30.) + .5 * ddCP_des * ((1 / 30.)**2)
dH_des = np.cross(
(CP_des - CM),
(dL_des_plane - totalMass * mm.s2v(wcfg.gravity)))
else:
dH_des = None
################
'''
linkPositions = motionModel.getBodyPositionsGlobal()
linkVelocities = motionModel.getBodyVelocitiesGlobal()
linkAngVelocities = motionModel.getBodyAngVelocitiesGlobal()
linkInertias = motionModel.getBodyInertiasGlobal()
CM2 = yrp.getCM(linkPositions, linkMasses, totalMass)
dCM2 = yrp.getCM(linkVelocities, linkMasses, totalMass)
footCenter1 = motionModel.getBodyPositionGlobal(sup)
footCenter2 = motionModel.getBodyPositionGlobal(sup2)
footCenter = (footCenter1+footCenter2)/2
pHatComDes = CM2 - footCenter
vComDes = dCM2
Wcp = -750
Wcv = -10
fCom = Wcp*(pHatComDes - pHatCom) + Wcv*(vComDes - vCom)
'''
#print("VirtualForce", fCom)
#fCom[0] = 0.
#fCom[1] = 0.
#fCom[2] = -20.
#fCom = [0., 0., 100.]
#print("VirtualForce", fCom)
for i in range(stepsPerFrame):
# apply penalty force
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(
bodyIDsToCheck, mus, Ks, Ds)
vpWorld.applyPenaltyForce(bodyIDs, contactPositionLocals,
contactForces)
controlModel.setDOFAccelerations(ddth_des)
linkPositions = controlModel.getBodyPositionsGlobal()
linkVelocities = controlModel.getBodyVelocitiesGlobal()
linkAngVelocities = controlModel.getBodyAngVelocitiesGlobal()
linkInertias = controlModel.getBodyInertiasGlobal()
jointPositions = controlModel.getJointPositionsGlobal()
jointAxeses = controlModel.getDOFAxeses()
CM = yrp.getCM(linkPositions, linkMasses, totalMass)
dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)
footCenter1 = controlModel.getBodyPositionGlobal(sup)
footCenter2 = controlModel.getBodyPositionGlobal(sup2)
footCenter = (footCenter1 + footCenter2) / 2
CM_plane = copy.copy(CM)
CM_plane[1] = 0.
footCenter_plane = copy.copy(footCenter)
footCenter_plane[1] = 0.
yjc.computeJacobian2(Jt, DOFs, jointPositions, jointAxeses, [CM],
CMJointMask)
pHatCom = CM - footCenter
vCom = dCM
linkPositions2 = motionModel.getBodyPositionsGlobal()
linkVelocities2 = motionModel.getBodyVelocitiesGlobal()
linkAngVelocities2 = motionModel.getBodyAngVelocitiesGlobal()
linkInertias2 = motionModel.getBodyInertiasGlobal()
CM2 = yrp.getCM(linkPositions2, linkMasses, totalMass)
dCM2 = yrp.getCM(linkVelocities2, linkMasses, totalMass)
footCenter1 = motionModel.getBodyPositionGlobal(sup)
footCenter2 = motionModel.getBodyPositionGlobal(sup2)
footCenter = (footCenter1 + footCenter2) / 2
pHatComDes = CM2 - footCenter
vComDes = dCM2
Wcp = 0
Wcv = 0
Wcm = 0
'''
0 : initial
1 : contact
2 : fly
3 : landing
'''
global stage
if len(contactForces) == 0:
if stage == 1:
stage = 2
print("fly")
else:
if stage == 0:
stage = 1
print("contact")
elif stage == 2:
stage = 3
print("landing")
Wcp = -550
Wcv = -100
Wcm = 0
if stage == 1:
Wcp = -550
Wcv = -100
Wcm = 0
#Wcp = -550
#Wcv = -100
elif stage == 3:
#Wcp = -950
#Wcv = -300
Wcp = -950
Wcv = -300
Wcm = 0
# COM Position control
fCom = Wcp * (pHatComDes - pHatCom) + Wcv * (
vComDes - vCom) + Wcm * (footCenter_plane - CM_plane)
if len(contactForces) == 0:
fCom[0] = 0.
fCom[1] = -10. #-10
fCom[2] = 0.
'''
fCom[0] = 10.
fCom[1] = 0.
fCom[2] = 250.
'''
# Angular Momentum control
L_ref = 0
L_con = 0
#R,i
for i in range(1, controlModel.getBodyNum()):
L_ref += (
linkMasses[i] *
np.cross(linkPositions2[i] - [CM], linkVelocities2[i]) +
linkInertias2[i] * linkAngVelocities2[i])
L_con += (
linkMasses[i] *
np.cross(linkPositions[i] - [CM], linkVelocities[i]) +
linkInertias[i] * linkAngVelocities[i])
for iJoint in range(1, 7): # from 'LeftUpLeg'(1) to 'RightFoot'(6)
JpT1 = (Jt[0][6 + 3 * (iJoint - 1)],
Jt[1][6 + 3 * (iJoint - 1)],
Jt[2][6 + 3 * (iJoint - 1)])
JpT2 = (Jt[0][6 + 3 * (iJoint - 1) + 1],
Jt[1][6 + 3 * (iJoint - 1) + 1],
Jt[2][6 + 3 * (iJoint - 1) + 1])
JpT3 = (Jt[0][6 + 3 * (iJoint - 1) + 2],
Jt[1][6 + 3 * (iJoint - 1) + 2],
Jt[2][6 + 3 * (iJoint - 1) + 2])
Tfi = (np.dot(JpT1, fCom), np.dot(JpT2,
fCom), np.dot(JpT3, fCom))
currentT = controlModel.getJointAngAccelerationLocal(iJoint)
controlModel.setJointAngAccelerationLocal(
iJoint, currentT + Tfi)
currentT = controlModel.getJointAngAccelerationLocal(0)
#print(currentT)
#JpT = ( Jt[0][0], Jt[1][0], Jt[2][0])
#Tfi = JpT*fCom
#controlModel.setJointAngAccelerationLocal(0, currentT+Tfi)
'''
if (len(contactForces) != 0) :
for iJoint in range(1, 7): # from 'LeftUpLeg'(1) to 'RightFoot'(6)
JpT = ( Jt[0][6+3*(iJoint-1)], Jt[1][6+3*(iJoint-1)], Jt[2][6+3*(iJoint-1)])
Tfi = JpT*fCom
currentT = controlModel.getJointAngAccelerationLocal(iJoint)
controlModel.setJointAngAccelerationLocal(iJoint, currentT+Tfi)
else:
print("No Contact force!!")
'''
controlModel.solveHybridDynamics()
vpWorld.step()
# rendering
rd_CM[0] = CM
rd_CM_plane[0] = CM.copy()
rd_CM_plane[0][1] = 0.
if CP != None and dCP != None:
rd_CP[0] = CP
rd_CP_des[0] = CP_des
rd_dL_des_plane[0] = dL_des_plane
rd_dH_des[0] = dH_des
rd_grf_des[0] = dL_des_plane - totalMass * mm.s2v(wcfg.gravity)
rd_vf[0] = fCom
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1 / 30.)
viewer.show()
Fl.run()
def test_CM_CP():
# bvhFilePath = '../samples/chain_6.bvh'
# bvhFilePath = '../samples/block_3_rotate.bvh'
# bvhFilePath = '../samples/block_tree_rotate.bvh'
bvhFilePath = '../samples/chain_2.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 100.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
node = mcfg.getNode('link0')
node.density = 200.
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.useDefaultContactModel = False
# wcfg.gravity = (0,0,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
motionModel.recordVelByFiniteDiff()
controlModel.translateByOffset((0,.5,.5))
CMPos_cm = [mm.O_Vec3()]
CMVel_cm = [mm.O_Vec3()]
CMPos_mm = [mm.O_Vec3()]
CPPos_cm = [mm.O_Vec3()]
CPVel_cm = [mm.O_Vec3()]
bodyMasses = controlModel.getBodyMasses()
totalMass = 0.
for m in bodyMasses:
totalMass += m
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [.5]*len(bodyIDsToCheck)
contactPositions= []
contactForces = []
viewer = ysv.SimpleViewer()
viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
# viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(motionModel, (100,100,100), yr.POLYGON_LINE))
viewer.doc.addRenderer('CMPos_cm', yr.PointsRenderer(CMPos_cm, (255,0,255)))
viewer.doc.addRenderer('CMVel_cm', yr.VectorsRenderer(CMVel_cm, CMPos_cm, (255,0,255)))
viewer.doc.addRenderer('CMPos_mm', yr.PointsRenderer(CMPos_mm, (200,0,200)))
viewer.doc.addRenderer('CPPos_cm', yr.PointsRenderer(CPPos_cm, (0,255,0)))
viewer.doc.addRenderer('CPVel_cm', yr.VectorsRenderer(CPVel_cm, CPPos_cm, (0,255,0)))
viewer.doc.addRenderer('contactPositions', yr.PointsRenderer(contactPositions, (0,0,255), yr.POINT_POINT))
viewer.doc.addRenderer('contactForces', yr.VectorsRenderer(contactForces, contactPositions,(0,0,255)))
def simulateCallback(frame):
controlModel.applyBodyTorqueGlobal(1, (0,10,0))
for i in range(stepsPerFrame):
bodyIDs, positions, positionLocals, forces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, 1000, 2*(1000**.5))
vpWorld.applyPenaltyForce(bodyIDs, positionLocals, forces)
vpWorld.step()
del contactPositions[:]
del contactForces[:]
contactPositions[:] = positions
contactForces[:] = forces
motionModel.update(motion[frame])
bodyPositions = controlModel.getBodyPositionsGlobal()
bodyVelocities = controlModel.getBodyVelocitiesGlobal()
CMPos_cm[0] = yrp.getCM(bodyPositions, bodyMasses, totalMass)
CMVel_cm[0] = yrp.getCM(bodyVelocities, bodyMasses, totalMass)
bodyPositions_ref = motionModel.getBodyPositionsGlobal()
bodyVelocities_ref = motionModel.getBodyVelocitiesGlobal()
CMPos_mm[0] = yrp.getCM(bodyPositions_ref, bodyMasses, totalMass)
CPPos_cm_old = CPPos_cm[0]
CPPos_cm[0] = yrp.getCP(positions, forces)
if CPPos_cm_old==None or CPPos_cm[0]==None:
CPVel_cm[0] = None
else:
CPVel_cm[0] = (CPPos_cm[0] - CPPos_cm_old)/(1./30.)
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_momentum_standard():
np.set_printoptions(precision=2, linewidth=200)
bvhFilePath = '../samples/chain_1_long.bvh'
motion1 = yf.readBvhFile(bvhFilePath)
bvhFilePath = '../samples/chain_2.bvh'
motion2 = yf.readBvhFile(bvhFilePath)
mcfg1 = ypc.ModelConfig()
mcfg1.defaultDensity = 1000.
mcfg1.defaultBoneRatio = 1.
for i in range(motion1[0].skeleton.getElementNum()):
mcfg1.addNode(motion1[0].skeleton.getElementName(i))
mcfg2 = ypc.ModelConfig()
mcfg2.defaultDensity = 1000.
mcfg2.defaultBoneRatio = 1.
for i in range(motion2[0].skeleton.getElementNum()):
mcfg2.addNode(motion2[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.gravity = (0, 0, 0)
stepsPerFrame = 30
wcfg.timeStep = (1 / 30.) / stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
m1 = cvm.VpControlModel(vpWorld, motion1[0], mcfg1)
m2 = cvm.VpControlModel(vpWorld, motion2[0], mcfg2)
vpWorld.initialize()
force = 1000
# force = 0
torque = 400
m1.translateByOffset((0, 1, 1))
m1.applyBodyTorqueGlobal(0, (0, 0, torque))
m1.applyBodyForceGlobal(0, (force, 0, 0))
m2.translateByOffset((0, 1, 0))
m2.applyBodyTorqueGlobal(0, (0, 0, torque / 2.))
m2.applyBodyTorqueGlobal(1, (0, 0, torque / 2.))
m2.applyBodyForceGlobal(0, (force / 2., 0, 0))
m2.applyBodyForceGlobal(1, (force / 2., 0, 0))
masses_m1 = m1.getBodyMasses()
masses_m2 = m2.getBodyMasses()
totalMass_m1 = m1.getTotalMass()
totalMass_m2 = m2.getTotalMass()
p = []
v = []
CM = []
L_std = []
H_std = []
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer(
'model', cvr.VpModelRenderer(m2, (255, 240, 255), yr.POLYGON_LINE))
viewer.doc.addRenderer(
'model2', cvr.VpModelRenderer(m1, (255, 240, 255),
yr.POLYGON_LINE))
# viewer.doc.addRenderer('v', yr.VectorsRenderer(v, p, (0,255,0)))
viewer.doc.addRenderer('L_std',
yr.VectorsRenderer(L_std, CM, (255, 0, 0)))
viewer.doc.addRenderer('H_std',
yr.VectorsRenderer(H_std, CM, (255, 0, 0)))
viewer.setMaxFrame(100)
def simulateCallback(frame):
for i in range(stepsPerFrame):
vpWorld.step()
velocities_m1 = m1.getBodyVelocitiesGlobal()
velocities_m2 = m2.getBodyVelocitiesGlobal()
positions_m1 = m1.getBodyPositionsGlobal()
positions_m2 = m2.getBodyPositionsGlobal()
CM_m1 = m1.getBodyPositionGlobal(0)
CM_m2 = yrp.getCM(positions_m2, masses_m2, totalMass_m2)
inertias_m1 = m1.getBodyInertiasGlobal()
inertias_m2 = m2.getBodyInertiasGlobal()
angVelocities_m1 = m1.getBodyAngVelocitiesGlobal()
angVelocities_m2 = m2.getBodyAngVelocitiesGlobal()
L1_std = getLinearMomentum(masses_m1, velocities_m1)
L2_std = getLinearMomentum(masses_m2, velocities_m2)
H1_std = getAngularMomentum(CM_m1, inertias_m1, angVelocities_m1,
positions_m1, masses_m1, velocities_m1)
H2_std = getAngularMomentum(CM_m2, inertias_m2, angVelocities_m2,
positions_m2, masses_m2, velocities_m2)
#===============================================================================
# for rendering
#===============================================================================
p[:] = m1.getBodyPositionsGlobal() + m2.getBodyPositionsGlobal()
v[:] = m1.getBodyVelocitiesGlobal() + m2.getBodyVelocitiesGlobal()
CM[:] = [
yrp.getCM(m1.getBodyPositionsGlobal(), m1.getBodyMasses()),
CM_m2
]
L_std[:] = [L1_std, L2_std]
H_std[:] = [H1_std, H2_std]
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1 / 30.)
viewer.show()
Fl.run()
def test_slope_character():
bvhFilePath = '../samples/wd2_WalkSameSame01.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfgfile = open('../samples/' + 'mcfg', 'r')
mcfg = cPickle.load(mcfgfile)
mcfgfile.close()
frameTime = 1/30.
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.useDefaultContactModel = False
stepsPerFrame = 30
wcfg.timeStep = (frameTime)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.]*len(bodyIDsToCheck)
Kt = 20.; Dt = 2*(Kt**.5)
Ks = 2000; Ds = 2*(Ks**.5)
rd_box = yr.BoxesRenderer([(5., .2, 3.)], [mm.Rp2T(mm.rotZ(0.1), (0,-.5,0))], (0,0,255), yr.POLYGON_LINE)
contactPositions= []
contactForces = []
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('contactPositions', yr.PointsRenderer(contactPositions, (0,255,0), yr.POINT_POINT))
viewer.doc.addRenderer('contactForces', yr.VectorsRenderer(contactForces, contactPositions,(0,255,0)))
viewer.doc.addRenderer('rd_box', rd_box)
viewer.setMaxFrame(500)
def simulateCallback(frame):
th_r = motion.getDOFPositions(frame)
th = controlModel.getDOFPositions()
dth_r = motion.getDOFVelocities(frame)
dth = controlModel.getDOFVelocities()
ddth_r = motion.getDOFAccelerations(frame)
ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt)
for i in range(stepsPerFrame):
# get penalty forces
# bodyIDs, positions, positionLocals, forces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, 1000, 10)
bodyIDs, positions, positionLocals, forces = vpWorld.calcPenaltyForce_Boxes(rd_box.boxSizes, rd_box.Ts, bodyIDsToCheck, mus, 1000, 10)
# apply penalty forces
vpWorld.applyPenaltyForce(bodyIDs, positionLocals, forces)
controlModel.setDOFAccelerations(ddth_des)
controlModel.solveHybridDynamics()
vpWorld.step()
contactPositions[:] = positions
contactForces[:] = forces
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_penalty_model():
bvhFilePath = '../samples/chain_1.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 100.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.useDefaultContactModel = False
wcfg.gravity = (0,-9.8,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
controlModel2 = cvm.VpControlModel(vpWorld, motion[0], mcfg)
controlModel3 = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.translateByOffset((0,1,0))
controlModel2.translateByOffset((0,1,.5))
controlModel3.translateByOffset((0,1,1.))
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1., .2, .1]
Ks = 1000; Ds = 2*(Ks**.5)
contactPositions= []
contactForces = []
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('model2', cvr.VpModelRenderer(controlModel2, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('model3', cvr.VpModelRenderer(controlModel3, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('contactPositions', yr.PointsRenderer(contactPositions, (0,255,0), yr.POINT_POINT))
viewer.doc.addRenderer('contactForces', yr.VectorsRenderer(contactForces, contactPositions,(0,255,0)))
viewer.setMaxFrame(500)
def simulateCallback(frame):
for i in range(stepsPerFrame):
controlModel.applyBodyForceGlobal(0, (1,0,0))
controlModel2.applyBodyForceGlobal(0, (1,0,0))
controlModel3.applyBodyForceGlobal(0, (1,0,0))
# get penalty forces
bodyIDs, positions, positionLocals, forces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, 1000, 10)
# apply penalty forces
vpWorld.applyPenaltyForce(bodyIDs, positionLocals, forces)
vpWorld.step()
contactPositions[:] = positions
contactForces[:] = forces
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def test_body_pos_vel_acc_funcs():
# bvhFilePath = '../samples/chain_6.bvh'
# bvhFilePath = '../samples/block_3_rotate.bvh'
bvhFilePath = '../samples/block_tree_rotate.bvh'
motion = yf.readBvhFile(bvhFilePath)
bvhFilePath = '../samples/chain_1.bvh'
motion2 = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
# mcfg.getNode('root').density = 1000000.
mcfg2 = ypc.ModelConfig()
for i in range(motion2[0].skeleton.getElementNum()):
mcfg2.addNode(motion2[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
# wcfg.gravity = (0,0,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
controlModel2 = cvm.VpControlModel(vpWorld, motion2[0], mcfg2)
vpWorld.initialize()
controlModel.fixBody(0)
motionModel.recordVelByFiniteDiff()
controlModel2.setBodyPositionGlobal(0, (0,1,-1))
cm_p = [mm.O_Vec3()]*controlModel.getBodyNum()
cm_v = [mm.O_Vec3()]*controlModel.getBodyNum()
cm_a = [mm.O_Vec3()]*controlModel.getBodyNum()
cm_av = [mm.O_Vec3()]*controlModel.getBodyNum()
cm_aa = [mm.O_Vec3()]*controlModel.getBodyNum()
mm_p = [mm.O_Vec3()]*motionModel.getBodyNum()
mm_v = [mm.O_Vec3()]*motionModel.getBodyNum()
mm_a = [mm.O_Vec3()]*motionModel.getBodyNum()
mm_av = [mm.O_Vec3()]*motionModel.getBodyNum()
mm_aa = [mm.O_Vec3()]*motionModel.getBodyNum()
viewer = ysv.SimpleViewer()
viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(motionModel, (100,100,100), yr.POLYGON_LINE))
viewer.doc.addRenderer('controlModel2', cvr.VpModelRenderer(controlModel2, (255,240,255), yr.POLYGON_LINE))
# viewer.doc.addRenderer('cm_p', yr.PointsRenderer(cm_p, (0,0,255)))
viewer.doc.addRenderer('cm_v', yr.VectorsRenderer(cm_v, cm_p, (255,0,0)))
# viewer.doc.addRenderer('cm_a', yr.VectorsRenderer(cm_a, cm_p, (0,255,0)))
# viewer.doc.addRenderer('cm_av', yr.VectorsRenderer(cm_av, cm_p, (255,255,0)))
# viewer.doc.addRenderer('cm_aa', yr.VectorsRenderer(cm_aa, cm_p, (0,255,255)))
# viewer.doc.addRenderer('mm_p', yr.PointsRenderer(mm_p, (200,200,0)))
viewer.doc.addRenderer('mm_v', yr.VectorsRenderer(mm_v, mm_p, (200,200,0)))
# viewer.doc.addRenderer('mm_a', yr.VectorsRenderer(mm_a, mm_p, (200,200,0)))
# viewer.doc.addRenderer('mm_av', yr.VectorsRenderer(mm_av, mm_p, (0,200,0)))
controlModel.applyBodyTorqueGlobal(1, (0,0,200))
controlModel2.applyBodyTorqueGlobal(0, (0,0,200))
def simulateCallback(frame):
for i in range(stepsPerFrame):
vpWorld.step()
motionModel.update(motion[frame])
# controlModel.applyBodyTorqueGlobal(1, (0,0,10))
# controlModel2.applyBodyTorqueGlobal(0, (0,0,10))
cm_p[:] = controlModel.getBodyPositionsGlobal() + controlModel2.getBodyPositionsGlobal()
cm_v[:] = controlModel.getBodyVelocitiesGlobal() + controlModel2.getBodyVelocitiesGlobal()
# cm_p.append(controlModel.getBodyPositionGlobal(1, (0,0,.25)))
# cm_v.append(controlModel.getBodyVelocityGlobal(1, (0,0,.25)))
# cm_p.append(controlModel.getBodyPositionGlobal(1, (0,0,-.25)))
# cm_v.append(controlModel.getBodyVelocityGlobal(1, (0,0,-.25)))
cm_a[:] = controlModel.getBodyAccelerationsGlobal() + controlModel2.getBodyAccelerationsGlobal()
cm_av[:] = controlModel.getBodyAngVelocitiesGlobal() + controlModel2.getBodyAngVelocitiesGlobal()
cm_aa[:] = controlModel.getBodyAngAccelerationsGlobal() + controlModel2.getBodyAngAccelerationsGlobal()
mm_p[:] = motionModel.getBodyPositionsGlobal()
mm_v[:] = motionModel.getBodyVelocitiesGlobal()
mm_av[:] = motionModel.getBodyAngVelocitiesGlobal()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def init():
global motion
global mcfg
global wcfg
global stepsPerFrame
global config
global mcfg_motion
global vpWorld
global controlModel
global totalDOF
global DOFs
global bodyIDsToCheck
global torques_nested
global ddth_des_flat
global dth_flat
global ddth_sol
global rd_cForces
global rd_cPositions
global rd_jointPos
global rd_cForcesControl
global rd_cPositionsControl
global rd_ForceControl
global rd_ForceDes
global rd_Position
global rd_PositionDes
global viewer
np.set_printoptions(precision=4, linewidth=200)
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_legs()
mcfg_motion = mit.normal_mcfg()
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
# vpWorld.SetIntegrator("RK4")
# vpWorld.SetIntegrator("IMPLICIT_EULER_FAST")
vpWorld.SetIntegrator("EULER")
# vpWorld.SetGlobalDamping(0.001)
# controlModel.initializeHybridDynamics()
controlModel.initializeForwardDynamics()
ModelOffset = np.array([0., 5.5, 0.])
controlModel.translateByOffset(ModelOffset)
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
bodyIDsToCheck = range(vpWorld.getBodyNum())
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
torques_nested = ype.makeNestedList(DOFs)
rd_cForces = [None]
rd_cPositions = [None]
rd_cForcesControl = [None]
rd_cPositionsControl = [None]
rd_ForceControl = [None]
rd_ForceDes = [None]
rd_Position = [None]
rd_PositionDes = [None]
rd_jointPos = [None]
viewer = hsv.hpSimpleViewer()
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer(
'controlModel',
cvr.VpModelRenderer(controlModel, CHARACTER_COLOR, yr.POLYGON_FILL))
viewer.doc.addRenderer(
'rd_contactForcesControl',
yr.VectorsRenderer(rd_cForcesControl, rd_cPositionsControl,
(255, 0, 0), .1))
viewer.doc.addRenderer(
'rd_contactForces',
yr.VectorsRenderer(rd_cForces, rd_cPositions, (0, 255, 0), .1))
viewer.doc.addRenderer(
'rd_contactForceControl',
yr.VectorsRenderer(rd_ForceControl, rd_Position, (0, 0, 255), .1))
viewer.doc.addRenderer(
'rd_contactForceDes',
yr.VectorsRenderer(rd_ForceDes, rd_PositionDes, (255, 0, 255), .1))
# viewer.doc.addRenderer('rd_jointPos', yr.PointsRenderer(rd_jointPos))
viewer.objectInfoWnd.add1DSlider('PD gain',
minVal=0.,
maxVal=1000.,
initVal=180.,
valStep=.1)
viewer.objectInfoWnd.add1DSlider('Joint Damping',
minVal=1.,
maxVal=2000.,
initVal=35.,
valStep=1.)
viewer.objectInfoWnd.add1DSlider('steps per frame',
minVal=1.,
maxVal=200.,
initVal=config['stepsPerFrame'],
valStep=1.)
viewer.objectInfoWnd.add1DSlider('1/simul speed',
minVal=1.,
maxVal=100.,
initVal=config['simulSpeedInv'],
valStep=1.)
viewer.objectInfoWnd.add1DSlider('normal des force min',
minVal=0.,
maxVal=3000.,
initVal=80.,
valStep=1.)
viewer.objectInfoWnd.add1DSlider('normal des force max',
minVal=0.,
maxVal=3000.,
initVal=80.,
valStep=1.)
viewer.objectInfoWnd.add1DSlider('des force begin',
minVal=0.,
maxVal=len(motion) - 1,
initVal=70.,
valStep=1.)
viewer.objectInfoWnd.add1DSlider('des force dur',
minVal=0.,
maxVal=len(motion) - 1,
initVal=20.,
valStep=1.)
viewer.objectInfoWnd.add1DSlider('force weight',
minVal=-10.,
maxVal=10.,
initVal=0.,
valStep=.01)
viewer.objectInfoWnd.add1DSlider('tracking weight',
minVal=-10.,
maxVal=10.,
initVal=0.,
valStep=.01)
viewer.objectInfoWnd.add1DSlider('tau weight',
minVal=-10.,
maxVal=10.,
initVal=0.,
valStep=.01)
viewer.cForceWnd.addDataSet('expForce', FL_BLACK)
viewer.cForceWnd.addDataSet('desForceMin', FL_RED)
viewer.cForceWnd.addDataSet('desForceMax', FL_RED)
viewer.cForceWnd.addDataSet('realForce', FL_GREEN)
for i in range(motion[0].skeleton.getJointNum()):
print(i, motion[0].skeleton.getJointName(i))
print "(index, id, name)"
for i in range(controlModel.getBodyNum()):
print(i, controlModel.index2id(i), controlModel.index2name(i))
def main():
np.set_printoptions(precision=4, linewidth=200)
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_5()
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
ModelOffset = (1.5, -0.02, 0)
#ModelOffset = (1.5, 1.02, 0)
#ModelOffset = (1.5, 0.02, 0)
controlModel.translateByOffset(ModelOffset)
#controlModel.translateByOffset((1.5,-0.0328,0))#(1.5,-0.02,0))
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
# parameter
Kt = config['Kt']; Dt = config['Dt'] # tracking gain
Kl = config['Kl']; Dl = config['Dl'] # linear balance gain
Kh = config['Kh']; Dh = config['Dh'] # angular balance gain
Ks = config['Ks']; Ds = config['Ds'] # penalty force spring gain
Bt = config['Bt']
Bl = config['Bl']
Bh = config['Bh']
w = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap'])
w_IK = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['IKweightMap'])
supL = motion[0].skeleton.getJointIndex(config['supLink'])
supR = motion[0].skeleton.getJointIndex(config['supLink2'])
#controlModel.SetGround(supL, True)
#controlModel.SetGround(supR, True)
selectedBody = motion[0].skeleton.getJointIndex(config['end'])
#constBody = motion[0].skeleton.getJointIndex('LeftForeArm')
constBody = motion[0].skeleton.getJointIndex('Hips')
# jacobian
JsupL = yjc.makeEmptyJacobian(DOFs, 1)
dJsupL = JsupL.copy()
JsupPreL = JsupL.copy()
JsupR = yjc.makeEmptyJacobian(DOFs, 1)
dJsupR = JsupR.copy()
JsupPreR = JsupR.copy()
Jsup = yjc.makeEmptyJacobian(DOFs, 1)
dJsup = Jsup.copy()
JsupPre = Jsup.copy()
Jsys = yjc.makeEmptyJacobian(DOFs, controlModel.getBodyNum())
dJsys = Jsys.copy()
JsysPre = Jsys.copy()
Jconst = yjc.makeEmptyJacobian(DOFs, 1)
dJconst = Jconst.copy()
supLJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, supL)]
supRJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, supR)]
constJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, constBody)]
allLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)
# momentum matrix
linkMasses = controlModel.getBodyMasses()
totalMass = controlModel.getTotalMass()
TO = ymt.make_TO(linkMasses)
dTO = ymt.make_dTO(len(linkMasses))
# optimization
problem = yac.LSE(totalDOF, 6)
a_sup = (0,0,0, 0,0,0) #L
#a_sup2 = (0,0,0, 0,0,0)#R
a_sup2 = [0,0,0, 0,0,0]#R
a_sup_2 = [0,0,0, 0,0,0, 0,0,0, 0,0,0]
CP_old = [mm.v3(0.,0.,0.)]
# penalty method
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.]*len(bodyIDsToCheck)
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
d_th_IK = ype.makeNestedList(DOFs)
d_th_IK_L = ype.makeNestedList(DOFs)
d_th_IK_R = ype.makeNestedList(DOFs)
dd_th_IK = ype.makeNestedList(DOFs)
dd_th_IK_flat = ype.makeFlatList(totalDOF)
d_th_IK_flat = ype.makeFlatList(totalDOF)
ddth_c_flat = ype.makeFlatList(totalDOF)
# viewer
rd_footCenter = [None]
rd_footCenter_ref = [None]
rd_footCenterL = [None]
rd_footCenterR = [None]
rd_CM_plane = [None]
rd_CM_plane_ref = [None]
rd_CM = [None]
rd_CP = [None]
rd_CP_des = [None]
rd_dL_des_plane = [None]
rd_dH_des = [None]
rd_grf_des = [None]
rd_exf_des = [None]
rd_root_des = [None]
rd_soft_const_vec = [None]
rd_CMP = [None]
rd_DesPosL = [None]
rd_DesPosR = [None]
rootPos = [None]
selectedBodyId = [selectedBody]
extraForce = [None]
applyedExtraForce = [None]
applyedExtraForce[0] = [0,0,0]
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,255,255), yr.LINK_BONE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(motionModel, (150,150,255), yr.POLYGON_FILL))
viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_FILL))
viewer.doc.addRenderer('rd_footCenter', yr.PointsRenderer(rd_footCenter))
#viewer.doc.addRenderer('rd_footCenterL', yr.PointsRenderer(rd_footCenterL))
#viewer.doc.addRenderer('rd_footCenterR', yr.PointsRenderer(rd_footCenterR))
viewer.doc.addRenderer('rd_CM_plane', yr.PointsRenderer(rd_CM_plane, (255,255,0)))
viewer.doc.addRenderer('rd_CP', yr.PointsRenderer(rd_CP, (0,255,0)))
#viewer.doc.addRenderer('rd_CP_des', yr.PointsRenderer(rd_CP_des, (255,0,255)))
# viewer.doc.addRenderer('rd_dL_des_plane', yr.VectorsRenderer(rd_dL_des_plane, rd_CM, (255,255,0)))
# viewer.doc.addRenderer('rd_dH_des', yr.VectorsRenderer(rd_dH_des, rd_CM, (0,255,0)))
viewer.doc.addRenderer('rd_grf_des', yr.ForcesRenderer(rd_grf_des, rd_CP_des, (0,255,255), .001))
viewer.doc.addRenderer('rd_exf_des', yr.ForcesRenderer(rd_exf_des, rd_root_des, (0,255,0), .009, 0.05))
#viewer.doc.addRenderer('rd_CMP', yr.PointsRenderer(rd_CMP, (0,0,255)))
viewer.doc.addRenderer('rd_DesPosL', yr.PointsRenderer(rd_DesPosL, (0,0,255)))
viewer.doc.addRenderer('rd_DesPosR', yr.PointsRenderer(rd_DesPosR, (0,100,255)))
#viewer.doc.addRenderer('softConstraint', yr.VectorsRenderer(rd_soft_const_vec, rd_CMP, (255,0,0), 3))
viewer.doc.addRenderer('rd_footCenter_ref', yr.PointsRenderer(rd_footCenter_ref))
viewer.doc.addRenderer('rd_CM_plane_ref', yr.PointsRenderer(rd_CM_plane_ref, (255,255,0)))
stage = 0
def simulateCallback(frame):
global g_initFlag
global preFootCenterL, preFootCenterR
global preFootOrientationL, preFootOrientationR
global forceShowFrame
global forceApplyFrame
global JsysPre
global JsupPreL
global JsupPreR
global JsupPre
global softConstPoint
global stage
motionModel.update(motion[frame])
Kt, Kk, Kl, Kh, Ksc, Bt, Bl, Bh, Bsc = viewer.GetParam()
if stage == 3:
Bsc = 0
#Kl *= 1.5
Dt = 2*(Kt**.5)
Dk = 2*(Kk**.5)
Dl = 2*(Kl**.5)
Dh = 2*(Kh**.5)
Dsc = 2*(Ksc**.5)
if Bsc == 0.0 :
viewer.doc.showRenderer('softConstraint', False)
viewer.motionViewWnd.update(1, viewer.doc)
else:
viewer.doc.showRenderer('softConstraint', True)
renderer1 = viewer.doc.getRenderer('softConstraint')
renderer1.rc.setLineWidth(0.1+Bsc*3)
viewer.motionViewWnd.update(1, viewer.doc)
# tracking
th_r = motion.getDOFPositions(frame)
th = controlModel.getDOFPositions()
dth_r = motion.getDOFVelocities(frame)
dth = controlModel.getDOFVelocities()
ddth_r = motion.getDOFAccelerations(frame)
ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt)
ddth_c = controlModel.getDOFAccelerations()
ype.flatten(ddth_des, ddth_des_flat)
ype.flatten(dth, dth_flat)
ype.flatten(ddth_c, ddth_c_flat)
# jacobian
footCenterL = controlModel.getBodyPositionGlobal(supL)
footCenterR = controlModel.getBodyPositionGlobal(supR)
refFootL = motionModel.getBodyPositionGlobal(supL)
refFootR = motionModel.getBodyPositionGlobal(supR)
footCenter = footCenterL + (footCenterR - footCenterL)/2.0
footCenter[1] = 0.
footCenter_ref = refFootL + (refFootR - refFootL)/2.0
footCenter_ref[1] = 0.
linkPositions = controlModel.getBodyPositionsGlobal()
linkVelocities = controlModel.getBodyVelocitiesGlobal()
linkAngVelocities = controlModel.getBodyAngVelocitiesGlobal()
linkInertias = controlModel.getBodyInertiasGlobal()
jointPositions = controlModel.getJointPositionsGlobal()
jointAxeses = controlModel.getDOFAxeses()
CM = yrp.getCM(linkPositions, linkMasses, totalMass)
dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)
CM_plane = copy.copy(CM); CM_plane[1]=0.
dCM_plane = copy.copy(dCM); dCM_plane[1]=0.
linkPositions_ref = motionModel.getBodyPositionsGlobal()
CM_plane_ref = yrp.getCM(linkPositions_ref, linkMasses, totalMass)
CM_plane_ref[1] = 0.
P = ymt.getPureInertiaMatrix(TO, linkMasses, linkPositions, CM, linkInertias)
dP = ymt.getPureInertiaMatrixDerivative(dTO, linkMasses, linkVelocities, dCM, linkAngVelocities, linkInertias)
yjc.computeJacobian2(Jsys, DOFs, jointPositions, jointAxeses, linkPositions, allLinkJointMasks)
dJsys = (Jsys - JsysPre)/(1/30.)
JsysPre = Jsys
#yjc.computeJacobianDerivative2(dJsys, DOFs, jointPositions, jointAxeses, linkAngVelocities, linkPositions, allLinkJointMasks)
if g_initFlag == 0:
preFootCenterL = footCenterL
preFootCenterR = footCenterR
preFootCenterL[1] -= 0.02
preFootCenterR[1] -= 0.02
preFootOrientationL = controlModel.getBodyOrientationGlobal(supL)
preFootOrientationR = controlModel.getBodyOrientationGlobal(supR)
softConstPoint = controlModel.getBodyPositionGlobal(constBody)
#softConstPoint[2] += 0.3
#softConstPoint[1] -= 1.1
#softConstPoint[0] += 0.1
softConstPoint[1] -= .3
#softConstPoint[0] -= .1
#softConstPoint[1] -= 1.
#softConstPoint[0] -= .5
g_initFlag = 1
yjc.computeJacobian2(JsupL, DOFs, jointPositions, jointAxeses, [footCenterL], supLJointMasks)
dJsupL = (JsupL - JsupPreL)/(1/30.)
JsupPreL = JsupL
#yjc.computeJacobianDerivative2(dJsupL, DOFs, jointPositions, jointAxeses, linkAngVelocities, [footCenterL], supLJointMasks, False)
yjc.computeJacobian2(JsupR, DOFs, jointPositions, jointAxeses, [footCenterR], supRJointMasks)
dJsupR = (JsupR - JsupPreR)/(1/30.)
JsupPreR = JsupR
#yjc.computeJacobianDerivative2(dJsupR, DOFs, jointPositions, jointAxeses, linkAngVelocities, [footCenterR], supRJointMasks, False)
preFootCenter = preFootCenterL + (preFootCenterR - preFootCenterL)/2.0
preFootCenter[1] = 0
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)
CP = yrp.getCP(contactPositions, contactForces)
# linear momentum
CM_ref_plane = footCenter
#CM_ref_plane = preFootCenter
dL_des_plane = Kl*totalMass*(CM_ref_plane - CM_plane) - Dl*totalMass*dCM_plane
#print("dL_des_plane ", dL_des_plane )
#dL_des_plane[1] = 0.
# angular momentum
CP_ref = footCenter
timeStep = 30.
if CP_old[0]==None or CP==None:
dCP = None
else:
dCP = (CP - CP_old[0])/(1/timeStep)
CP_old[0] = CP
if CP!=None and dCP!=None:
ddCP_des = Kh*(CP_ref - CP) - Dh*(dCP)
CP_des = CP + dCP*(1/timeStep) + .5*ddCP_des*((1/timeStep)**2)
dH_des = np.cross((CP_des - CM), (dL_des_plane + totalMass*mm.s2v(wcfg.gravity)))
#dH_des = np.cross((CP_des - CM_plane), (dL_des_plane + totalMass*mm.s2v(wcfg.gravity)))
#dH_des = [0, 0, 0]
else:
dH_des = None
CMP = yrp.getCMP(contactForces, CM)
r = [0,0,0]
if CP!= None and np.any(np.isnan(CMP))!=True :
r = CP - CMP
#print("r.l", mm.length(r))
#Bba = Bh*(mm.length(r))
Bba = Bh
# momentum matrix
RS = np.dot(P, Jsys)
R, S = np.vsplit(RS, 2)
rs = np.dot((np.dot(dP, Jsys) + np.dot(P, dJsys)), dth_flat)
r_bias, s_bias = np.hsplit(rs, 2)
##############################
# soft point constraint
'''
cmDiff = footCenter - CM_plane
print("cmDiff", cmDiff)
if stage == 3:
softConstPoint +=
'''
P_des = softConstPoint
P_cur = controlModel.getBodyPositionGlobal(constBody)
dP_des = [0, 0, 0]
dP_cur = controlModel.getBodyVelocityGlobal(constBody)
ddP_des1 = Ksc*(P_des - P_cur) - Dsc*(dP_cur - dP_des)
r = P_des - P_cur
I = np.vstack(([1,0,0],[0,1,0],[0,0,1]))
Z = np.hstack((I, mm.getCrossMatrixForm(-r)))
yjc.computeJacobian2(Jconst, DOFs, jointPositions, jointAxeses, [softConstPoint], constJointMasks)
JL, JA = np.vsplit(Jconst, 2)
Q1 = np.dot(Z, Jconst)
q1 = np.dot(JA, dth_flat)
q2 = np.dot(mm.getCrossMatrixForm(q1), np.dot(mm.getCrossMatrixForm(q1), r))
yjc.computeJacobianDerivative2(dJconst, DOFs, jointPositions, jointAxeses, linkAngVelocities, [softConstPoint], constJointMasks, False)
q_bias1 = np.dot(np.dot(Z, dJconst), dth_flat) + q2
'''
P_des = preFootCenterR
P_cur = controlModel.getBodyPositionGlobal(supR)
P_cur[1] = 0
dP_des = [0, 0, 0]
dP_cur = controlModel.getBodyVelocityGlobal(supR)
ddP_des2 = Kp*(P_des - P_cur) - Dp*(dP_cur - dP_des)
r = P_des - P_cur
#print("r2", r)
I = np.vstack(([1,0,0],[0,1,0],[0,0,1]))
Z = np.hstack((I, mm.getCrossMatrixForm(-r)))
JL, JA = np.vsplit(JsupR, 2)
Q2 = np.dot(Z, JsupR)
q1 = np.dot(JA, dth_flat)
q2 = np.dot(mm.getCrossMatrixForm(q1), np.dot(mm.getCrossMatrixForm(q1), r))
q_bias2 = np.dot(np.dot(Z, dJsupR), dth_flat) + q2
'''
#print("Q1", Q1)
'''
print("ddP_des1", ddP_des1)
q_ddth1 = np.dot(Q1, ddth_c_flat)
print("q_ddth1", q_ddth1)
print("q_bias1", q_bias1)
ddp1 = q_ddth1+q_bias1
print("ddp1", ddp1)
print("diff1", ddP_des1-ddp1)
'''
'''
print("ddP_des2", ddP_des2)
q_ddth2 = np.dot(Q2, ddth_c_flat)
print("q_ddth2", q_ddth2)
print("q_bias2", q_bias2)
ddp2 = q_ddth2+q_bias2
print("ddp2", ddp2)
print("diff2", ddP_des2-ddp2)
'''
##############################
############################
# IK
'''
P_des = preFootCenterL
P_cur = controlModel.getJointPositionGlobal(supL)
r = P_des - P_cur
Q_des = preFootOrientationL
Q_cur = controlModel.getJointOrientationGlobal(supL)
rv = mm.logSO3(np.dot(Q_cur.transpose(), Q_des))
#print("rv", rv)
des_v_sup = (r[0],r[1],r[2], rv[0], rv[1], rv[2])
A_large = np.dot(JsupL.T, JsupL)
b_large = np.dot(JsupL.T, des_v_sup)
des_d_th = npl.lstsq(A_large, b_large)
ype.nested(des_d_th[0], d_th_IK_L)
P_des2 = preFootCenterR
P_cur2 = controlModel.getJointPositionGlobal(supR)
r2 = P_des2 - P_cur2
Q_des2 = preFootOrientationR
Q_cur2 = controlModel.getJointOrientationGlobal(supR)
rv2 = mm.logSO3(np.dot(Q_cur2.transpose(), Q_des2))
#print("Q_des2", Q_des2)
#print("Q_cur2", Q_cur2)
#print("rv2", rv2)
des_v_sup2 = (r2[0],r2[1],r2[2], rv2[0], rv2[1], rv[2])
A_large = np.dot(JsupR.T, JsupR)
b_large = np.dot(JsupR.T, des_v_sup2)
des_d_th = npl.lstsq(A_large, b_large)
ype.nested(des_d_th[0], d_th_IK_R)
for i in range(len(d_th_IK_L)):
for j in range(len(d_th_IK_L[i])):
d_th_IK[i][j] = d_th_IK_L[i][j] + d_th_IK_R[i][j]
th_IK = yct.getIntegralDOF(th, d_th_IK, 1/timeStep)
dd_th_IK = yct.getDesiredDOFAccelerations(th_IK, th, d_th_IK, dth, ddth_r, Kk, Dk)
ype.flatten(d_th_IK, d_th_IK_flat)
ype.flatten(dd_th_IK, dd_th_IK_flat)
'''
############################
flagContact = True
if dH_des==None or np.any(np.isnan(dH_des)) == True:
flagContact = False
'''
0 : initial
1 : contact
2 : fly
3 : landing
'''
if flagContact == False :
if stage == 1:
stage = 2
print("fly")
else:
if stage == 0:
stage = 1
print("contact")
elif stage == 2:
stage = 3
print("landing")
if stage == 3:
Bt = Bt*0.8
Bl = Bl*1
# optimization
mot.addTrackingTerms(problem, totalDOF, Bt, w, ddth_des_flat)
#mot.addTrackingTerms(problem, totalDOF, Bk, w_IK, dd_th_IK_flat)
mot.addSoftPointConstraintTerms(problem, totalDOF, Bsc, ddP_des1, Q1, q_bias1)
#mot.addSoftPointConstraintTerms(problem, totalDOF, Bp, ddP_des2, Q2, q_bias2)
#mot.addConstraint(problem, totalDOF, JsupL, dJsupL, dth_flat, a_sup)
#mot.addConstraint(problem, totalDOF, JsupR, dJsupR, dth_flat, a_sup2)
desLinearAccL = [0,0,0]
desAngularAccL = [0,0,0]
desLinearAccR = [0,0,0]
desAngularAccR = [0,0,0]
refPos = motionModel.getBodyPositionGlobal(supL)
refPos[0] += ModelOffset[0]
refPos[1] = 0
refVel = motionModel.getBodyVelocityGlobal(supL)
curPos = controlModel.getBodyPositionGlobal(supL)
#curPos[1] = 0
curVel = controlModel.getBodyVelocityGlobal(supL)
refAcc = (0,0,0)
if stage == 3:
refPos = curPos
refPos[1] = 0
if curPos[1] < 0.0:
curPos[1] = 0
else :
curPos[1] = 0
rd_DesPosL[0] = refPos
#(p_r, p, v_r, v, a_r, Kt, Dt)
desLinearAccL = yct.getDesiredAcceleration(refPos, curPos, refVel, curVel, refAcc, Kk, Dk)
#desLinearAccL[1] = 0
refPos = motionModel.getBodyPositionGlobal(supR)
refPos[0] += ModelOffset[0]
refPos[1] = 0
refVel = motionModel.getBodyVelocityGlobal(supR)
curPos = controlModel.getBodyPositionGlobal(supR)
#curPos[1] = 0
curVel = controlModel.getBodyVelocityGlobal(supR)
if stage == 3:
refPos = curPos
refPos[1] = 0
if curPos[1] < 0.0:
curPos[1] = 0
else :
curPos[1] = 0
rd_DesPosR[0] = refPos
desLinearAccR = yct.getDesiredAcceleration(refPos, curPos, refVel, curVel, refAcc, Kk, Dk)
#desLinearAccR[1] = 0
#(th_r, th, dth_r, dth, ddth_r, Kt, Dt)
refAng = [preFootOrientationL]
curAng = [controlModel.getBodyOrientationGlobal(supL)]
refAngVel = motionModel.getBodyAngVelocityGlobal(supL)
curAngVel = controlModel.getBodyAngVelocityGlobal(supL)
refAngAcc = (0,0,0)
#desAngularAccL = yct.getDesiredAngAccelerations(refAng, curAng, refAngVel, curAngVel, refAngAcc, Kk, Dk)
curAngY = np.dot(curAng, np.array([0,1,0]))
aL = mm.logSO3(mm.getSO3FromVectors(curAngY[0], np.array([0,1,0])))
print("curAngYL=",curAngY, "aL=", aL)
desAngularAccL = [Kk*aL + Dk*(refAngVel-curAngVel)]
refAng = [preFootOrientationR]
curAng = [controlModel.getBodyOrientationGlobal(supR)]
refAngVel = motionModel.getBodyAngVelocityGlobal(supR)
curAngVel = controlModel.getBodyAngVelocityGlobal(supR)
refAngAcc = (0,0,0)
#desAngularAccR = yct.getDesiredAngAccelerations(refAng, curAng, refAngVel, curAngVel, refAngAcc, Kk, Dk)
curAngY = np.dot(curAng, np.array([0,1,0]))
aL = mm.logSO3(mm.getSO3FromVectors(curAngY[0], np.array([0,1,0])))
desAngularAccR = [Kk*aL + Dk*(refAngVel-curAngVel)]
print("curAngYR=",curAngY, "aL=", aL)
a_sup_2 = [desLinearAccL[0], desLinearAccL[1], desLinearAccL[2], desAngularAccL[0][0], desAngularAccL[0][1], desAngularAccL[0][2],
desLinearAccR[0], desLinearAccR[1], desLinearAccR[2], desAngularAccR[0][0], desAngularAccR[0][1], desAngularAccR[0][2]]
if stage == 2 :#or stage == 3:
refAccL = motionModel.getBodyAccelerationGlobal(supL)
refAndAccL = motionModel.getBodyAngAccelerationGlobal(supL)
refAccR = motionModel.getBodyAccelerationGlobal(supR)
refAndAccR = motionModel.getBodyAngAccelerationGlobal(supR)
a_sup_2 = [refAccL[0], refAccL[1], refAccL[2], refAndAccL[0], refAndAccL[1], refAndAccL[2],
refAccR[0], refAccR[1], refAccR[2], refAndAccR[0], refAndAccR[1], refAndAccR[2]]
'''
a_sup_2 = [0,0,0, desAngularAccL[0][0], desAngularAccL[0][1], desAngularAccL[0][2],
0,0,0, desAngularAccR[0][0], desAngularAccR[0][1], desAngularAccR[0][2]]
'''
Jsup_2 = np.vstack((JsupL, JsupR))
dJsup_2 = np.vstack((dJsupL, dJsupR))
if flagContact == True:
mot.addLinearTerms(problem, totalDOF, Bl, dL_des_plane, R, r_bias)
mot.addAngularTerms(problem, totalDOF, Bh, dH_des, S, s_bias)
mot.setConstraint(problem, totalDOF, Jsup_2, dJsup_2, dth_flat, a_sup_2)
#mot.setConstraint(problem, totalDOF, JsupR, dJsupR, dth_flat, a_sup2)
#mot.setConstraint(problem, totalDOF, Jsup_2, dJsup_2, dth_flat, a_sup_2)
#mot.addConstraint(problem, totalDOF, Jsup_2, dJsup_2, d_th_IK_flat, a_sup_2)
'''
jZ = np.dot(dJsup_2.T, dJsup_2)
lamda = 0.001
for i in range(len(jZ)):
for j in range(len(jZ[0])):
if i == j :
jZ[i][j] += lamda
jZInv = npl.pinv(jZ)
jA = np.dot(Jsup_2, np.dot(jZInv, np.dot(dJsup_2.T, -Jsup_2)))
mot.addConstraint2(problem, totalDOF, jA, a_sup_2)
'''
r = problem.solve()
problem.clear()
ype.nested(r['x'], ddth_sol)
rootPos[0] = controlModel.getBodyPositionGlobal(selectedBody)
localPos = [[0, 0, 0]]
for i in range(stepsPerFrame):
# apply penalty force
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)
vpWorld.applyPenaltyForce(bodyIDs, contactPositionLocals, contactForces)
controlModel.setDOFAccelerations(ddth_sol)
controlModel.solveHybridDynamics()
extraForce[0] = viewer.GetForce()
if (extraForce[0][0] != 0 or extraForce[0][1] != 0 or extraForce[0][2] != 0) :
forceApplyFrame += 1
vpWorld.applyPenaltyForce(selectedBodyId, localPos, extraForce)
applyedExtraForce[0] = extraForce[0]
if forceApplyFrame*wcfg.timeStep > 0.1:
viewer.ResetForce()
forceApplyFrame = 0
vpWorld.step()
# rendering
rd_footCenter[0] = footCenter
rd_footCenterL[0] = preFootCenterL
rd_footCenterR[0] = preFootCenterR
rd_CM[0] = CM
rd_CM_plane[0] = CM_plane.copy()
rd_footCenter_ref[0] = footCenter_ref
rd_CM_plane_ref[0] = CM_plane_ref.copy()
#rd_CM_plane[0][1] = 0.
if CP!=None and dCP!=None:
rd_CP[0] = CP
rd_CP_des[0] = CP_des
rd_dL_des_plane[0] = dL_des_plane
rd_dH_des[0] = dH_des
rd_grf_des[0] = dL_des_plane - totalMass*mm.s2v(wcfg.gravity)
rd_exf_des[0] = applyedExtraForce[0]
#print("rd_exf_des", rd_exf_des[0])
rd_root_des[0] = rootPos[0]
rd_CMP[0] = softConstPoint
rd_soft_const_vec[0] = controlModel.getBodyPositionGlobal(constBody)-softConstPoint
#if (applyedExtraForce[0][0] != 0 or applyedExtraForce[0][1] != 0 or applyedExtraForce[0][2] != 0) :
if (forceApplyFrame == 0) :
applyedExtraForce[0] = [0, 0, 0]
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/60.)
viewer.show()
Fl.run()
def test_replaceBvhFile():
# motion
bvhFilePath = '../samples/wd2_WalkSameSame00.bvh'
bvh = readBvhFileAsBvh(bvhFilePath)
motion = bvh.toJointMotion(.01, False)
partBvhFilePath = '../samples/simpleJump_long.bvh'
partBvh = readBvhFileAsBvh(partBvhFilePath)
bvh.replaceJointFromBvh('RightFoot', partBvh)
partBvh = readBvhFileAsBvh(partBvhFilePath)
partBvh.mirror('YZ')
bvh.replaceJointFromBvh('LeftFoot', partBvh)
motion2 = bvh.toJointMotion(.01, False)
def buildMassMap():
massMap = {}
massMap = massMap.fromkeys([
'Head',
'Head_Effector',
'Hips',
'LeftArm',
'LeftFoot',
'LeftForeArm',
'LeftHand',
'LeftHand_Effector',
'LeftLeg',
'LeftShoulder1',
'LeftUpLeg',
'RightArm',
'RightFoot',
'RightForeArm',
'RightHand',
'RightHand_Effector',
'RightLeg',
'RightShoulder',
'RightUpLeg',
'Spine',
'Spine1',
'RightFoot_foot_0_0',
'RightFoot_foot_0_1',
'RightFoot_foot_0_1_Effector',
'RightFoot_foot_1_0',
'RightFoot_foot_1_1',
'RightFoot_foot_1_1_Effector',
'RightFoot_foot_2_0',
'RightFoot_foot_2_1',
'RightFoot_foot_2_1_Effector',
'LeftFoot_foot_0_0',
'LeftFoot_foot_0_1',
'LeftFoot_foot_0_1_Effector',
'LeftFoot_foot_1_0',
'LeftFoot_foot_1_1',
'LeftFoot_foot_1_1_Effector',
'LeftFoot_foot_2_0',
'LeftFoot_foot_2_1',
'LeftFoot_foot_2_1_Effector',
], 0.)
# torso : 10
massMap['Hips'] += 2.
massMap['Spine'] += 8.
# head : 3
massMap['Spine1'] += 3.
# right upper arm : 2
massMap['RightArm'] += 2.
# left upper arm : 2
massMap['LeftArm'] += 2.
# right lower arm : 1
massMap['RightForeArm'] = 1.
# massMap['RightForeArm'] = 2.
# left lower arm : 1
massMap['LeftForeArm'] = 1.
# massMap['LeftForeArm'] = 2.
# right thigh : 7
massMap['Hips'] += 2.
massMap['RightUpLeg'] += 5.
# left thigh : 7
massMap['Hips'] += 2.
massMap['LeftUpLeg'] += 5.
# right shin : 5
massMap['RightLeg'] += 5.
# left shin : 5
massMap['LeftLeg'] += 5.
# right foot : 4
massMap['RightFoot'] += 2.
# left foot : 4
massMap['LeftFoot'] += 2.
massMap['RightFoot_foot_0_0'] = .3
massMap['RightFoot_foot_0_1'] = .3
massMap['RightFoot_foot_1_0'] = .3
massMap['RightFoot_foot_1_1'] = .3
massMap['RightFoot_foot_2_0'] = .3
massMap['RightFoot_foot_2_1'] = .3
massMap['LeftFoot_foot_0_0'] = .3
massMap['LeftFoot_foot_0_1'] = .3
massMap['LeftFoot_foot_1_0'] = .3
massMap['LeftFoot_foot_1_1'] = .3
massMap['LeftFoot_foot_2_0'] = .3
massMap['LeftFoot_foot_2_1'] = .3
return massMap
def buildMcfg():
massMap = buildMassMap()
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .9
totalMass = 0.
for name in massMap:
node = mcfg.addNode(name)
node.mass = massMap[name]
totalMass += node.mass
node = mcfg.getNode('Hips')
node.length = .2
node.width = .25
node = mcfg.getNode('Spine1')
node.length = .2
node.offset = (0, 0, 0.1)
node = mcfg.getNode('Spine')
node.width = .22
node = mcfg.getNode('RightFoot')
node.length = .25
# node.length = .27
# node.offset = (0,0,0.01)
node.width = .1
node.geom = 'MyFoot1'
node = mcfg.getNode('LeftFoot')
node.length = .25
# node.length = .27
# node.offset = (0,0,0.01)
node.width = .1
node.geom = 'MyFoot1'
def capsulize(node_name):
node = mcfg.getNode(node_name)
node.geom = 'MyFoot4'
node.width = 0.02
capsulize('RightFoot')
capsulize('LeftFoot')
capsulize('RightFoot_foot_0_0')
capsulize('RightFoot_foot_0_1')
capsulize('RightFoot_foot_1_0')
capsulize('RightFoot_foot_1_1')
capsulize('RightFoot_foot_2_0')
capsulize('RightFoot_foot_2_1')
capsulize('LeftFoot_foot_0_0')
capsulize('LeftFoot_foot_0_1')
capsulize('LeftFoot_foot_1_0')
capsulize('LeftFoot_foot_1_1')
capsulize('LeftFoot_foot_2_0')
capsulize('LeftFoot_foot_2_1')
return mcfg
mcfg = buildMcfg()
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
wcfg.useDefaultContactModel = False
wcfg.lockingVel = 0.05
stepsPerFrame = 30
wcfg.timeStep = 0.001
print(motion2[0].skeleton)
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion2[0], mcfg)
# vpWorld.initialize()
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer('motion',
yr.JointMotionRenderer(motion, (0, 255, 0)))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('motion2',
yr.JointMotionRenderer(motion2, (255, 0, 0)))
viewer.doc.addObject('motion2', motion2)
viewer.doc.addRenderer(
'csmotion2',
cvr.VpModelRenderer(motionModel, (255, 0, 0), yr.POLYGON_FILL))
viewer.startTimer(1 / motion.fps)
def callback(frame):
motionModel.update(motion2[frame])
viewer.setSimulateCallback(callback)
viewer.show()
Fl.run()
tempFilePath = '../samples/motion_foot_temp_wd2_WalkSameSame00.bvh.temp'
import Renderer.ysRenderer as yr
import Renderer.csVpRenderer as cvr
import Simulator.csVpWorld as cvw
import Simulator.csVpModel as cvm
import GUI.ysSimpleViewer as ysv
import Optimization.ysAnalyticConstrainedOpt as yac
import ArticulatedBody.ysJacobian as yjc
import Util.ysPythonEx as ype
import ArticulatedBody.ysReferencePoints as yrp
import ArticulatedBody.ysMomentum as ymt
import ArticulatedBody.ysControl as yct
import GUI.ysMultiViewer as ymv
import Motion.ysHierarchyEdit as yme
import Simulator.ysPhysConfig as ypc
import numpy.linalg as npl
import mtOptimize as mot
import mtInitialize_Simple as mit
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
mcfg_motion = mit.normal_mcfg()
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
motionModel.recordVelByFiniteDiff()
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
def test_biped_motion_edit():
massMap = buildMassMap()
bvhFilePath = '../samples/wd2_WalkSameSame00.bvh'
motion = yf.readBvhFile(bvhFilePath, .01)
yme.removeJoint(motion, 'Head', False)
yme.removeJoint(motion, 'RightShoulder', False)
yme.removeJoint(motion, 'LeftShoulder1', False)
yme.removeJoint(motion, 'RightToes_Effector', False)
yme.removeJoint(motion, 'LeftToes_Effector', False)
yme.removeJoint(motion, 'RightHand_Effector', False)
yme.removeJoint(motion, 'LeftHand_Effector', False)
yme.offsetJointLocal(motion, 'RightArm', (.03,-.05,0), False)
yme.offsetJointLocal(motion, 'LeftArm', (-.03,-.05,0), False)
yme.updateGlobalT(motion)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .9
for name in massMap:
node = mcfg.addNode(name)
node.mass = massMap[name]
node = mcfg.getNode('Hips')
node.length = .2
node.width = .25
# node = mcfg.getNode('Head')
# node.length = .2
node = mcfg.getNode('Spine1')
node.length = .2
node.offset = (0,0,0.1)
node = mcfg.getNode('Spine')
node.width = .22
node = mcfg.getNode('RightFoot')
node.length = .25
node = mcfg.getNode('LeftFoot')
node.length = .25
wcfg = ypc.WorldConfig()
wcfg.planeHeight = 0.
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
print motion[0].skeleton
print
print controlModel
viewer = ysv.SimpleViewer()
# viewer.record(False)
viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,255,255), yr.LINK_LINE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(controlModel, (255,240,255), cvr.POLYGON_FILL))
viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(motionModel, (255,240,255), cvr.POLYGON_LINE))
def preFrameCallback(frame):
motionModel.update(motion[frame])
viewer.setPreFrameCallback(preFrameCallback)
def simulateCallback(frame):
for i in range(stepsPerFrame):
vpWorld.step()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()
def main():
np.set_printoptions(precision=4, linewidth=200)
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_5()
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
motionModel.recordVelByFiniteDiff()
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
elasticity = 20000
damping = 2*(elasticity**.5)
springBody1 = 1
springBody2 = 2
springBody1Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]))
springBody2Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]))
initialDist = mm.length(springBody1Pos - springBody2Pos)*1.
node = mcfg.getNode(mit.RIGHT_METATARSAL_1)
initialDist -= node.width#0.084
v1 = (-node.width*0.5,0.0,node.length*0.4)
v2 = (node.width*0.5,0.0,node.length*0.4)
controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]), elasticity, damping, v2, v1, initialDist)
controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootRPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootRPart'][springBody2]), elasticity, damping, v1, v2, initialDist)
v1 = (-node.width*0.5,0.0,-node.length*0.4)
v2 = (node.width*0.5,0.02,-node.length*0.4)
controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]), elasticity, damping, v2, v1, initialDist)
controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootRPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootRPart'][springBody2]), elasticity, damping, v1, v2, initialDist)
elasticity2 = 10000
damping2 = 2*(elasticity**.5)
springBody3 = 5
springBody4 = 6
springBody3Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody3]))
springBody4Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody4]))
initialDist2 = mm.length(springBody3Pos - springBody4Pos)*1.
node2 = mcfg.getNode(mit.RIGHT_CALCANEUS_1)
initialDist2 -= node2.width
v3 = (-node2.width*0.5,0.0,-node2.length*0.4)
v4 = (node2.width*0.5,0.0,-node2.length*0.4)
controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody3]), motion[0].skeleton.getJointIndex(config['FootLPart'][springBody4]), elasticity2, damping2, v4, v3, initialDist2)
controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootRPart'][springBody3]), motion[0].skeleton.getJointIndex(config['FootRPart'][springBody4]), elasticity2, damping2, v3, v4, initialDist2)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
#ModelOffset = (1.5, -0.01, 0)
ModelOffset = (1.5, 0.1, 0)
controlModel.translateByOffset(ModelOffset)
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
# parameter
Kt = config['Kt']; Dt = config['Dt'] # tracking gain
Kl = config['Kl']; Dl = config['Dl'] # linear balance gain
Kh = config['Kh']; Dh = config['Dh'] # angular balance gain
Ks = config['Ks']; Ds = config['Ds'] # penalty force spring gain
Bt = config['Bt']
Bl = config['Bl']
Bh = config['Bh']
w = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap'])
w2 = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap2'])
#w_IK = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['IKweightMap'])
supL = motion[0].skeleton.getJointIndex(config['supLink'])
supR = motion[0].skeleton.getJointIndex(config['supLink2'])
rootB = motion[0].skeleton.getJointIndex(config['root'])
selectedBody = motion[0].skeleton.getJointIndex(config['end'])
#constBody = motion[0].skeleton.getJointIndex('LeftForeArm')
constBody = motion[0].skeleton.getJointIndex(config['const'])
# jacobian
Jsup = yjc.makeEmptyJacobian(DOFs, 1)
dJsup = Jsup.copy()
JsupPre = Jsup.copy()
Jsys = yjc.makeEmptyJacobian(DOFs, controlModel.getBodyNum())
dJsys = Jsys.copy()
JsysPre = Jsys.copy()
Jconst = yjc.makeEmptyJacobian(DOFs, 1)
dJconst = Jconst.copy()
###############
footPartNum = config['FootPartNum']
indexFootL = [None]*footPartNum
indexFootR = [None]*footPartNum
jFootL = [None]*footPartNum
dJFootL = [None]*footPartNum
jFootR = [None]*footPartNum
dJFootR = [None]*footPartNum
jointMasksFootL = [None]*footPartNum
jointMasksFootR = [None]*footPartNum
jAngFootL = [None]*footPartNum
dJAngFootL = [None]*footPartNum
jAngFootR = [None]*footPartNum
dJAngFootR = [None]*footPartNum
for i in range(footPartNum) :
jFootL[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootL[i] = jFootL[i].copy()
jFootR[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootR[i] = jFootR[i].copy()
jAngFootL[i] = yjc.makeEmptyJacobian(DOFs, 1, False)
dJAngFootL[i] = jAngFootL[i].copy()
jAngFootR[i] = yjc.makeEmptyJacobian(DOFs, 1, False)
dJAngFootR[i] = jAngFootR[i].copy()
indexFootL[i] = motion[0].skeleton.getJointIndex(config['FootLPart'][i])
indexFootR[i] = motion[0].skeleton.getJointIndex(config['FootRPart'][i])
jointMasksFootL[i] = [yjc.getLinkJointMask(motion[0].skeleton, indexFootL[i])]
jointMasksFootR[i] = [yjc.getLinkJointMask(motion[0].skeleton, indexFootR[i])]
constJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [indexFootL[1], indexFootR[1]])]
#constJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [indexFootL[0]])]
#constJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, constBody)]
allLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)
'''
maskArray = [foreSupLJointMasks, foreSupRJointMasks, rearSupLJointMasks, rearSupRJointMasks]
parentArray = [supL, supR, supL, supR]
effectorArray = [foreSupL, foreSupR, rearSupL, rearSupR]
for j in range(4) :
for i in range(len(foreSupLJointMasks)) :
if i == parentArray[j] or i == effectorArray[j] :
maskArray[j][0][i] = 1
else :
maskArray[j][0][i] = 0
'''
# momentum matrix
linkMasses = controlModel.getBodyMasses()
totalMass = controlModel.getTotalMass()
TO = ymt.make_TO(linkMasses)
dTO = ymt.make_dTO(len(linkMasses))
# optimization
problem = yac.LSE(totalDOF, 6)
a_sup = (0,0,0, 0,0,0) #L
#a_sup2 = (0,0,0, 0,0,0)#R
a_sup2 = [0,0,0, 0,0,0]#R
a_sup_2 = [0,0,0, 0,0,0, 0,0,0, 0,0,0]
CP_old = [mm.v3(0.,0.,0.)]
# penalty method
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.]*len(bodyIDsToCheck)
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
d_th_IK = ype.makeNestedList(DOFs)
d_th_IK_L = ype.makeNestedList(DOFs)
d_th_IK_R = ype.makeNestedList(DOFs)
dd_th_IK = ype.makeNestedList(DOFs)
dd_th_IK_flat = ype.makeFlatList(totalDOF)
d_th_IK_flat = ype.makeFlatList(totalDOF)
ddth_c_flat = ype.makeFlatList(totalDOF)
# viewer
rd_footCenter = [None]
rd_footCenter_ref = [None]
rd_footCenterL = [None]
rd_footCenterR = [None]
rd_CM_plane = [None]
rd_CM_plane_ref = [None]
rd_CM_ref = [None]
rd_CM = [None]
rd_CM_vec = [None]
rd_CM_ref_vec = [None]
rd_CP = [None]
rd_CP_des = [None]
rd_dL_des_plane = [None]
rd_dH_des = [None]
rd_grf_des = [None]
rd_footCenter_des = [None]
rd_exf_des = [None]
rd_root_des = [None]
rd_soft_const_vec = [None]
rd_root = [None]
rd_footL_vec = [None]
rd_footR_vec = [None]
rd_CMP = [None]
rd_DesPosL = [None]
rd_DesPosR = [None]
rd_DesForePosL = [None]
rd_DesForePosR = [None]
rd_DesRearPosL = [None]
rd_DesRearPosR = [None]
rd_Joint = [None]
rd_Joint2 = [None]
rd_Joint3 = [None]
rd_Joint4 = [None]
rd_contactForces = [None]*1000
rd_contactPositions = [None]*1000
rootPos = [None]
selectedBodyId = [selectedBody]
extraForce = [None]
applyedExtraForce = [None]
applyedExtraForce[0] = [0,0,0]
normalVector = [[0,2,0]]
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,255,255), yr.LINK_BONE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(motionModel, (150,150,255), yr.POLYGON_FILL))
viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_FILL))
viewer.doc.addRenderer('rd_footCenter', yr.PointsRenderer(rd_footCenter))
viewer.doc.addRenderer('rd_footCenter_des', yr.PointsRenderer(rd_footCenter_des, (150,0,150)) )
#viewer.doc.addRenderer('rd_footCenterL', yr.PointsRenderer(rd_footCenterL))
#viewer.doc.addRenderer('rd_footCenterR', yr.PointsRenderer(rd_footCenterR))
#viewer.doc.addRenderer('rd_CM_plane', yr.PointsRenderer(rd_CM_plane, (255,255,0)))
viewer.doc.addRenderer('rd_CM', yr.PointsRenderer(rd_CM_plane, (255,255,0)))
#viewer.doc.addRenderer('rd_CP_des', yr.PointsRenderer(rd_CP_des, (0,255,0)))
#viewer.doc.addRenderer('rd_CP_des', yr.PointsRenderer(rd_CP_des, (255,0,255)))
# viewer.doc.addRenderer('rd_dL_des_plane', yr.VectorsRenderer(rd_dL_des_plane, rd_CM, (255,255,0)))
# viewer.doc.addRenderer('rd_dH_des', yr.VectorsRenderer(rd_dH_des, rd_CM, (0,255,0)))
viewer.doc.addRenderer('rd_grf_des', yr.ForcesRenderer(rd_grf_des, rd_CP, (0,255,255), .001))
viewer.doc.addRenderer('rd_exf_des', yr.ForcesRenderer(rd_exf_des, rd_root_des, (0,255,0), .009, 0.05))
viewer.doc.addRenderer('rd_CMP', yr.PointsRenderer(rd_CMP, (0,0,255)))
viewer.doc.addRenderer('rd_DesPosL', yr.PointsRenderer(rd_DesPosL, (0,0,255)))
viewer.doc.addRenderer('rd_DesPosR', yr.PointsRenderer(rd_DesPosR, (0,100,255)))
#viewer.doc.addRenderer('rd_DesForePosL', yr.PointsRenderer(rd_DesForePosL, (150,0,200)))
#viewer.doc.addRenderer('rd_DesForePosR', yr.PointsRenderer(rd_DesForePosR, (150,0,250)))
#viewer.doc.addRenderer('rd_DesRearPosL', yr.PointsRenderer(rd_DesRearPosL, (0,150,200)))
#viewer.doc.addRenderer('rd_DesRearPosR', yr.PointsRenderer(rd_DesRearPosR, (0,150,250)))
viewer.doc.addRenderer('softConstraint', yr.VectorsRenderer(rd_soft_const_vec, rd_CMP, (150,100,100), 3))
viewer.doc.addRenderer('rd_footLVec', yr.VectorsRenderer(rd_footL_vec, rd_footCenterL, (255,0,0), 3))
viewer.doc.addRenderer('rd_footRVec', yr.VectorsRenderer(rd_footR_vec, rd_footCenterR, (255,255,0), 3))
#viewer.doc.addRenderer('rd_footCenter_ref', yr.PointsRenderer(rd_footCenter_ref))
#viewer.doc.addRenderer('rd_CM_plane_ref', yr.PointsRenderer(rd_CM_plane_ref, (255,255,0)))
viewer.doc.addRenderer('rd_refNormalVec', yr.VectorsRenderer(normalVector, rd_footCenter_ref, (255,0,0), 3))
viewer.doc.addRenderer('rd_refCMVec', yr.VectorsRenderer(rd_CM_ref_vec, rd_footCenter_ref, (255,0,255), 3))
viewer.doc.addRenderer('rd_curNormalVec', yr.VectorsRenderer(normalVector, rd_footCenter, (255,0,0), 3))
viewer.doc.addRenderer('rd_CMVec', yr.VectorsRenderer(rd_CM_vec, rd_footCenter, (255,0,255), 3))
#viewer.doc.addRenderer('rd_contactForces', yr.ForcesRenderer(rd_contactForces, rd_contactPositions, (0,255,0), .009, 0.009))
viewer.doc.addRenderer('rd_Joint', yr.PointsRenderer(rd_Joint, (255,0,0)))
viewer.doc.addRenderer('rd_Joint2', yr.PointsRenderer(rd_Joint2, (0,255,0)))
viewer.doc.addRenderer('rd_Joint3', yr.PointsRenderer(rd_Joint3, (0,0,255)))
viewer.doc.addRenderer('rd_Joint4', yr.PointsRenderer(rd_Joint4, (255,255,0)))
stage = STATIC_BALANCING
contactRendererName = []
for i in range (motion[0].skeleton.getJointNum()):
print(i, motion[0].skeleton.getJointName(i))
def simulateCallback(frame):
global g_initFlag
global forceShowFrame
global forceApplyFrame
global JsysPre
global JsupPreL
global JsupPreR
global JsupPre
global softConstPoint
global stage
global contactRendererName
motionModel.update(motion[frame])
Kt, Kk, Kl, Kh, Ksc, Bt, Bl, Bh, Bsc = viewer.GetParam()
Dt = 2*(Kt**.5)
Dk = 2*(Kk**.5)
Dl = 2*(Kl**.5)
Dh = 2*(Kh**.5)
Dsc = 2*(Ksc**.5)
if Bsc == 0.0 :
viewer.doc.showRenderer('softConstraint', False)
viewer.motionViewWnd.update(1, viewer.doc)
else:
viewer.doc.showRenderer('softConstraint', True)
renderer1 = viewer.doc.getRenderer('softConstraint')
renderer1.rc.setLineWidth(0.1+Bsc*3)
viewer.motionViewWnd.update(1, viewer.doc)
# tracking
th_r = motion.getDOFPositions(frame)
th = controlModel.getDOFPositions()
dth_r = motion.getDOFVelocities(frame)
dth = controlModel.getDOFVelocities()
ddth_r = motion.getDOFAccelerations(frame)
ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt)
ddth_c = controlModel.getDOFAccelerations()
ype.flatten(ddth_des, ddth_des_flat)
ype.flatten(dth, dth_flat)
ype.flatten(ddth_c, ddth_c_flat)
# jacobian
refFootL = motionModel.getBodyPositionGlobal(supL)
refFootR = motionModel.getBodyPositionGlobal(supR)
positionFootL = [None]*footPartNum
positionFootR = [None]*footPartNum
for i in range(footPartNum):
positionFootL[i] = controlModel.getBodyPositionGlobal(indexFootL[i])
positionFootR[i] = controlModel.getBodyPositionGlobal(indexFootR[i])
linkPositions = controlModel.getBodyPositionsGlobal()
linkVelocities = controlModel.getBodyVelocitiesGlobal()
linkAngVelocities = controlModel.getBodyAngVelocitiesGlobal()
linkInertias = controlModel.getBodyInertiasGlobal()
jointPositions = controlModel.getJointPositionsGlobal()
jointAxeses = controlModel.getDOFAxeses()
CM = yrp.getCM(linkPositions, linkMasses, totalMass)
dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)
CM_plane = copy.copy(CM); CM_plane[1]=0.
dCM_plane = copy.copy(dCM); dCM_plane[1]=0.
linkPositions_ref = motionModel.getBodyPositionsGlobal()
CM_ref = yrp.getCM(linkPositions_ref, linkMasses, totalMass)
CM_plane_ref = copy.copy(CM_ref)
CM_plane_ref[1] = 0.
P = ymt.getPureInertiaMatrix(TO, linkMasses, linkPositions, CM, linkInertias)
dP = ymt.getPureInertiaMatrixDerivative(dTO, linkMasses, linkVelocities, dCM, linkAngVelocities, linkInertias)
yjc.computeJacobian2(Jsys, DOFs, jointPositions, jointAxeses, linkPositions, allLinkJointMasks)
yjc.computeJacobianDerivative2(dJsys, DOFs, jointPositions, jointAxeses, linkAngVelocities, linkPositions, allLinkJointMasks)
yjc.computeJacobian2(jFootL[0], DOFs, jointPositions, jointAxeses, [positionFootL[0]], jointMasksFootL[0])
yjc.computeJacobianDerivative2(dJFootL[0], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootL[0]], jointMasksFootL[0], False)
yjc.computeJacobian2(jFootR[0], DOFs, jointPositions, jointAxeses, [positionFootR[0]], jointMasksFootR[0])
yjc.computeJacobianDerivative2(dJFootR[0], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootR[0]], jointMasksFootR[0], False)
yjc.computeAngJacobian2(jAngFootL[0], DOFs, jointPositions, jointAxeses, [positionFootL[0]], jointMasksFootL[0])
yjc.computeAngJacobianDerivative2(dJAngFootL[0], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootL[0]], jointMasksFootL[0], False)
yjc.computeAngJacobian2(jAngFootR[0], DOFs, jointPositions, jointAxeses, [positionFootR[0]], jointMasksFootR[0])
yjc.computeAngJacobianDerivative2(dJAngFootR[0], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootR[0]], jointMasksFootR[0], False)
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)
CP = yrp.getCP(contactPositions, contactForces)
for i in range(len(bodyIDsToCheck)) :
controlModel.SetBodyColor(bodyIDsToCheck[i], 0, 0, 0)
##########################################
for i in range(len(rd_contactPositions)):
rd_contactPositions[i] = [0,0,0]
rd_contactForces[i] = [0,0,0]
for i in range(len(contactPositions)):
rd_contactPositions[i] = np.copy(contactPositions[i])
rd_contactForces[i] = np.copy(contactForces[i])
'''
if len(contactPositions) > 0:
rd_contactPositions = np.copy(contactPositions)
rd_contactForces = np.copy(contactForces)
print("rd_contactPositions", rd_contactPositions)
print("contactPositions", contactPositions)
'''
'''
for i in range(len(contactRendererName)):
viewer.doc.removeRenderer(contactRendererName[i])
del contactRendererName[:]
for i in range(len(contactPositions)):
contactRendererName.append(str(i))
#viewer.doc.addRenderer(str(i), yr.PointsRenderer([contactPositions[i]], (0,255,0)))
viewer.doc.addRenderer(str(i), yr.ForcesRenderer([contactForces[i]], [contactPositions[i]], (0,255,0), .009, 0.009))
viewer.motionViewWnd.update(1, viewer.doc)
'''
##########################################
contactFlagFootL = [0]*footPartNum
contactFlagFootR = [0]*footPartNum
partialDOFIndex = [22, 22]
for i in range(len(bodyIDs)) :
controlModel.SetBodyColor(bodyIDs[i], 255, 105, 105)
index = controlModel.id2index(bodyIDs[i])
for j in range(len(indexFootL)):
if index == indexFootL[j]:
contactFlagFootL[j] = 1
if j != 0:
yjc.computePartialJacobian2(jFootL[j], DOFs, jointPositions, jointAxeses, [positionFootL[j]], jointMasksFootL[j], partialDOFIndex)
yjc.computePartialJacobianDerivative2(dJFootL[j], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootL[j]], jointMasksFootL[j], False, partialDOFIndex)
break
for j in range(len(indexFootR)):
if index == indexFootR[j]:
contactFlagFootR[j] = 1
if j != 0:
yjc.computePartialJacobian2(jFootR[j], DOFs, jointPositions, jointAxeses, [positionFootR[j]], jointMasksFootR[j], partialDOFIndex)
yjc.computePartialJacobianDerivative2(dJFootR[j], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootR[j]], jointMasksFootR[j], False, partialDOFIndex)
break
for j in range(len(indexFootL)):
yjc.computeAngJacobian2(jAngFootL[j], DOFs, jointPositions, jointAxeses, [positionFootL[j]], jointMasksFootL[j])
yjc.computeAngJacobianDerivative2(dJAngFootL[j], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootL[j]], jointMasksFootL[j], False)
yjc.computeAngJacobian2(jAngFootR[j], DOFs, jointPositions, jointAxeses, [positionFootR[j]], jointMasksFootR[j])
yjc.computeAngJacobianDerivative2(dJAngFootR[j], DOFs, jointPositions, jointAxeses, linkAngVelocities, [positionFootR[j]], jointMasksFootR[j], False)
'''
if footPartNum == 1:
footCenterL = controlModel.getBodyPositionGlobal(supL)
footCenterR = controlModel.getBodyPositionGlobal(supR)
else:
if ((contactFlagFootL[3] == 1 or contactFlagFootL[4] == 1) and contactFlagFootL[0] == 0) or ((contactFlagFootR[3] == 1 or contactFlagFootR[4] == 1) and contactFlagFootR[0] == 0):
r = 0.8
footCenterL = (controlModel.getBodyPositionGlobal(supL)*r + controlModel.getBodyPositionGlobal(indexFootL[1])*(1.0-r))
footCenterR = (controlModel.getBodyPositionGlobal(supR)*r + controlModel.getBodyPositionGlobal(indexFootR[1])*(1.0-r))
#footCenterL = controlModel.getBodyPositionGlobal(indexFootL[1])
#footCenterR = controlModel.getBodyPositionGlobal(indexFootR[1])
else :
#footCenterL = (controlModel.getBodyPositionGlobal(supL) + controlModel.getBodyPositionGlobal(indexFootL[1]))/2.0
#footCenterR = (controlModel.getBodyPositionGlobal(supR) + controlModel.getBodyPositionGlobal(indexFootR[1]))/2.0
#footCenterL = controlModel.getBodyPositionGlobal(indexFootL[1])
#footCenterR = controlModel.getBodyPositionGlobal(indexFootR[1])
r = 0.8
footCenterL = (controlModel.getBodyPositionGlobal(indexFootL[1])*r + controlModel.getBodyPositionGlobal(indexFootL[3])*(1.0-r))
footCenterR = (controlModel.getBodyPositionGlobal(indexFootR[1])*r + controlModel.getBodyPositionGlobal(indexFootR[3])*(1.0-r))
'''
'''
if stage == POWERFUL_BALANCING:
footCenterL = controlModel.getBodyPositionGlobal(indexFootL[1])
footCenterR = controlModel.getBodyPositionGlobal(indexFootR[1])
else:
footCenterL = (controlModel.getBodyPositionGlobal(indexFootL[1]) + controlModel.getBodyPositionGlobal(indexFootL[3]) )/2.0
footCenterR = (controlModel.getBodyPositionGlobal(indexFootR[1]) + controlModel.getBodyPositionGlobal(indexFootR[3]))/2.0
'''
'''
p1 = controlModel.getBodyPositionGlobal(indexFootL[0])
p2 = controlModel.getBodyPositionGlobal(indexFootR[0])
p3 = controlModel.getBodyPositionGlobal(indexFootL[3])
p4 = controlModel.getBodyPositionGlobal(indexFootR[3])
print(frame, "supL", p1[1])
print(frame, "supR", p2[1])
print(frame, "calcL", p3[1])
print(frame, "calcR", p4[1])
'''
#footCenter = footCenterL + (footCenterR - footCenterL)/2.0
#footCenter[1] = 0.
#
'''
if checkAll(contactFlagFootL, 0) == 1 and checkAll(contactFlagFootR, 0) == 1:
footCenter = footCenter
elif checkAll(contactFlagFootL, 0) == 1 :
footCenter = footCenterR
elif checkAll(contactFlagFootR, 0) == 1 :
footCenter = footCenterL
'''
if footPartNum == 1:
desFCL = (controlModel.getBodyPositionGlobal(supL))
desFCR = (controlModel.getBodyPositionGlobal(supR))
else :
r = .4
desFCL = (controlModel.getBodyPositionGlobal(indexFootL[1])*r + controlModel.getBodyPositionGlobal(indexFootL[3])*(1.0-r))#controlModel.getBodyPositionGlobal(indexFootL[1])
desFCR = (controlModel.getBodyPositionGlobal(indexFootR[1])*r + controlModel.getBodyPositionGlobal(indexFootR[3])*(1.0-r))#controlModel.getBodyPositionGlobal(indexFootR[1])
desFC = desFCL + (desFCR - desFCL)/2.0
if checkAll(contactFlagFootL, 0) == 1 and checkAll(contactFlagFootR, 0) == 1:
desFC = desFC
elif checkAll(contactFlagFootL, 0) == 1 :
desFC = desFCR
elif checkAll(contactFlagFootR, 0) == 1 :
desFC = desFCL
#if stage == MOTION_TRACKING:
# desFC = desFCL
desFC[1] = 0
rd_footCenter_des[0] = desFC.copy()
curRelCMVec = CM_plane - desFC
vecRatio = mm.length(curRelCMVec)*0.
#print(frame, vecRatio)
footCenter = desFC - curRelCMVec*(vecRatio)#/10.0
footCenter_ref = refFootL + (refFootR - refFootL)/2.0
#footCenter_ref[1] = 0.
footCenter[1] = 0.
vecRatio = mm.length(curRelCMVec)*0.
softConstPointOffset = -curRelCMVec*(vecRatio)#/10.0
#print(frame, vecRatio, softConstPointOffset)
desForeSupLAcc = [0,0,0]
desForeSupRAcc = [0,0,0]
totalNormalForce = [0,0,0]
for i in range(len(contactForces)):
totalNormalForce[0] += contactForces[i][0]
totalNormalForce[1] += contactForces[i][1]
totalNormalForce[2] += contactForces[i][2]
#print((totalMass*mm.s2v(wcfg.gravity))[1])
print("totalNormalForce=", totalNormalForce[1])
print("F_Diff=", (totalMass*mm.s2v(wcfg.gravity))[1]+totalNormalForce[1])
# linear momentum
CM_ref_plane = footCenter
dL_des_plane = Kl*totalMass*(CM_ref_plane - CM_plane) - Dl*totalMass*dCM_plane
print("CM_Diff=",mm.length(CM_ref_plane - CM_plane))
# angular momentum
CP_ref = footCenter
timeStep = 30.
if CP_old[0]==None or CP==None:
dCP = None
else:
dCP = (CP - CP_old[0])/(1/timeStep)
CP_old[0] = CP
if CP!=None and dCP!=None:
ddCP_des = Kh*(CP_ref - CP) - Dh*(dCP)
CP_des = CP + dCP*(1/timeStep) + .5*ddCP_des*((1/timeStep)**2)
#dH_des = np.cross((CP_des - CM), (dL_des_plane + totalMass*mm.s2v(wcfg.gravity)))
dH_des = np.cross((CP_des - CM_plane), (dL_des_plane + totalMass*mm.s2v(wcfg.gravity)))
print("CP_Diff=",mm.length(CP_des - CP))
else:
dH_des = None
# momentum matrix
RS = np.dot(P, Jsys)
R, S = np.vsplit(RS, 2)
rs = np.dot((np.dot(dP, Jsys) + np.dot(P, dJsys)), dth_flat)
r_bias, s_bias = np.hsplit(rs, 2)
##############################
# soft point constraint
#####################################################
P_cur = controlModel.getBodyPositionGlobal(constBody)
constBodyVec = P_cur - footCenter
softConstPoint = [footCenter[0]+softConstPointOffset[0], mm.length(constBodyVec), footCenter[2]+softConstPointOffset[2]]
#####################################################
P_des = softConstPoint
#P_cur = controlModel.getBodyPositionGlobal(constBody)
dP_des = [0, 0, 0]
dP_cur = controlModel.getBodyVelocityGlobal(constBody)
ddP_des1 = Ksc*(-(P_des - P_cur)) - Dsc*(-(dP_cur - dP_des))
r = -(P_des - P_cur)
I = np.vstack(([1,0,0],[0,1,0],[0,0,1]))
Z = np.hstack((I, mm.getCrossMatrixForm(-r)))
yjc.computeJacobian2(Jconst, DOFs, jointPositions, jointAxeses, [P_cur], constJointMasks)
JL, JA = np.vsplit(Jconst, 2)
Q1 = np.dot(Z, Jconst)
q1 = np.dot(JA, dth_flat)
q2 = np.dot(mm.getCrossMatrixForm(q1), np.dot(mm.getCrossMatrixForm(q1), r))
yjc.computeJacobianDerivative2(dJconst, DOFs, jointPositions, jointAxeses, linkAngVelocities, [P_cur], constJointMasks, False)
q_bias1 = np.dot(np.dot(Z, dJconst), dth_flat) + q2
##############################
flagContact = True
if dH_des==None or np.any(np.isnan(dH_des)) == True:
flagContact = False
viewer.doc.showRenderer('rd_grf_des', False)
viewer.motionViewWnd.update(1, viewer.doc)
else:
viewer.doc.showRenderer('rd_grf_des', True)
viewer.motionViewWnd.update(1, viewer.doc)
'''
0 : initial
1 : contact
2 : fly
3 : landing
'''
#MOTION = FORWARD_JUMP
if mit.MOTION == mit.FORWARD_JUMP :
frame_index = [136, 100]
#frame_index = [100000, 100000]
elif mit.MOTION == mit.TAEKWONDO:
frame_index = [130, 100]
#frame_index = [100000, 100000]
elif mit.MOTION == mit.TAEKWONDO2:
frame_index = [130+40, 100]
elif mit.MOTION == mit.WALK:
frame_index = [10000, 60]
else :
frame_index = [1000000, 1000000]
#MOTION = TAEKWONDO
#frame_index = [135, 100]
'''
if frame > 300 :
if stage != DYNAMIC_BALANCING:
print("#", frame,"-DYNAMIC_BALANCING")
stage = DYNAMIC_BALANCING
Kk = Kk*1
Dk = 2*(Kk**.5)
'''
if frame > frame_index[0] :
if stage != POWERFUL_BALANCING:
print("#", frame,"-POWERFUL_BALANCING")
stage = POWERFUL_BALANCING
Kk = Kk*2
Dk = 2*(Kk**.5)
elif frame > frame_index[1]:
if stage != MOTION_TRACKING:
print("#", frame,"-MOTION_TRACKING")
stage = MOTION_TRACKING
trackingW = w
#if checkAll(contactFlagFootR, 0) != 1 :
if stage == MOTION_TRACKING:
trackingW = w2
#stage = POWERFUL_BALANCING
Bt = Bt*2
# optimization
mot.addTrackingTerms(problem, totalDOF, Bt, trackingW, ddth_des_flat)
mot.addSoftPointConstraintTerms(problem, totalDOF, Bsc, ddP_des1, Q1, q_bias1)
if flagContact == True:
if stage != MOTION_TRACKING+10:
mot.addLinearTerms(problem, totalDOF, Bl, dL_des_plane, R, r_bias)
mot.addAngularTerms(problem, totalDOF, Bh, dH_des, S, s_bias)
a_sup_2 = [None]
Jsup_2 = [None]
dJsup_2 = [None]
##############################
# Hard constraint
if stage != MOTION_TRACKING:
Kk2 = Kk * 2.0
else :
Kk2 = Kk * 1.5
Dk2 = 2*(Kk2**.5)
'''
desLinearAccL, desPosL = getDesFootLinearAcc(motionModel, controlModel, supL, ModelOffset, CM_ref, CM, Kk2, Dk2)
desLinearAccR, desPosR = getDesFootLinearAcc(motionModel, controlModel, supR, ModelOffset, CM_ref, CM, Kk2, Dk2)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, supL, Kk2, Dk2)
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel, supR, Kk2, Dk2)
'''
if stage != MOTION_TRACKING:
idx = 0 #LEFT/RIGHT_TOES
if stage != MOTION_TRACKING:
desLinearAccL, desPosL = getDesFootLinearAcc(motionModel, controlModel, indexFootL[idx], ModelOffset, CM_ref, CM, Kk2, Dk2, 0.14)#0.076)
desLinearAccR, desPosR = getDesFootLinearAcc(motionModel, controlModel, indexFootR[idx], ModelOffset, CM_ref, CM, Kk2, Dk2, 0.14)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[idx], Kk2, Dk2, [0,0,-1], [0,1,1.5])
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel, indexFootR[idx], Kk2, Dk2, [0,0,-1], [0,1,1.5])
a_sup_2 = np.hstack(( np.hstack((desLinearAccL, desAngularAccL)), np.hstack((desLinearAccR, desAngularAccR)) ))
Jsup_2 = np.vstack((jFootL[idx], jFootR[idx]))
dJsup_2 = np.vstack((dJFootL[idx], dJFootR[idx]))
else:
desLinearAccL, desPosL = getDesFootLinearAcc(motionModel, controlModel, indexFootL[idx], ModelOffset, CM_ref, CM, Kk2, Dk2, 0.040)
desLinearAccR, desPosR = getDesFootLinearAcc(motionModel, controlModel, indexFootR[idx], ModelOffset, CM_ref, CM, Kk2, Dk2, 0.040)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[idx], Kk2, Dk2)
a_sup_2 = np.hstack((desLinearAccL, desAngularAccL))
Jsup_2 = jFootL[idx]
dJsup_2 = dJFootL[idx]
rd_DesPosL[0] = desPosL.copy()
rd_DesPosR[0] = desPosR.copy()
else:
if footPartNum != 5:
idx = 0
desLinearAccL, desPosL = getDesFootLinearAcc(motionModel, controlModel, indexFootL[idx], ModelOffset, CM_ref, CM, Kk2, Dk2, 0.045)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[idx], Kk2, Dk2)
a_sup_2 = np.hstack(( desLinearAccL, desAngularAccL))
Jsup_2 = (jFootL[idx])
dJsup_2 = (dJFootL[idx])
'''
idx = 4
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[idx], Kk2, Dk2)
a_sup_2 = np.hstack(( a_sup_2, desAngularAccL))
Jsup_2 = np.vstack(( Jsup_2, jAngFootL[idx]))
dJsup_2 = np.vstack(( dJsup_2, dJAngFootL[idx]))
'''
'''
idx = 1
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[idx], Kk2, Dk2)
a_sup_2 = np.hstack(( a_sup_2, desAngularAccL))
Jsup_2 = np.vstack(( Jsup_2, jAngFootL[idx]))
dJsup_2 = np.vstack(( dJsup_2, dJAngFootL[idx]))
'''
else:
idx = 0
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[idx], Kk2, Dk2)
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel, indexFootR[idx], Kk2, Dk2)
a_sup_2 = np.hstack(( desAngularAccL, desAngularAccR ))
Jsup_2 = np.vstack((jAngFootL[idx], jAngFootR[idx]))
dJsup_2 = np.vstack((dJAngFootL[idx], dJAngFootR[idx]))
##############################
##############################
# Additional constraint
if stage != MOTION_TRACKING+10:
#Kk2 = Kk * 2.5
Kk2 = Kk * 2.5
Dk2 = 2*(Kk2**.5)
desForePosL = [0,0,0]
desForePosR = [0,0,0]
desRearPosL = [0,0,0]
desRearPosR = [0,0,0]
for i in range(1, footPartNum) :
if stage != MOTION_TRACKING:
axis = [0,1,0]
desAng = [0,1,0]
desY = 0.04
if i == 1 or i == 2:
desAng = [0,1,1.2]
desY = 0.076
if contactFlagFootL[i] == 1:
desLinearAccL, desForePosL = getDesFootLinearAcc(motionModel, controlModel, indexFootL[i], ModelOffset, CM_ref, CM, Kk2, Dk2, desY)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[i], Kk2, Dk2, axis, desAng)
a_sup_2 = np.hstack(( a_sup_2, np.hstack((desLinearAccL, desAngularAccL)) ))
Jsup_2 = np.vstack(( Jsup_2, jFootL[i] ))
dJsup_2 = np.vstack(( dJsup_2, dJFootL[i] ))
if contactFlagFootR[i] == 1:
desLinearAccR, desForePosR = getDesFootLinearAcc(motionModel, controlModel, indexFootR[i], ModelOffset, CM_ref, CM, Kk2, Dk2, desY)
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel, indexFootR[i], Kk2, Dk2, axis, desAng)
a_sup_2 = np.hstack(( a_sup_2, np.hstack((desLinearAccR, desAngularAccR)) ))
Jsup_2 = np.vstack(( Jsup_2, jFootR[i] ))
dJsup_2 = np.vstack(( dJsup_2, dJFootR[i] ))
else:
if contactFlagFootL[i] == 1:
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[i], Kk2, Dk2)
a_sup_2 = np.hstack(( a_sup_2, desAngularAccL ))
Jsup_2 = np.vstack(( Jsup_2, jAngFootL[i] ))
dJsup_2 = np.vstack(( dJsup_2, dJAngFootL[i] ))
if contactFlagFootR[i] == 1:
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel, indexFootR[i], Kk2, Dk2)
a_sup_2 = np.hstack(( a_sup_2, desAngularAccR ))
Jsup_2 = np.vstack(( Jsup_2, jAngFootR[i] ))
dJsup_2 = np.vstack(( dJsup_2, dJAngFootR[i] ))
'''
for i in range(1, footPartNum) :
if contactFlagFootL[i] == 1:
desLinearAccL, desForePosL = getDesFootLinearAcc(motionModel, controlModel, indexFootL[i], ModelOffset, CM_ref, CM, Kk2, Dk2, 0.034)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, indexFootL[i], Kk2, Dk2)
a_sup_2 = np.hstack(( a_sup_2, np.hstack((desLinearAccL, desAngularAccL)) ))
Jsup_2 = np.vstack(( Jsup_2, jFootL[i] ))
dJsup_2 = np.vstack(( dJsup_2, dJFootL[i] ))
if contactFlagFootR[i] == 1:
desLinearAccR, desForePosR = getDesFootLinearAcc(motionModel, controlModel, indexFootR[i], ModelOffset, CM_ref, CM, Kk2, Dk2, 0.034)
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel, indexFootR[i], Kk2, Dk2)
a_sup_2 = np.hstack(( a_sup_2, np.hstack((desLinearAccR, desAngularAccR)) ))
Jsup_2 = np.vstack(( Jsup_2, jFootR[i] ))
dJsup_2 = np.vstack(( dJsup_2, dJFootR[i] ))
'''
rd_DesForePosL[0] = desForePosL
rd_DesForePosR[0] = desForePosR
rd_DesRearPosL[0] = desRearPosL
rd_DesRearPosR[0] = desRearPosR
##############################
mot.setConstraint(problem, totalDOF, Jsup_2, dJsup_2, dth_flat, a_sup_2)
r = problem.solve()
problem.clear()
ype.nested(r['x'], ddth_sol)
rootPos[0] = controlModel.getBodyPositionGlobal(selectedBody)
localPos = [[0, 0, 0]]
rd_Joint[0] = controlModel.getJointPositionGlobal(motion[0].skeleton.getJointIndex('LeftMetatarsal_1'))
rd_Joint2[0] = controlModel.getJointPositionGlobal(motion[0].skeleton.getJointIndex('LeftMetatarsal_3'))
rd_Joint3[0] = controlModel.getJointPositionGlobal(motion[0].skeleton.getJointIndex('LeftPhalange_1'))
rd_Joint4[0] = controlModel.getJointPositionGlobal(motion[0].skeleton.getJointIndex('LeftPhalange_3'))
for i in range(stepsPerFrame):
# apply penalty force
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)
vpWorld.applyPenaltyForce(bodyIDs, contactPositionLocals, contactForces)
extraForce[0] = viewer.GetForce()
if (extraForce[0][0] != 0 or extraForce[0][1] != 0 or extraForce[0][2] != 0) :
forceApplyFrame += 1
#vpWorld.applyPenaltyForce(selectedBodyId, localPos, extraForce)
controlModel.applyBodyForceGlobal(selectedBody, extraForce[0])
applyedExtraForce[0] = extraForce[0]
if forceApplyFrame*wcfg.timeStep > 0.1:
viewer.ResetForce()
forceApplyFrame = 0
controlModel.setDOFAccelerations(ddth_sol)
controlModel.solveHybridDynamics()
'''
extraForce[0] = viewer.GetForce()
if (extraForce[0][0] != 0 or extraForce[0][1] != 0 or extraForce[0][2] != 0) :
forceApplyFrame += 1
vpWorld.applyPenaltyForce(selectedBodyId, localPos, extraForce)
applyedExtraForce[0] = extraForce[0]
if forceApplyFrame*wcfg.timeStep > 0.1:
viewer.ResetForce()
forceApplyFrame = 0
'''
vpWorld.step()
# rendering
rd_footCenter[0] = footCenter
rd_CM[0] = CM.copy()
rd_CM_plane[0] = CM_plane.copy()
rd_footCenter_ref[0] = footCenter_ref
rd_CM_plane_ref[0] = CM_ref.copy()
rd_CM_ref[0] = CM_ref.copy()
rd_CM_ref_vec[0] = (CM_ref - footCenter_ref)*3.
rd_CM_vec[0] = (CM - footCenter)*3
#rd_CM_plane[0][1] = 0.
if CP!=None and dCP!=None:
rd_CP[0] = CP
rd_CP_des[0] = CP_des
rd_dL_des_plane[0] = dL_des_plane
rd_dH_des[0] = dH_des
rd_grf_des[0] = totalNormalForce# - totalMass*mm.s2v(wcfg.gravity)#dL_des_plane - totalMass*mm.s2v(wcfg.gravity)
rd_exf_des[0] = applyedExtraForce[0]
rd_root_des[0] = rootPos[0]
rd_CMP[0] = softConstPoint
rd_soft_const_vec[0] = controlModel.getBodyPositionGlobal(constBody)-softConstPoint
#indexL = motion[0].skeleton.getJointIndex('Hips')
#indexR = motion[0].skeleton.getJointIndex('Spine1')
indexL = indexFootL[0]
indexR = indexFootR[0]
curAng = [controlModel.getBodyOrientationGlobal(indexL)]
curAngY = np.dot(curAng, np.array([0,0,1]))
rd_footL_vec[0] = np.copy(curAngY[0])
rd_footCenterL[0] = controlModel.getBodyPositionGlobal(indexL)
curAng = [controlModel.getBodyOrientationGlobal(indexR)]
curAngY = np.dot(curAng, np.array([0,0,1]))
rd_footR_vec[0] = np.copy(curAngY[0])
rd_footCenterR[0] = controlModel.getBodyPositionGlobal(indexR)
if (forceApplyFrame == 0) :
applyedExtraForce[0] = [0, 0, 0]
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/60.)
viewer.show()
Fl.run()
def main():
np.set_printoptions(precision=4, linewidth=200)
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_5()
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
motionModel.recordVelByFiniteDiff()
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
#ModelOffset = (1.5, -0.01, 0)
ModelOffset = (1.5, 0.0, 0)
controlModel.translateByOffset(ModelOffset)
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
# parameter
Kt = config['Kt']
Dt = config['Dt'] # tracking gain
Kl = config['Kl']
Dl = config['Dl'] # linear balance gain
Kh = config['Kh']
Dh = config['Dh'] # angular balance gain
Ks = config['Ks']
Ds = config['Ds'] # penalty force spring gain
Bt = config['Bt']
Bl = config['Bl']
Bh = config['Bh']
w = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap'])
w2 = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap2'])
#w_IK = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['IKweightMap'])
supL = motion[0].skeleton.getJointIndex(config['supLink'])
supR = motion[0].skeleton.getJointIndex(config['supLink2'])
rootB = motion[0].skeleton.getJointIndex(config['root'])
selectedBody = motion[0].skeleton.getJointIndex(config['end'])
#constBody = motion[0].skeleton.getJointIndex('LeftForeArm')
constBody = motion[0].skeleton.getJointIndex(config['const'])
# jacobian
Jsup = yjc.makeEmptyJacobian(DOFs, 1)
dJsup = Jsup.copy()
JsupPre = Jsup.copy()
Jsys = yjc.makeEmptyJacobian(DOFs, controlModel.getBodyNum())
dJsys = Jsys.copy()
JsysPre = Jsys.copy()
Jconst = yjc.makeEmptyJacobian(DOFs, 1)
dJconst = Jconst.copy()
###############
footPartNum = config['FootPartNum']
indexFootL = [None] * footPartNum
indexFootR = [None] * footPartNum
jFootL = [None] * footPartNum
dJFootL = [None] * footPartNum
jFootR = [None] * footPartNum
dJFootR = [None] * footPartNum
jointMasksFootL = [None] * footPartNum
jointMasksFootR = [None] * footPartNum
jAngFootL = [None] * footPartNum
dJAngFootL = [None] * footPartNum
jAngFootR = [None] * footPartNum
dJAngFootR = [None] * footPartNum
for i in range(footPartNum):
jFootL[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootL[i] = jFootL[i].copy()
jFootR[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootR[i] = jFootR[i].copy()
jAngFootL[i] = yjc.makeEmptyJacobian(DOFs, 1, False)
dJAngFootL[i] = jAngFootL[i].copy()
jAngFootR[i] = yjc.makeEmptyJacobian(DOFs, 1, False)
dJAngFootR[i] = jAngFootR[i].copy()
indexFootL[i] = motion[0].skeleton.getJointIndex(
config['FootLPart'][i])
indexFootR[i] = motion[0].skeleton.getJointIndex(
config['FootRPart'][i])
jointMasksFootL[i] = [
yjc.getLinkJointMask(motion[0].skeleton, indexFootL[i])
]
jointMasksFootR[i] = [
yjc.getLinkJointMask(motion[0].skeleton, indexFootR[i])
]
constJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, constBody)]
allLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)
'''
maskArray = [foreSupLJointMasks, foreSupRJointMasks, rearSupLJointMasks, rearSupRJointMasks]
parentArray = [supL, supR, supL, supR]
effectorArray = [foreSupL, foreSupR, rearSupL, rearSupR]
for j in range(4) :
for i in range(len(foreSupLJointMasks)) :
if i == parentArray[j] or i == effectorArray[j] :
maskArray[j][0][i] = 1
else :
maskArray[j][0][i] = 0
'''
# momentum matrix
linkMasses = controlModel.getBodyMasses()
totalMass = controlModel.getTotalMass()
TO = ymt.make_TO(linkMasses)
dTO = ymt.make_dTO(len(linkMasses))
# optimization
problem = yac.LSE(totalDOF, 6)
a_sup = (0, 0, 0, 0, 0, 0) #L
#a_sup2 = (0,0,0, 0,0,0)#R
a_sup2 = [0, 0, 0, 0, 0, 0] #R
a_sup_2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
CP_old = [mm.v3(0., 0., 0.)]
# penalty method
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.] * len(bodyIDsToCheck)
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
d_th_IK = ype.makeNestedList(DOFs)
d_th_IK_L = ype.makeNestedList(DOFs)
d_th_IK_R = ype.makeNestedList(DOFs)
dd_th_IK = ype.makeNestedList(DOFs)
dd_th_IK_flat = ype.makeFlatList(totalDOF)
d_th_IK_flat = ype.makeFlatList(totalDOF)
ddth_c_flat = ype.makeFlatList(totalDOF)
# viewer
rd_footCenter = [None]
rd_footCenter_ref = [None]
rd_footCenterL = [None]
rd_footCenterR = [None]
rd_CM_plane = [None]
rd_CM_plane_ref = [None]
rd_CM_ref = [None]
rd_CM = [None]
rd_CM_vec = [None]
rd_CM_ref_vec = [None]
rd_CP = [None]
rd_CP_des = [None]
rd_dL_des_plane = [None]
rd_dH_des = [None]
rd_grf_des = [None]
rd_exf_des = [None]
rd_root_des = [None]
rd_soft_const_vec = [None]
rd_root = [None]
rd_footL_vec = [None]
rd_footR_vec = [None]
rd_CMP = [None]
rd_DesPosL = [None]
rd_DesPosR = [None]
rd_DesForePosL = [None]
rd_DesForePosR = [None]
rd_DesRearPosL = [None]
rd_DesRearPosR = [None]
rootPos = [None]
selectedBodyId = [selectedBody]
extraForce = [None]
applyedExtraForce = [None]
applyedExtraForce[0] = [0, 0, 0]
normalVector = [[0, 2, 0]]
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,255,255), yr.LINK_BONE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer(
'motionModel',
cvr.VpModelRenderer(motionModel, (150, 150, 255), yr.POLYGON_FILL))
viewer.doc.addRenderer(
'controlModel',
cvr.VpModelRenderer(controlModel, (255, 240, 255), yr.POLYGON_FILL))
viewer.doc.addRenderer('rd_footCenter', yr.PointsRenderer(rd_footCenter))
#viewer.doc.addRenderer('rd_footCenterL', yr.PointsRenderer(rd_footCenterL))
#viewer.doc.addRenderer('rd_footCenterR', yr.PointsRenderer(rd_footCenterR))
#viewer.doc.addRenderer('rd_CM_plane', yr.PointsRenderer(rd_CM_plane, (255,255,0)))
viewer.doc.addRenderer('rd_CM', yr.PointsRenderer(rd_CM, (255, 255, 0)))
viewer.doc.addRenderer('rd_CP_des',
yr.PointsRenderer(rd_CP_des, (0, 255, 0)))
#viewer.doc.addRenderer('rd_CP_des', yr.PointsRenderer(rd_CP_des, (255,0,255)))
# viewer.doc.addRenderer('rd_dL_des_plane', yr.VectorsRenderer(rd_dL_des_plane, rd_CM, (255,255,0)))
# viewer.doc.addRenderer('rd_dH_des', yr.VectorsRenderer(rd_dH_des, rd_CM, (0,255,0)))
viewer.doc.addRenderer(
'rd_grf_des', yr.ForcesRenderer(rd_grf_des, rd_CP, (0, 255, 255),
.001))
viewer.doc.addRenderer(
'rd_exf_des',
yr.ForcesRenderer(rd_exf_des, rd_root_des, (0, 255, 0), .009, 0.05))
#viewer.doc.addRenderer('rd_CMP', yr.PointsRenderer(rd_CMP, (0,0,255)))
viewer.doc.addRenderer('rd_DesPosL',
yr.PointsRenderer(rd_DesPosL, (0, 0, 255)))
viewer.doc.addRenderer('rd_DesPosR',
yr.PointsRenderer(rd_DesPosR, (0, 100, 255)))
viewer.doc.addRenderer('rd_DesForePosL',
yr.PointsRenderer(rd_DesForePosL, (150, 0, 200)))
viewer.doc.addRenderer('rd_DesForePosR',
yr.PointsRenderer(rd_DesForePosR, (150, 0, 250)))
viewer.doc.addRenderer('rd_DesRearPosL',
yr.PointsRenderer(rd_DesRearPosL, (0, 150, 200)))
viewer.doc.addRenderer('rd_DesRearPosR',
yr.PointsRenderer(rd_DesRearPosR, (0, 150, 250)))
#viewer.doc.addRenderer('softConstraint', yr.VectorsRenderer(rd_soft_const_vec, rd_CMP, (255,0,0), 3))
viewer.doc.addRenderer(
'rd_footLVec',
yr.VectorsRenderer(rd_footL_vec, rd_footCenterL, (255, 0, 0), 3))
viewer.doc.addRenderer(
'rd_footRVec',
yr.VectorsRenderer(rd_footR_vec, rd_footCenterL, (255, 255, 0), 3))
#viewer.doc.addRenderer('rd_footCenter_ref', yr.PointsRenderer(rd_footCenter_ref))
viewer.doc.addRenderer('rd_CM_plane_ref',
yr.PointsRenderer(rd_CM_plane_ref, (255, 255, 0)))
viewer.doc.addRenderer(
'rd_refNormalVec',
yr.VectorsRenderer(normalVector, rd_footCenter_ref, (255, 0, 0), 3))
viewer.doc.addRenderer(
'rd_refCMVec',
yr.VectorsRenderer(rd_CM_ref_vec, rd_footCenter_ref, (255, 0, 255), 3))
viewer.doc.addRenderer(
'rd_curNormalVec',
yr.VectorsRenderer(normalVector, rd_footCenter, (255, 0, 0), 3))
viewer.doc.addRenderer(
'rd_CMVec',
yr.VectorsRenderer(rd_CM_vec, rd_footCenter, (255, 0, 255), 3))
stage = STATIC_BALANCING
def simulateCallback(frame):
global g_initFlag
global forceShowFrame
global forceApplyFrame
global JsysPre
global JsupPreL
global JsupPreR
global JsupPre
global softConstPoint
global stage
motionModel.update(motion[frame])
Kt, Kk, Kl, Kh, Ksc, Bt, Bl, Bh, Bsc = viewer.GetParam()
Dt = 2 * (Kt**.5)
Dk = 2 * (Kk**.5)
Dl = 2 * (Kl**.5)
Dh = 2 * (Kh**.5)
Dsc = 2 * (Ksc**.5)
if Bsc == 0.0:
viewer.doc.showRenderer('softConstraint', False)
viewer.motionViewWnd.update(1, viewer.doc)
else:
viewer.doc.showRenderer('softConstraint', True)
renderer1 = viewer.doc.getRenderer('softConstraint')
renderer1.rc.setLineWidth(0.1 + Bsc * 3)
viewer.motionViewWnd.update(1, viewer.doc)
# tracking
th_r = motion.getDOFPositions(frame)
th = controlModel.getDOFPositions()
dth_r = motion.getDOFVelocities(frame)
dth = controlModel.getDOFVelocities()
ddth_r = motion.getDOFAccelerations(frame)
ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r,
Kt, Dt)
ddth_c = controlModel.getDOFAccelerations()
ype.flatten(ddth_des, ddth_des_flat)
ype.flatten(dth, dth_flat)
ype.flatten(ddth_c, ddth_c_flat)
# jacobian
'''
if stage == POWERFUL_BALANCING:
#if stage != MOTION_TRACKING:
footCenterL = controlModel.getBodyPositionGlobal(supL)
footCenterR = controlModel.getBodyPositionGlobal(supR)
else:
footCenterL = controlModel.getBodyPositionGlobal(indexFootL[1])
footCenterR = controlModel.getBodyPositionGlobal(indexFootR[1])
'''
if footPartNum == 1:
footCenterL = controlModel.getBodyPositionGlobal(supL)
footCenterR = controlModel.getBodyPositionGlobal(supR)
else:
if stage == POWERFUL_BALANCING:
footCenterL = controlModel.getBodyPositionGlobal(supL)
footCenterR = controlModel.getBodyPositionGlobal(supR)
else:
footCenterL = (
controlModel.getBodyPositionGlobal(supL) +
controlModel.getBodyPositionGlobal(indexFootL[1])) / 2.0
footCenterR = (
controlModel.getBodyPositionGlobal(supR) +
controlModel.getBodyPositionGlobal(indexFootR[1])) / 2.0
refFootL = motionModel.getBodyPositionGlobal(supL)
refFootR = motionModel.getBodyPositionGlobal(supR)
footCenter = footCenterL + (footCenterR - footCenterL) / 2.0
footCenter[1] = 0.
footCenter_ref = refFootL + (refFootR - refFootL) / 2.0
#footCenter_ref[1] = 0.
positionFootL = [None] * footPartNum
positionFootR = [None] * footPartNum
for i in range(footPartNum):
positionFootL[i] = controlModel.getBodyPositionGlobal(
indexFootL[i])
positionFootR[i] = controlModel.getBodyPositionGlobal(
indexFootR[i])
linkPositions = controlModel.getBodyPositionsGlobal()
linkVelocities = controlModel.getBodyVelocitiesGlobal()
linkAngVelocities = controlModel.getBodyAngVelocitiesGlobal()
linkInertias = controlModel.getBodyInertiasGlobal()
jointPositions = controlModel.getJointPositionsGlobal()
jointAxeses = controlModel.getDOFAxeses()
CM = yrp.getCM(linkPositions, linkMasses, totalMass)
dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)
CM_plane = copy.copy(CM)
CM_plane[1] = 0.
dCM_plane = copy.copy(dCM)
dCM_plane[1] = 0.
linkPositions_ref = motionModel.getBodyPositionsGlobal()
CM_ref = yrp.getCM(linkPositions_ref, linkMasses, totalMass)
CM_plane_ref = copy.copy(CM_ref)
CM_plane_ref[1] = 0.
P = ymt.getPureInertiaMatrix(TO, linkMasses, linkPositions, CM,
linkInertias)
dP = ymt.getPureInertiaMatrixDerivative(dTO, linkMasses,
linkVelocities, dCM,
linkAngVelocities,
linkInertias)
yjc.computeJacobian2(Jsys, DOFs, jointPositions, jointAxeses,
linkPositions, allLinkJointMasks)
yjc.computeJacobianDerivative2(dJsys, DOFs, jointPositions,
jointAxeses, linkAngVelocities,
linkPositions, allLinkJointMasks)
if g_initFlag == 0:
softConstPoint = controlModel.getBodyPositionGlobal(constBody)
softConstPoint[1] -= .3
g_initFlag = 1
yjc.computeJacobian2(jFootL[0], DOFs, jointPositions, jointAxeses,
[positionFootL[0]], jointMasksFootL[0])
yjc.computeJacobianDerivative2(dJFootL[0], DOFs, jointPositions,
jointAxeses, linkAngVelocities,
[positionFootL[0]], jointMasksFootL[0],
False)
yjc.computeJacobian2(jFootR[0], DOFs, jointPositions, jointAxeses,
[positionFootR[0]], jointMasksFootR[0])
yjc.computeJacobianDerivative2(dJFootR[0], DOFs, jointPositions,
jointAxeses, linkAngVelocities,
[positionFootR[0]], jointMasksFootR[0],
False)
yjc.computeAngJacobian2(jAngFootL[0], DOFs, jointPositions,
jointAxeses, [positionFootL[0]],
jointMasksFootL[0])
yjc.computeAngJacobianDerivative2(dJAngFootL[0], DOFs, jointPositions,
jointAxeses, linkAngVelocities,
[positionFootL[0]],
jointMasksFootL[0], False)
yjc.computeAngJacobian2(jAngFootR[0], DOFs, jointPositions,
jointAxeses, [positionFootR[0]],
jointMasksFootR[0])
yjc.computeAngJacobianDerivative2(dJAngFootR[0], DOFs, jointPositions,
jointAxeses, linkAngVelocities,
[positionFootR[0]],
jointMasksFootR[0], False)
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(
bodyIDsToCheck, mus, Ks, Ds)
CP = yrp.getCP(contactPositions, contactForces)
for i in range(len(bodyIDsToCheck)):
controlModel.SetBodyColor(bodyIDsToCheck[i], 0, 0, 0)
contactFlagFootL = [0] * footPartNum
contactFlagFootR = [0] * footPartNum
for i in range(len(bodyIDs)):
controlModel.SetBodyColor(bodyIDs[i], 255, 105, 105)
index = controlModel.id2index(bodyIDs[i])
for j in range(len(indexFootL)):
if index == indexFootL[j]:
contactFlagFootL[j] = 1
if j != 0:
yjc.computeJacobian2(jFootL[j], DOFs, jointPositions,
jointAxeses, [positionFootL[j]],
jointMasksFootL[j])
yjc.computeJacobianDerivative2(
dJFootL[j], DOFs, jointPositions, jointAxeses,
linkAngVelocities, [positionFootL[j]],
jointMasksFootL[j], False)
break
for j in range(len(indexFootR)):
if index == indexFootR[j]:
contactFlagFootR[j] = 1
if j != 0:
yjc.computeJacobian2(jFootR[j], DOFs, jointPositions,
jointAxeses, [positionFootR[j]],
jointMasksFootR[j])
yjc.computeJacobianDerivative2(
dJFootR[j], DOFs, jointPositions, jointAxeses,
linkAngVelocities, [positionFootR[j]],
jointMasksFootR[j], False)
break
for j in range(len(indexFootL)):
yjc.computeAngJacobian2(jAngFootL[j], DOFs, jointPositions,
jointAxeses, [positionFootL[j]],
jointMasksFootL[j])
yjc.computeAngJacobianDerivative2(dJAngFootL[j], DOFs,
jointPositions, jointAxeses,
linkAngVelocities,
[positionFootL[j]],
jointMasksFootL[j], False)
yjc.computeAngJacobian2(jAngFootR[j], DOFs, jointPositions,
jointAxeses, [positionFootR[j]],
jointMasksFootR[j])
yjc.computeAngJacobianDerivative2(dJAngFootR[j], DOFs,
jointPositions, jointAxeses,
linkAngVelocities,
[positionFootR[j]],
jointMasksFootR[j], False)
#
if checkAll(contactFlagFootL, 0) == 1 and checkAll(
contactFlagFootR, 0) == 1:
footCenter = footCenter
elif checkAll(contactFlagFootL, 0) == 1:
footCenter = footCenterR
elif checkAll(contactFlagFootR, 0) == 1:
footCenter = footCenterL
footCenter[1] = 0.
desForeSupLAcc = [0, 0, 0]
desForeSupRAcc = [0, 0, 0]
totalNormalForce = [0, 0, 0]
for i in range(len(contactForces)):
totalNormalForce[0] += contactForces[i][0]
totalNormalForce[1] += contactForces[i][1]
totalNormalForce[2] += contactForces[i][2]
# linear momentum
CM_ref_plane = footCenter
dL_des_plane = Kl * totalMass * (CM_ref_plane -
CM_plane) - Dl * totalMass * dCM_plane
# angular momentum
CP_ref = footCenter
timeStep = 30.
if CP_old[0] == None or CP == None:
dCP = None
else:
dCP = (CP - CP_old[0]) / (1 / timeStep)
CP_old[0] = CP
if CP != None and dCP != None:
ddCP_des = Kh * (CP_ref - CP) - Dh * (dCP)
CP_des = CP + dCP * (1 / timeStep) + .5 * ddCP_des * (
(1 / timeStep)**2)
dH_des = np.cross(
(CP_des - CM),
(dL_des_plane + totalMass * mm.s2v(wcfg.gravity)))
#dH_des = np.cross((CP_des - CM_plane), (dL_des_plane + totalMass*mm.s2v(wcfg.gravity)))
else:
dH_des = None
# momentum matrix
RS = np.dot(P, Jsys)
R, S = np.vsplit(RS, 2)
rs = np.dot((np.dot(dP, Jsys) + np.dot(P, dJsys)), dth_flat)
r_bias, s_bias = np.hsplit(rs, 2)
##############################
# soft point constraint
P_des = softConstPoint
P_cur = controlModel.getBodyPositionGlobal(constBody)
dP_des = [0, 0, 0]
dP_cur = controlModel.getBodyVelocityGlobal(constBody)
ddP_des1 = Ksc * (P_des - P_cur) - Dsc * (dP_cur - dP_des)
r = P_des - P_cur
I = np.vstack(([1, 0, 0], [0, 1, 0], [0, 0, 1]))
Z = np.hstack((I, mm.getCrossMatrixForm(-r)))
yjc.computeJacobian2(Jconst, DOFs, jointPositions, jointAxeses,
[softConstPoint], constJointMasks)
JL, JA = np.vsplit(Jconst, 2)
Q1 = np.dot(Z, Jconst)
q1 = np.dot(JA, dth_flat)
q2 = np.dot(mm.getCrossMatrixForm(q1),
np.dot(mm.getCrossMatrixForm(q1), r))
yjc.computeJacobianDerivative2(dJconst, DOFs, jointPositions,
jointAxeses, linkAngVelocities,
[softConstPoint], constJointMasks,
False)
q_bias1 = np.dot(np.dot(Z, dJconst), dth_flat) + q2
##############################
flagContact = True
if dH_des == None or np.any(np.isnan(dH_des)) == True:
flagContact = False
viewer.doc.showRenderer('rd_grf_des', False)
viewer.motionViewWnd.update(1, viewer.doc)
else:
viewer.doc.showRenderer('rd_grf_des', True)
viewer.motionViewWnd.update(1, viewer.doc)
'''
0 : initial
1 : contact
2 : fly
3 : landing
'''
#MOTION = FORWARD_JUMP
if mit.MOTION == mit.FORWARD_JUMP:
frame_index = [136, 100]
#frame_index = [100000, 100000]
elif mit.MOTION == mit.TAEKWONDO:
frame_index = [130, 100]
#frame_index = [100000, 100000]
else:
frame_index = [1000000, 1000000]
#MOTION = TAEKWONDO
#frame_index = [135, 100]
'''
if frame > 300 :
if stage != DYNAMIC_BALANCING:
print("#", frame,"-DYNAMIC_BALANCING")
stage = DYNAMIC_BALANCING
Kk = Kk*1
Dk = 2*(Kk**.5)
'''
if frame > frame_index[0]:
if stage != POWERFUL_BALANCING:
print("#", frame, "-POWERFUL_BALANCING")
stage = POWERFUL_BALANCING
Kk = Kk * 2
Dk = 2 * (Kk**.5)
elif frame > frame_index[1]:
if stage != MOTION_TRACKING:
print("#", frame, "-MOTION_TRACKING")
stage = MOTION_TRACKING
trackingW = w
if stage == MOTION_TRACKING:
trackingW = w2
Bt = Bt * 2
# optimization
mot.addTrackingTerms(problem, totalDOF, Bt, trackingW, ddth_des_flat)
mot.addSoftPointConstraintTerms(problem, totalDOF, Bsc, ddP_des1, Q1,
q_bias1)
if flagContact == True:
if stage != MOTION_TRACKING + 10:
mot.addLinearTerms(problem, totalDOF, Bl, dL_des_plane, R,
r_bias)
mot.addAngularTerms(problem, totalDOF, Bh, dH_des, S, s_bias)
a_sup_2 = [None]
Jsup_2 = [None]
dJsup_2 = [None]
##############################
# Hard constraint
if stage != MOTION_TRACKING:
Kk2 = Kk * 2.0
else:
Kk2 = Kk * 1.5
Dk2 = 2 * (Kk2**.5)
'''
desLinearAccL, desPosL = getDesFootLinearAcc(motionModel, controlModel, supL, ModelOffset, CM_ref, CM, Kk2, Dk2)
desLinearAccR, desPosR = getDesFootLinearAcc(motionModel, controlModel, supR, ModelOffset, CM_ref, CM, Kk2, Dk2)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel, supL, Kk2, Dk2)
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel, supR, Kk2, Dk2)
'''
if stage != MOTION_TRACKING:
idx = 0 #LEFT/RIGHT_TOES
desLinearAccL, desPosL = getDesFootLinearAcc(
motionModel, controlModel, indexFootL[idx], ModelOffset,
CM_ref, CM, Kk2, Dk2)
desLinearAccR, desPosR = getDesFootLinearAcc(
motionModel, controlModel, indexFootR[idx], ModelOffset,
CM_ref, CM, Kk2, Dk2)
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel,
indexFootL[idx], Kk2, Dk2)
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel,
indexFootR[idx], Kk2, Dk2)
a_sup_2 = np.hstack((np.hstack((desLinearAccL, desAngularAccL)),
np.hstack((desLinearAccR, desAngularAccR))))
Jsup_2 = np.vstack((jFootL[idx], jFootR[idx]))
dJsup_2 = np.vstack((dJFootL[idx], dJFootR[idx]))
rd_DesPosL[0] = desPosL.copy()
rd_DesPosR[0] = desPosR.copy()
else:
if footPartNum != 1:
idx = 1
else:
idx = 0
desAngularAccL = getDesFootAngularAcc(motionModel, controlModel,
indexFootL[idx], Kk2, Dk2)
desAngularAccR = getDesFootAngularAcc(motionModel, controlModel,
indexFootR[idx], Kk2, Dk2)
a_sup_2 = np.hstack((desAngularAccL, desAngularAccR))
Jsup_2 = np.vstack((jAngFootL[idx], jAngFootR[idx]))
dJsup_2 = np.vstack((dJAngFootL[idx], dJAngFootR[idx]))
##############################
##############################
# Additional constraint
if stage != MOTION_TRACKING:
Kk2 = Kk * 1.5
Dk2 = 2 * (Kk2**.5)
desForePosL = [0, 0, 0]
desForePosR = [0, 0, 0]
desRearPosL = [0, 0, 0]
desRearPosR = [0, 0, 0]
for i in range(1, footPartNum):
if contactFlagFootL[i] == 1:
desLinearAccL, desForePosL = getDesFootLinearAcc(
motionModel, controlModel, indexFootL[i], ModelOffset,
CM_ref, CM, Kk2, Dk2)
desAngularAccL = getDesFootAngularAcc(
motionModel, controlModel, indexFootL[i], Kk2, Dk2)
a_sup_2 = np.hstack(
(a_sup_2, np.hstack((desLinearAccL, desAngularAccL))))
Jsup_2 = np.vstack((Jsup_2, jFootL[i]))
dJsup_2 = np.vstack((dJsup_2, dJFootL[i]))
if contactFlagFootR[i] == 1:
desLinearAccR, desForePosR = getDesFootLinearAcc(
motionModel, controlModel, indexFootR[i], ModelOffset,
CM_ref, CM, Kk2, Dk2)
desAngularAccR = getDesFootAngularAcc(
motionModel, controlModel, indexFootR[i], Kk2, Dk2)
a_sup_2 = np.hstack(
(a_sup_2, np.hstack((desLinearAccR, desAngularAccR))))
Jsup_2 = np.vstack((Jsup_2, jFootR[i]))
dJsup_2 = np.vstack((dJsup_2, dJFootR[i]))
rd_DesForePosL[0] = desForePosL
rd_DesForePosR[0] = desForePosR
rd_DesRearPosL[0] = desRearPosL
rd_DesRearPosR[0] = desRearPosR
##############################
mot.setConstraint(problem, totalDOF, Jsup_2, dJsup_2, dth_flat,
a_sup_2)
r = problem.solve()
problem.clear()
ype.nested(r['x'], ddth_sol)
rootPos[0] = controlModel.getBodyPositionGlobal(selectedBody)
localPos = [[0, 0, 0]]
for i in range(stepsPerFrame):
# apply penalty force
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(
bodyIDsToCheck, mus, Ks, Ds)
vpWorld.applyPenaltyForce(bodyIDs, contactPositionLocals,
contactForces)
extraForce[0] = viewer.GetForce()
if (extraForce[0][0] != 0 or extraForce[0][1] != 0
or extraForce[0][2] != 0):
forceApplyFrame += 1
#vpWorld.applyPenaltyForce(selectedBodyId, localPos, extraForce)
controlModel.applyBodyForceGlobal(selectedBody, extraForce[0])
applyedExtraForce[0] = extraForce[0]
if forceApplyFrame * wcfg.timeStep > 0.1:
viewer.ResetForce()
forceApplyFrame = 0
controlModel.setDOFAccelerations(ddth_sol)
controlModel.solveHybridDynamics()
'''
extraForce[0] = viewer.GetForce()
if (extraForce[0][0] != 0 or extraForce[0][1] != 0 or extraForce[0][2] != 0) :
forceApplyFrame += 1
vpWorld.applyPenaltyForce(selectedBodyId, localPos, extraForce)
applyedExtraForce[0] = extraForce[0]
if forceApplyFrame*wcfg.timeStep > 0.1:
viewer.ResetForce()
forceApplyFrame = 0
'''
vpWorld.step()
# rendering
rd_footCenter[0] = footCenter
rd_CM[0] = CM.copy()
rd_CM_plane[0] = CM_plane.copy()
rd_footCenter_ref[0] = footCenter_ref
rd_CM_plane_ref[0] = CM_ref.copy()
rd_CM_ref[0] = CM_ref.copy()
rd_CM_ref_vec[0] = (CM_ref - footCenter_ref) * 3.
rd_CM_vec[0] = (CM - footCenter) * 3
#rd_CM_plane[0][1] = 0.
if CP != None and dCP != None:
rd_CP[0] = CP
rd_CP_des[0] = CP_des
rd_dL_des_plane[0] = dL_des_plane
rd_dH_des[0] = dH_des
rd_grf_des[0] = totalNormalForce - totalMass * mm.s2v(
wcfg.gravity) #dL_des_plane - totalMass*mm.s2v(wcfg.gravity)
rd_exf_des[0] = applyedExtraForce[0]
rd_root_des[0] = rootPos[0]
rd_CMP[0] = softConstPoint
rd_soft_const_vec[0] = controlModel.getBodyPositionGlobal(
constBody) - softConstPoint
if (forceApplyFrame == 0):
applyedExtraForce[0] = [0, 0, 0]
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1 / 60.)
viewer.show()
Fl.run()
def test_momentum_matrix():
np.set_printoptions(precision=2, linewidth=200)
# bvhFilePath = '../samples/chain_1_long.bvh'
bvhFilePath = '../samples/chain_3_rotate.bvh'
motion1 = yf.readBvhFile(bvhFilePath)
mcfg1 = ypc.ModelConfig()
mcfg1.defaultDensity = 1000.
mcfg1.defaultBoneRatio = 1.
for i in range(motion1[0].skeleton.getElementNum()):
mcfg1.addNode(motion1[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
wcfg.gravity = (0, 0, 0)
stepsPerFrame = 30
wcfg.timeStep = (1 / 30.) / stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
m1 = cvm.VpControlModel(vpWorld, motion1[0], mcfg1)
vpWorld.initialize()
# momentum matrix information
masses = m1.getBodyMasses()
totalMass = m1.getTotalMass()
TO = make_TO(masses)
v_sol = ype.makeNestedList([6] * m1.getBodyNum())
# jacobian for internal joints
DOFs_internal = m1.getInternalJointDOFs()
totalDOF_internal = m1.getTotalInternalJointDOF()
J_internal = yjc.makeEmptyJacobian(DOFs_internal, m1.getBodyNum())
linkJointMasks_internal = yjc.getAllLinkInternalJointMasks(
motion1[0].skeleton)
dth_flat_internal = ype.makeFlatList(totalDOF_internal)
# momentum matrix for all joints
DOFs_all = m1.getDOFs()
totalDOF_all = m1.getTotalDOF()
J_all = yjc.makeEmptyJacobian(DOFs_all, m1.getBodyNum())
linkJointMasks_all = yjc.getAllLinkJointMasks(motion1[0].skeleton)
dth_flat_all = ype.makeFlatList(totalDOF_all)
p = []
v = []
rd_CM = []
rd_L_std = []
rd_L_jacob_internal = []
rd_L_jacob_all = []
rd_H_std = []
rd_H_jacob_internal = []
rd_H_jacob_all = []
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer(
'model', cvr.VpModelRenderer(m1, (255, 240, 255), yr.POLYGON_LINE))
# viewer.doc.addRenderer('v', yr.VectorsRenderer(v, p, (0,255,0)))
viewer.doc.addRenderer(
'L_std', yr.VectorsRenderer(rd_L_std, rd_CM, (255, 0, 0)))
# viewer.doc.addRenderer('L_jacob_internal', yr.VectorsRenderer(rd_L_jacob_internal, rd_CM, (0,255,0)))
viewer.doc.addRenderer(
'L_jacob_all',
yr.VectorsRenderer(rd_L_jacob_all, rd_CM, (255, 255, 0)))
viewer.doc.addRenderer(
'H_std', yr.VectorsRenderer(rd_H_std, rd_CM, (255, 0, 0)))
# viewer.doc.addRenderer('H_jacob_internal', yr.VectorsRenderer(rd_H_jacob_internal, rd_CM, (0,255,0)))
viewer.doc.addRenderer(
'H_jacob_all',
yr.VectorsRenderer(rd_H_jacob_all, rd_CM, (255, 255, 0)))
viewer.setMaxFrame(100)
# force
m1.applyBodyTorqueGlobal(0, (0, 0, 1000))
m1.applyBodyForceGlobal(0, (1000, 0, 0))
m1.applyBodyTorqueGlobal(0, (0, 1000, 0))
def simulateCallback(frame):
for i in range(stepsPerFrame):
vpWorld.step()
#===============================================================================
# momentum calculation by standard method
#===============================================================================
velocities = m1.getBodyVelocitiesGlobal()
positions = m1.getBodyPositionsGlobal()
CM = yrp.getCM(positions, masses, totalMass)
inertias = m1.getBodyInertiasGlobal()
angVelocities = m1.getBodyAngVelocitiesGlobal()
L_std = getLinearMomentum(masses, velocities)
H_std = getAngularMomentum(CM, inertias, angVelocities, positions,
masses, velocities)
#===============================================================================
# momentum calculation by centroidal momentum matrix
#===============================================================================
P = getPureInertiaMatrix(TO, masses, positions, CM, inertias)
# momentum matrix for internal joints and addition of total momentum about CM
# jointPositions_internal = m1.getInternalJointPositionsGlobal()
#
# Rs = m1.getInternalJointOrientationsGlobal()
# jointAxeses_internal = [Rs[i].transpose() for i in range(0,len(Rs))]
#
# yjc.computeJacobian2(J_internal, DOFs_internal, jointPositions_internal, jointAxeses_internal, positions, linkJointMasks_internal)
#
# dth = m1.getInternalJointAngVelocitiesLocal()
# ype.flatten(dth, dth_flat_internal)
#
# PJ_internal = np.dot(P, J_internal)
# LH_internal = np.dot(PJ_internal, dth_flat_internal)
# L2_jacob_internal, H2_jacob_internal = np.hsplit(LH_internal, 2)
#
# p_root = m1.getBodyPositionGlobal(0)
# v_root = m1.getBodyVelocityGlobal(0)
# w_root = m1.getBodyAngVelocityGlobal(0)
#
# L_jacob_internal = mm.v3(0.,0.,0.)
# L_jacob_internal += (totalMass * v_root)
# L_jacob_internal += (-totalMass * np.cross( (CM - p_root), w_root))
#
L_jacob_internal = None
H_jacob_internal = None
# momentum matrix for all joints
jointPositions_all = m1.getJointPositionsGlobal()
jointAxeses_all = m1.getDOFAxeses()
yjc.computeJacobian2(J_all, DOFs_all, jointPositions_all,
jointAxeses_all, positions,
linkJointMasks_all)
dth = m1.getDOFVelocities()
ype.flatten(dth, dth_flat_all)
PJ_all = np.dot(P, J_all)
LH_all = np.dot(PJ_all, dth_flat_all)
L_jacob_all, H_jacob_all = np.hsplit(LH_all, 2)
#===============================================================================
# for rendering
#===============================================================================
p[:] = positions
v[:] = velocities
rd_CM[:] = [CM]
rd_L_std[:] = [L_std]
rd_L_jacob_internal[:] = [L_jacob_internal]
rd_L_jacob_all[:] = [L_jacob_all]
rd_H_std[:] = [H_std]
rd_H_jacob_internal[:] = [H_jacob_internal]
rd_H_jacob_all[:] = [H_jacob_all]
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1 / 30.)
viewer.show()
Fl.run()
def main():
np.set_printoptions(precision=4, linewidth=200)
#motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_5()
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
mcfg_motion = mit.normal_mcfg()
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
motionModel.recordVelByFiniteDiff()
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
footPartNum = config['FootPartNum']
if footPartNum > 1:
elasticity = 2000
damping = 2 * (elasticity**.5)
springBody1 = 5
springBody2 = 6
springBody1Pos = motionModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]))
springBody2Pos = motionModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]))
initialDist = mm.length(springBody1Pos - springBody2Pos) * 1.
node = mcfg.getNode(mit.LEFT_PHALANGE_1)
initialDist -= node.width #0.084
v1 = (-node.width * 0.5, 0.0, node.length * 0.4)
v2 = (node.width * 0.5, 0.0, node.length * 0.4)
controlModel.setSpring(
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]),
motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]),
elasticity, damping, v2, v1, initialDist)
controlModel.setSpring(
motion[0].skeleton.getJointIndex(config['FootRPart'][springBody1]),
motion[0].skeleton.getJointIndex(config['FootRPart'][springBody2]),
elasticity, damping, v1, v2, initialDist)
#elasticity = 10
#damping = 2*(elasticity**.5)
#springBody1 = 3
#springBody2 = 4
#node = mcfg.getNode(mit.LEFT_PHALANGE_1)
#springBody1Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]))
#springBody2Pos = motionModel.getBodyPositionGlobal(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]))
#initialDist = mm.length(springBody1Pos - springBody2Pos)*1.
#initialDist -= node.width#0.084
#v1 = (-node.width*0.5,0.0,-node.length*0.4)
#v2 = (node.width*0.5,0.0,-node.length*0.4)
##controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootLPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootLPart'][springBody2]), elasticity, damping, v2, v1, initialDist)
##controlModel.setSpring(motion[0].skeleton.getJointIndex(config['FootRPart'][springBody1]), motion[0].skeleton.getJointIndex(config['FootRPart'][springBody2]), elasticity, damping, v1, v2, initialDist)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
#ModelOffset = (1.5, -0.01, 0)
ModelOffset = (1.5, 0.04, 0)
controlModel.translateByOffset(ModelOffset)
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
# parameter
Kt = config['Kt']
Dt = config['Dt'] # tracking gain
Kl = config['Kl']
Dl = config['Dl'] # linear balance gain
Kh = config['Kh']
Dh = config['Dh'] # angular balance gain
Ks = config['Ks']
Ds = config['Ds'] # penalty force spring gain
Bt = config['Bt']
Bl = config['Bl']
Bh = config['Bh']
w = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap'])
w2 = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap2'])
#w_IK = mot.getTrackingWeight(DOFs, motion[0].skeleton, config['IKweightMap'])
supL = motion[0].skeleton.getJointIndex(config['supLink'])
supR = motion[0].skeleton.getJointIndex(config['supLink2'])
rootB = motion[0].skeleton.getJointIndex(config['root'])
selectedBody = motion[0].skeleton.getJointIndex(config['end'])
#constBody = motion[0].skeleton.getJointIndex('LeftForeArm')
constBody = motion[0].skeleton.getJointIndex(config['const'])
# jacobian
Jsup = yjc.makeEmptyJacobian(DOFs, 1)
dJsup = Jsup.copy()
JsupPre = Jsup.copy()
Jsys = yjc.makeEmptyJacobian(DOFs, controlModel.getBodyNum())
dJsys = Jsys.copy()
JsysPre = Jsys.copy()
Jconst = yjc.makeEmptyJacobian(DOFs, 1)
dJconst = Jconst.copy()
Jcom = yjc.makeEmptyJacobian(DOFs, 1, False)
dJcom = Jcom.copy()
JcomAng = yjc.makeEmptyJacobian(DOFs, 1, False)
dJcomAng = JcomAng.copy()
###############
indexFootL = [None] * footPartNum
indexFootR = [None] * footPartNum
jFootL = [None] * footPartNum
dJFootL = [None] * footPartNum
jFootR = [None] * footPartNum
dJFootR = [None] * footPartNum
jointMasksFootL = [None] * footPartNum
jointMasksFootR = [None] * footPartNum
for i in range(footPartNum):
jFootL[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootL[i] = jFootL[i].copy()
jFootR[i] = yjc.makeEmptyJacobian(DOFs, 1)
dJFootR[i] = jFootR[i].copy()
indexFootL[i] = motion[0].skeleton.getJointIndex(
config['FootLPart'][i])
indexFootR[i] = motion[0].skeleton.getJointIndex(
config['FootRPart'][i])
jointMasksFootL[i] = [
yjc.getLinkJointMask(motion[0].skeleton, indexFootL[i])
]
jointMasksFootR[i] = [
yjc.getLinkJointMask(motion[0].skeleton, indexFootR[i])
]
constJointMasks = [
yjc.getLinksJointMask(motion[0].skeleton,
[indexFootL[0], indexFootR[0]])
]
#constJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [indexFootL[0]])]
#constJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, constBody)]
allLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)
#comLowerJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [motion[0].skeleton.getJointIndex('LeftLeg'), motion[0].skeleton.getJointIndex('RightLeg')])]
comUpperJointMasks = [
yjc.getLinkJointMask(motion[0].skeleton, selectedBody)
]
#comLowerJointMasks = [yjc.getLinksJointMask(motion[0].skeleton, [motion[0].skeleton.getJointIndex('LeftLeg'), motion[0].skeleton.getJointIndex('RightLeg')])]
comUpperJointMasks[0][0] = 0
#comUpperJointMasks[0][1] = 1
#comUpperJointMasks[0][10] = 1
comUpperJointMasks[0][2] = 1
comUpperJointMasks[0][11] = 1
#print(comUpperJointMasks)
comLowerJointMasks = [
yjc.getLinksJointMask(motion[0].skeleton, [
motion[0].skeleton.getJointIndex('LeftLeg'),
motion[0].skeleton.getJointIndex('RightLeg')
])
]
'''
maskArray = [foreSupLJointMasks, foreSupRJointMasks, rearSupLJointMasks, rearSupRJointMasks]
parentArray = [supL, supR, supL, supR]
effectorArray = [foreSupL, foreSupR, rearSupL, rearSupR]
for j in range(4) :
for i in range(len(foreSupLJointMasks)) :
if i == parentArray[j] or i == effectorArray[j] :
maskArray[j][0][i] = 1
else :
maskArray[j][0][i] = 0
'''
# momentum matrix
linkMasses = controlModel.getBodyMasses()
totalMass = controlModel.getTotalMass()
TO = ymt.make_TO(linkMasses)
dTO = ymt.make_dTO(len(linkMasses))
# optimization
problem = yac.LSE(totalDOF, 6)
a_sup = (0, 0, 0, 0, 0, 0) #L
#a_sup2 = (0,0,0, 0,0,0)#R
a_sup2 = [0, 0, 0, 0, 0, 0] #R
a_sup_2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
CP_old = [mm.v3(0., 0., 0.)]
# penalty method
bodyIDsToCheck = range(vpWorld.getBodyNum())
mus = [1.] * len(bodyIDsToCheck)
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
d_th_IK = ype.makeNestedList(DOFs)
d_th_IK_L = ype.makeNestedList(DOFs)
d_th_IK_R = ype.makeNestedList(DOFs)
dd_th_IK = ype.makeNestedList(DOFs)
dd_th_IK_flat = ype.makeFlatList(totalDOF)
d_th_IK_flat = ype.makeFlatList(totalDOF)
ddth_c_flat = ype.makeFlatList(totalDOF)
# viewer
rd_footCenter = [None]
rd_footCenter_ref = [None]
rd_footCenterL = [None]
rd_footCenterR = [None]
rd_CM_plane = [None]
rd_CM_plane_ref = [None]
rd_CM_ref = [None]
rd_CM_des = [None]
rd_CM = [None]
rd_CM_vec = [None]
rd_CM_ref_vec = [None]
rd_CP = [None]
rd_CP_des = [None]
rd_dL_des_plane = [None]
rd_dH_des = [None]
rd_grf_des = [None]
rd_footCenter_des = [None]
rd_exf_des = [None]
rd_root_des = [None]
rd_soft_const_vec = [None]
rd_root = [None]
rd_footL_vec = [None]
rd_footR_vec = [None]
rd_CMP = [None]
rd_DesPosL = [None]
rd_DesPosR = [None]
rd_DesForePosL = [None]
rd_DesForePosR = [None]
rd_DesRearPosL = [None]
rd_DesRearPosR = [None]
rd_Joint = [None]
rd_Joint2 = [None]
rd_Joint3 = [None]
rd_Joint4 = [None]
rd_desPoints = [None]
rd_contactForces = [None]
rd_contactPositions = [None]
#rd_contactForces = [None]*10000
#rd_contactPositions = [None]*10000
rd_virtualForce = [None]
rootPos = [None]
selectedBodyId = [selectedBody]
extraForce = [None]
applyedExtraForce = [None]
applyedExtraForce[0] = [0, 0, 0]
normalVector = [[0, 2, 0]]
if MULTI_VIEWER:
viewer = ymv.MultiViewer(800, 655)
#viewer = ymv.MultiViewer(1600, 1255)
viewer.setRenderers1([
cvr.VpModelRenderer(motionModel, CHARACTER_COLOR, yr.POLYGON_FILL)
])
viewer.setRenderers2([
cvr.VpModelRenderer(controlModel, CHARACTER_COLOR, yr.POLYGON_FILL)
])
else:
viewer = ysv.SimpleViewer()
# viewer.record(False)
# viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,255,255), yr.LINK_BONE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer(
'motionModel',
cvr.VpModelRenderer(motionModel, (100, 100, 100),
yr.POLYGON_FILL)) #(150,150,255)
viewer.doc.addRenderer(
'controlModel',
cvr.VpModelRenderer(controlModel, CHARACTER_COLOR,
yr.POLYGON_FILL))
#viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(controlModel, CHARACTER_COLOR, yr.POLYGON_LINE))
#viewer.doc.addRenderer('rd_footCenter', yr.PointsRenderer(rd_footCenter))
#viewer.doc.addRenderer('rd_footCenter_des', yr.PointsRenderer(rd_footCenter_des, (150,0,150)) )
#viewer.doc.addRenderer('rd_footCenterL', yr.PointsRenderer(rd_footCenterL))
#viewer.doc.addRenderer('rd_footCenterR', yr.PointsRenderer(rd_footCenterR))
viewer.doc.addRenderer('rd_CM_plane',
yr.PointsRenderer(rd_CM_plane, (255, 255, 0)))
viewer.doc.addRenderer('rd_CM',
yr.PointsRenderer(rd_CM, (255, 0, 255)))
viewer.doc.addRenderer('rd_CM_des',
yr.PointsRenderer(rd_CM_des, (64, 64, 255)))
viewer.doc.addRenderer(
'rd_CM_vec',
yr.VectorsRenderer(rd_CM_vec, rd_CM_plane, (255, 0, 0), 3))
#viewer.doc.addRenderer('rd_CP_des', yr.PointsRenderer(rd_CP_des, (0,255,0)))
viewer.doc.addRenderer('rd_CP_des',
yr.PointsRenderer(rd_CP_des, (255, 0, 128)))
# viewer.doc.addRenderer('rd_dL_des_plane', yr.VectorsRenderer(rd_dL_des_plane, rd_CM, (255,255,0)))
# viewer.doc.addRenderer('rd_dH_des', yr.VectorsRenderer(rd_dH_des, rd_CM, (0,255,0)))
#viewer.doc.addRenderer('rd_grf_des', yr.ForcesRenderer(rd_grf_des, rd_CP, (0,255,255), .001))
viewer.doc.addRenderer(
'rd_exf_des',
yr.ForcesRenderer(rd_exf_des, rd_root_des, (0, 255, 0), .009,
0.04))
#viewer.doc.addRenderer('rd_CMP', yr.PointsRenderer(rd_CMP, (0,0,255)))
#viewer.doc.addRenderer('rd_DesPosL', yr.PointsRenderer(rd_DesPosL, (0,0,255)))
#viewer.doc.addRenderer('rd_DesPosR', yr.PointsRenderer(rd_DesPosR, (0,100,255)))
#viewer.doc.addRenderer('rd_DesForePosL', yr.PointsRenderer(rd_DesForePosL, (150,0,200)))
#viewer.doc.addRenderer('rd_DesForePosR', yr.PointsRenderer(rd_DesForePosR, (150,0,250)))
#viewer.doc.addRenderer('rd_DesRearPosL', yr.PointsRenderer(rd_DesRearPosL, (0,150,200)))
#viewer.doc.addRenderer('rd_DesRearPosR', yr.PointsRenderer(rd_DesRearPosR, (0,150,250)))
#viewer.doc.addRenderer('softConstraint', yr.VectorsRenderer(rd_soft_const_vec, rd_CMP, (150,100,100), 3))
#viewer.doc.addRenderer('rd_footLVec', yr.VectorsRenderer(rd_footL_vec, rd_footCenterL, (255,0,0), 3))
#viewer.doc.addRenderer('rd_footRVec', yr.VectorsRenderer(rd_footR_vec, rd_footCenterR, (255,255,0), 3))
#viewer.doc.addRenderer('rd_footCenter_ref', yr.PointsRenderer(rd_footCenter_ref))
#viewer.doc.addRenderer('rd_CM_plane_ref', yr.PointsRenderer(rd_CM_plane_ref, (255,255,0)))
#viewer.doc.addRenderer('rd_refNormalVec', yr.VectorsRenderer(normalVector, rd_footCenter_ref, (255,0,0), 3))
#viewer.doc.addRenderer('rd_refCMVec', yr.VectorsRenderer(rd_CM_ref_vec, rd_footCenter_ref, (255,0,255), 3))
#viewer.doc.addRenderer('rd_curNormalVec', yr.VectorsRenderer(normalVector, rd_footCenter, (255,0,0), 3))
#viewer.doc.addRenderer('rd_CMVec', yr.VectorsRenderer(rd_CM_vec, rd_footCenter, (255,0,255), 3))
viewer.doc.addRenderer(
'rd_contactForces',
yr.VectorsRenderer(rd_contactForces, rd_contactPositions,
(0, 255, 0), .1))
#viewer.doc.addRenderer('rd_virtualForce', yr.ForcesRenderer(rd_virtualForce, rd_CM, (50,255,0), 0.5, 0.02))
#viewer.doc.addRenderer('rd_Joint', yr.PointsRenderer(rd_Joint, (255,0,0)))
#viewer.doc.addRenderer('rd_Joint2', yr.PointsRenderer(rd_Joint2, (0,255,0)))
#viewer.doc.addRenderer('rd_Joint3', yr.PointsRenderer(rd_Joint3, (0,0,255)))
#viewer.doc.addRenderer('rd_Joint4', yr.PointsRenderer(rd_Joint4, (255,255,0)))
#viewer.doc.addRenderer('rd_desPoints', yr.PointsRenderer(rd_desPoints, (255,0,0)))
stage = STATIC_BALANCING
contactRendererName = []
#for i in range (motion[0].skeleton.getJointNum()):
# print(i, motion[0].skeleton.getJointName(i))
print "(index, id, name)"
for i in range(controlModel.getBodyNum()):
print(i, controlModel.index2id(i), controlModel.index2name(i))
desCOMOffset = 0.0
pt = [0.]
timeReport = [0.] * 7
viewer.objectInfoWnd.comOffsetY.value(-0.05)
viewer.objectInfoWnd.comOffsetZ.value(0.00)
viewer.objectInfoWnd.begin()
viewer.objectInfoWnd.Bc = Fl_Value_Input(100, 450, 40, 10, 'Bc')
viewer.objectInfoWnd.Bc.value(0.1)
viewer.objectInfoWnd.end()
viewer.objectInfoWnd.labelKt.value(50)
viewer.objectInfoWnd.labelKk.value(17)
def simulateCallback(frame):
print "main:frame : ", frame
curTime = time.time()
if frame % 30 == 1: pt[0] = time.time()
global g_initFlag
global forceShowFrame
global forceApplyFrame
global JsysPre
global JsupPreL
global JsupPreR
global JsupPre
global softConstPoint
global stage
global contactRendererName
global desCOMOffset
motionModel.update(motion[0])
Kt, Kk, Kl, Kh, Ksc, Bt, Bl, Bh, B_CM, B_CMSd, B_Toe = viewer.GetParam(
)
Dt = 2 * (Kt**.5)
Dk = 2 * (Kk**.5)
Dl = 2 * (Kl**.5)
Dh = 2 * (Kh**.5)
Dsc = 2 * (Ksc**.5)
# tracking
th_r_ori = motion.getDOFPositions(frame)
th_r = copy.copy(th_r_ori)
############################
#Reference motion modulation
dCM_k = 10.
linkVelocities = controlModel.getBodyVelocitiesGlobal()
dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)
dCM_plane = copy.copy(dCM)
dCM_plane[1] = 0.
global leftHipTimer
if viewer.objectInfoWnd.onLeftHip:
leftHipTimer = 60
viewer.objectInfoWnd.onLeftHip = False
if leftHipTimer > 0:
viewer.objectInfoWnd.comOffsetX.value(
0.08 * np.sin(2 * 3.14 * leftHipTimer / 60.))
#viewer.objectInfoWnd.comOffsetZ.value(0.04*np.cos(2*3.14*leftHipTimer/90.))
#B_Hipd = viewer.objectInfoWnd.labelLeftHip.value()
#newR1 = mm.exp(mm.v3(0.0,1.0,0.0), 3.14*0.5*B_Hipd/100.)
#idx = motion[0].skeleton.getJointIndex('LeftUpLeg')
#th_r[idx] = np.dot(th_r[idx], newR1)
#idx = motion[0].skeleton.getJointIndex('RightUpLeg')
#th_r[idx] = np.dot(th_r[idx], newR1)
leftHipTimer -= 1
timeReport[0] += time.time() - curTime
curTime = time.time()
th = controlModel.getDOFPositions()
dth_r = motion.getDOFVelocities(frame)
dth = controlModel.getDOFVelocities()
ddth_r = motion.getDOFAccelerations(frame)
ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r,
Kt, Dt)
ddth_c = controlModel.getDOFAccelerations()
ype.flatten(ddth_des, ddth_des_flat)
ype.flatten(dth, dth_flat)
ype.flatten(ddth_c, ddth_c_flat)
# jacobian
refFootL = motionModel.getBodyPositionGlobal(supL)
refFootR = motionModel.getBodyPositionGlobal(supR)
positionFootL = [None] * footPartNum
positionFootR = [None] * footPartNum
for i in range(footPartNum):
positionFootL[i] = controlModel.getBodyPositionGlobal(
indexFootL[i])
positionFootR[i] = controlModel.getBodyPositionGlobal(
indexFootR[i])
linkPositions = controlModel.getBodyPositionsGlobal()
linkVelocities = controlModel.getBodyVelocitiesGlobal()
linkAngVelocities = controlModel.getBodyAngVelocitiesGlobal()
linkInertias = controlModel.getBodyInertiasGlobal()
jointPositions = controlModel.getJointPositionsGlobal()
jointAxeses = controlModel.getDOFAxeses()
CM = yrp.getCM(linkPositions, linkMasses, totalMass)
dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)
CM_plane = copy.copy(CM)
CM_plane[1] = 0.
dCM_plane = copy.copy(dCM)
dCM_plane[1] = 0.
linkPositions_ref = motionModel.getBodyPositionsGlobal()
linkVelocities_ref = motionModel.getBodyVelocitiesGlobal()
linkAngVelocities_ref = motionModel.getBodyAngVelocitiesGlobal()
linkInertias_ref = motionModel.getBodyInertiasGlobal()
CM_ref = yrp.getCM(linkPositions_ref, linkMasses, totalMass)
CM_plane_ref = copy.copy(CM_ref)
CM_plane_ref[1] = 0.
P = ymt.getPureInertiaMatrix(TO, linkMasses, linkPositions, CM,
linkInertias)
dP = ymt.getPureInertiaMatrixDerivative(dTO, linkMasses,
linkVelocities, dCM,
linkAngVelocities,
linkInertias)
timeReport[1] += time.time() - curTime
curTime = time.time()
yjc.computeJacobian2(Jsys, DOFs, jointPositions, jointAxeses,
linkPositions, allLinkJointMasks)
timeReport[2] += time.time() - curTime
curTime = time.time()
# yjc.computeJacobianDerivative2(dJsys, DOFs, jointPositions, jointAxeses, linkAngVelocities, linkPositions, allLinkJointMasks)
if frame > 0:
dJsys = (Jsys - JsysPre) * 30.
else:
dJsys = (Jsys - Jsys)
JsysPre = Jsys.copy()
timeReport[3] += time.time() - curTime
curTime = time.time()
lcpBodyIDs, lcpContactPositions, lcpContactPositionLocals, lcpContactForces = hls.calcLCPForces(
motion, vpWorld, controlModel, bodyIDsToCheck, 1., 4, None)
# bodyIDs : IDs for Virtual Physics, not VpModel !!!
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(
bodyIDsToCheck, mus, Ks, Ds)
CP = yrp.getCP(contactPositions, contactForces)
if (CP is not None):
CP[1] = 0.
for i in range(controlModel.getBodyNum()):
controlModel.SetBodyColor(bodyIDsToCheck[i], 0, 0, 0, 255)
contactFlagFootL = [0] * footPartNum
contactFlagFootR = [0] * footPartNum
for i in range(len(bodyIDs)):
controlModel.SetBodyColor(bodyIDs[i], 255, 105, 105, 200)
index = controlModel.id2index(bodyIDs[i])
for j in range(len(indexFootL)):
if index == indexFootL[j]:
contactFlagFootL[j] = 1
for j in range(len(indexFootR)):
if index == indexFootR[j]:
contactFlagFootR[j] = 1
for j in range(0, footPartNum):
jFootR[j] = Jsys[6 * indexFootR[j]:6 * indexFootR[j] + 6] #.copy()
jFootL[j] = Jsys[6 * indexFootL[j]:6 * indexFootL[j] + 6] #.copy()
dJFootR[j] = dJsys[6 * indexFootR[j]:6 * indexFootR[j] +
6] #.copy()
dJFootL[j] = dJsys[6 * indexFootL[j]:6 * indexFootL[j] +
6] #.copy()
if footPartNum == 1:
desFCL = (controlModel.getBodyPositionGlobal(supL))
desFCR = (controlModel.getBodyPositionGlobal(supR))
else:
r = .5 + desCOMOffset
desFCL = (controlModel.getBodyPositionGlobal(indexFootL[0]) * r +
controlModel.getBodyPositionGlobal(indexFootL[1]) *
(1.0 - r)
) #controlModel.getBodyPositionGlobal(indexFootL[1])
desFCR = (controlModel.getBodyPositionGlobal(indexFootR[0]) * r +
controlModel.getBodyPositionGlobal(indexFootR[1]) *
(1.0 - r)
) #controlModel.getBodyPositionGlobal(indexFootR[1])
desFC = desFCL + (desFCR - desFCL) / 2.0
desFC[1] = 0
rd_footCenter_des[0] = desFC.copy()
curRelCMVec = CM_plane - desFC
vecRatio = mm.length(curRelCMVec) * 0.
#print(frame, vecRatio)
footCenter = desFC - curRelCMVec * (vecRatio) #/10.0
footCenter = (
getBodyGlobalPos(controlModel, motion, 'LeftCalcaneus_1') +
getBodyGlobalPos(controlModel, motion, 'LeftPhalange_1') +
getBodyGlobalPos(controlModel, motion, 'RightCalcaneus_1') +
getBodyGlobalPos(controlModel, motion, 'RightPhalange_1')) / 4.
#footCenter = (getBodyGlobalPos(controlModel, motion, 'LeftCalcaneus_1') + getBodyGlobalPos(controlModel, motion, 'LeftTalus_1') + getBodyGlobalPos(controlModel, motion, 'RightCalcaneus_1') + getBodyGlobalPos(controlModel, motion, 'RightTalus_1'))/4.
footCenter_ref = refFootL + (refFootR - refFootL) / 2.0
#footCenter_ref[1] = 0.
footCenter[1] = 0.
footCenterOffset = np.array([
viewer.objectInfoWnd.comOffsetX.value(), 0,
viewer.objectInfoWnd.comOffsetZ.value()
])
#footCenter += footCenterOffset
vecRatio = mm.length(curRelCMVec) * 0.
softConstPointOffset = -curRelCMVec * (vecRatio) #/10.0
#print(frame, vecRatio, softConstPointOffset)
desForeSupLAcc = [0, 0, 0]
desForeSupRAcc = [0, 0, 0]
totalNormalForce = [0, 0, 0]
for i in range(len(contactForces)):
totalNormalForce[0] += contactForces[i][0]
totalNormalForce[1] += contactForces[i][1]
totalNormalForce[2] += contactForces[i][2]
#print((totalMass*mm.s2v(wcfg.gravity))[1])
footCenterOffset = np.array([
viewer.objectInfoWnd.comOffsetX.value(),
viewer.objectInfoWnd.comOffsetY.value(),
viewer.objectInfoWnd.comOffsetZ.value()
])
######################
# optimization terms
######################
# linear momentum
CM_ref_plane = footCenter + footCenterOffset
dL_des_plane = Kl * totalMass * (CM_ref_plane -
CM_plane) - Dl * totalMass * dCM_plane
dL_des_plane[1] = Kl * totalMass * (CM_ref[1] + footCenterOffset[1] -
CM[1]) - Dl * totalMass * dCM[1]
#dL_des_plane[1] = 0.
#print 'dL_des_plane', dL_des_plane
# angular momentum
CP_ref = footCenter + footCenterOffset
CP_ref[1] = 0.
timeStep = 30.
if (CP_old[0] is None) or (CP is None):
dCP = None
else:
dCP = (CP - CP_old[0]) * timeStep
CP_old[0] = CP
if (CP is not None) and (dCP is not None):
ddCP_des = Kh * (CP_ref - CP) - Dh * (dCP)
CP_des = CP + dCP * (1 / timeStep) + .5 * ddCP_des * (
(1 / timeStep)**2)
#print 'dCP: ', dCP
#print 'ddCP_des: ', ddCP_des
#print 'CP_des: ', CP_des
#dH_des = np.cross((CP_des - CM), (dL_des_plane + totalMass*mm.s2v(wcfg.gravity)))
dH_des = np.cross(
(CP_des - CM_plane),
(dL_des_plane + totalMass * mm.s2v(wcfg.gravity)))
else:
dH_des = None
# momentum matrix
RS = np.dot(P, Jsys)
R, S = np.vsplit(RS, 2)
rs = np.dot((np.dot(dP, Jsys) + np.dot(P, dJsys)), dth_flat)
r_bias, s_bias = np.hsplit(rs, 2)
flagContact = True
if (dH_des is None) or np.any(np.isnan(dH_des)) == True:
flagContact = False
#viewer.doc.showRenderer('rd_grf_des', False)
#viewer.motionViewWnd.update(1, viewer.doc)
#else:
#viewer.doc.showRenderer('rd_grf_des', True)
#viewer.motionViewWnd.update(1, viewer.doc)
'''
0 : initial
1 : contact
2 : fly
3 : landing
'''
#MOTION = FORWARD_JUMP
if mit.MOTION == mit.FORWARD_JUMP:
frame_index = [136, 100]
#frame_index = [100000, 100000]
elif mit.MOTION == mit.TAEKWONDO:
frame_index = [130, 100]
#frame_index = [100000, 100000]
elif mit.MOTION == mit.TAEKWONDO2:
frame_index = [130 + 40, 100]
elif mit.MOTION == mit.WALK:
frame_index = [10000, 60]
elif mit.MOTION == mit.TIPTOE:
frame_index = [1000000, 1000000]
#frame_index = [10000, 165]
else:
frame_index = [1000000, 1000000]
#MOTION = TAEKWONDO
#frame_index = [135, 100]
if frame > frame_index[0]:
if stage != POWERFUL_BALANCING:
print("#", frame, "-POWERFUL_BALANCING")
stage = POWERFUL_BALANCING
Kk = Kk * 2
Dk = 2 * (Kk**.5)
elif frame > frame_index[1]:
if stage != MOTION_TRACKING:
print("#", frame, "-MOTION_TRACKING")
stage = MOTION_TRACKING
trackingW = w
#if checkAll(contactFlagFootR, 0) != 1 :
if 0: #stage == MOTION_TRACKING:
trackingW = w2
#stage = POWERFUL_BALANCING
Bt = Bt * 2
# optimization
mot.addTrackingTerms(problem, totalDOF, Bt, trackingW, ddth_des_flat)
#mot.addSoftPointConstraintTerms(problem, totalDOF, Bsc, ddP_des1, Q1, q_bias1)
if flagContact == True:
if stage != MOTION_TRACKING + 10:
mot.addLinearTerms(problem, totalDOF, Bl, dL_des_plane, R,
r_bias)
#mot.addAngularTerms(problem, totalDOF, Bh, dH_des, S, s_bias)
# using || dH ||^2 instead
mot.addAnotherTerms(problem, totalDOF, Bh, S,
-(s_bias + Kh * np.dot(S, dth_flat)))
a_sup_2 = None
Jsup_2 = None
dJsup_2 = None
##############################
# Hard constraint
Kk2 = Kk * 4.0
Dk2 = 2 * (Kk2**.5)
ankleW = 0
ankleOffset = ankleW * curRelCMVec[2]
metatarW = 0
metatarOffset = metatarW * curRelCMVec[2]
##############################
##############################
# Additional constraint
if stage != MOTION_TRACKING and frame > 5:
# ankle strategy
idx = 0 #LEFT/RIGHT_TOES
if mit.FOOT_PART_NUM == 1:
yOffset = 0.03
else:
yOffset = 0.069
#yOffset = 0.06
# ankleOffset = (footCenter - CM_plane)*4.
ankleOffset = footCenterOffset * 10.
ankleOffset[1] = 0.
#ankleOffset[2] = 0.
ankleOffset[2] = ankleOffset[2] * 20.
ankleOffsetL = ankleOffset.copy()
ankleOffsetR = ankleOffset.copy()
#ankleOffset= np.array((0,0,0))
if footCenterOffset[0] > 0.0:
ankleOffsetL[0] = 0.
else:
ankleOffsetR[0] = 0.
# print 'ankleOffset=', ankleOffset
desLinearAccL, desPosL = getDesFootLinearAcc(
motionModel, controlModel, indexFootL[idx], ModelOffset,
CM_ref, CM, Kk, Dk, yOffset) #0.076) #0.14)
desLinearAccR, desPosR = getDesFootLinearAcc(
motionModel, controlModel, indexFootR[idx], ModelOffset,
CM_ref, CM, Kk, Dk, yOffset)
ax = [0, 0, -1]
aaa = getBodyGlobalOri(controlModel, motion, 'RightFoot')
#print np.dot(aaa, ax)
if mit.FOOT_PART_NUM == 1:
ax = [0, 1, 0]
desAngularAccL = getDesFootAngularAcc(
motionModel, controlModel, indexFootL[idx], Kk, Dk, ax,
mm.normalize([0, 1, 0] + ankleOffsetL))
desAngularAccR = getDesFootAngularAcc(
motionModel, controlModel, indexFootR[idx], Kk, Dk, ax,
mm.normalize([0, 1, 0] + ankleOffsetR))
a_sup_2 = np.hstack((np.hstack((desLinearAccL, desAngularAccL)),
np.hstack((desLinearAccR, desAngularAccR))))
Jsup_2 = np.vstack((jFootL[idx], jFootR[idx]))
dJsup_2 = np.vstack((dJFootL[idx], dJFootR[idx]))
#mot.addConstraint(problem, totalDOF, Jsup_2, dJsup_2, dth_flat, a_sup_2)
#mot.addConstraint(problem, totalDOF, Jsup_2[:1], dJsup_2[:1], dth_flat, a_sup_2[:1])
#mot.addConstraint(problem, totalDOF, Jsup_2[2:], dJsup_2[2:], dth_flat, a_sup_2[2:])
#mot.addConstraint(problem, totalDOF, Jsup_2[3:], dJsup_2[3:], dth_flat, a_sup_2[3:])
mot.addAnotherTerms(problem, totalDOF,
viewer.objectInfoWnd.Bc.value(), Jsup_2[3:],
a_sup_2[3:] - np.dot(dJsup_2[3:], dth_flat))
#mot.addAnotherTerms(problem, totalDOF, viewer.objectInfoWnd.Bc.value(), Jsup_2, a_sup_2 - np.dot(dJsup_2, dth_flat))
#mot.addAnotherTerms(problem, totalDOF, 1.*viewer.objectInfoWnd.Bc.value(), Jsup_2[0:1], a_sup_2[0:1] - np.dot(dJsup_2[0:1] , dth_flat))
#mot.addAnotherTerms(problem, totalDOF, 1.*viewer.objectInfoWnd.Bc.value(), Jsup_2[2:], a_sup_2[2:] - np.dot(dJsup_2[2:] , dth_flat))
desCOMOffset = 0.0
rd_DesPosL[0] = desPosL.copy()
rd_DesPosR[0] = desPosR.copy()
if stage == STATIC_BALANCING and frame > 10: # and False:
del rd_desPoints[:]
# foot strategy
#Kk2 = Kk * 2.5
#Kk2 = Kk * .2
#Dk2 = 2*(Kk2**.5)
desForePosL = [0, 0, 0]
desForePosR = [0, 0, 0]
desRearPosL = [0, 0, 0]
desRearPosR = [0, 0, 0]
footPartPos = []
footPartPos.append(
controlModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex('LeftCalcaneus_1')))
footPartPos.append(
controlModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex('LeftPhalange_1')))
footPartPos.append(
controlModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex('RightCalcaneus_1')))
footPartPos.append(
controlModel.getBodyPositionGlobal(
motion[0].skeleton.getJointIndex('RightPhalange_1')))
for i in range(1, footPartNum):
contactFlagFootL[i] = 1
contactFlagFootR[i] = 1
SupPts = np.vstack(
(np.array((footPartPos[0][0], footPartPos[1][0],
footPartPos[2][0], footPartPos[3][0])),
np.array(
(footPartPos[0][2], footPartPos[1][2], footPartPos[2][2],
footPartPos[3][2])), np.array((1., 1., 1., 1.))))
coordWidthLen = 2.
coordLengthLen = 1.5
SupUV = np.vstack(
(np.array((-coordWidthLen, -coordWidthLen, coordWidthLen,
coordWidthLen)),
np.array((-coordLengthLen, coordLengthLen, -coordLengthLen,
coordLengthLen)), np.array((1., 1., 1., 1.))))
SupMap = np.dot(np.dot(SupUV, SupUV.T),
np.linalg.inv(np.dot(SupPts, SupUV.T)))
#print SupMap
desFootCenter = footCenter + footCenterOffset
footCenterPts = np.array((desFootCenter[0], desFootCenter[2], 1))
#print np.dot(SupMap, footCenterPts)
#print np.dot(getBodyGlobalOri(controlModel, motion, 'LeftMetatarsal_1'), np.array((0,1,0)))
CM_plane_2D = np.array((CM[0], CM[2], 1))
# CM_plane_UV = np.dot(SupMap, CM_plane_2D)
CM_plane_UV = np.dot(SupMap, footCenterPts)
# print CM_plane_UV
# for i in range(1, footPartNum):
if CM_plane_UV[1] > .5:
# com is in front
for i in range(1, 5):
contactFlagFootL[i] = 0
contactFlagFootR[i] = 0
elif CM_plane_UV[1] < -.5:
# com is back
for i in range(3, footPartNum):
contactFlagFootL[i] = 0
contactFlagFootR[i] = 0
else:
# com is in middle position
for i in range(3, 5):
contactFlagFootL[i] = 0
contactFlagFootR[i] = 0
contactFlagFoot = contactFlagFootL
if CM_plane_UV[0] < 0.:
contactFlagFoot = contactFlagFootR
# CM_plane_UV[0] = -CM_plane_UV[0]
if abs(CM_plane_UV[0]) > 1.:
for j in range(0, 3):
contactFlagFoot[2 * j + 2] = 0
# print 'footL : ',contactFlagFootL
# print 'footR : ',contactFlagFootR
for i in range(1, footPartNum):
axis = [0, 0, 1]
if i == 1 or i == 2:
axis = [0, 0, -1]
desAng = [0, 0, 1]
if i == 1 or i == 2:
desAng = [0, 0, -1]
desY = 0.029
if contactFlagFootL[i] == 1:
desLinearAccL, desForePosL = getDesFootLinearAcc(
motionModel, controlModel, indexFootL[i], ModelOffset,
CM_ref, CM, Kk2, Dk2, desY)
desAngularAccL = getDesFootAngularAcc(
motionModel, controlModel, indexFootL[i], Kk2, Dk2,
axis, desAng)
a_sup_2 = np.hstack((desLinearAccL, desAngularAccL))
Jsup_2 = jFootL[i].copy()
dJsup_2 = dJFootL[i].copy()
mot.addConstraint(problem, totalDOF, Jsup_2, dJsup_2,
dth_flat, a_sup_2)
#mot.addAnotherTerms(problem, totalDOF, viewer.objectInfoWnd.Bc.value(), Jsup_2, a_sup_2 - np.dot(dJsup_2, dth_flat))
#mot.addAnotherTerms(problem, totalDOF, viewer.objectInfoWnd.Bc.value(), Jsup_2[3:], a_sup_2[3:] - np.dot(dJsup_2[3:] , dth_flat))
rd_desPoints.append(desForePosL.copy())
if contactFlagFootR[i] == 1:
desLinearAccR, desForePosR = getDesFootLinearAcc(
motionModel, controlModel, indexFootR[i], ModelOffset,
CM_ref, CM, Kk2, Dk2, desY)
desAngularAccR = getDesFootAngularAcc(
motionModel, controlModel, indexFootR[i], Kk2, Dk2,
axis, desAng)
a_sup_2 = np.hstack((desLinearAccR, desAngularAccR))
Jsup_2 = jFootR[i].copy()
dJsup_2 = dJFootR[i].copy()
mot.addConstraint(problem, totalDOF, Jsup_2, dJsup_2,
dth_flat, a_sup_2)
#mot.addAnotherTerms(problem, totalDOF, viewer.objectInfoWnd.Bc.value(), Jsup_2, a_sup_2 - np.dot(dJsup_2, dth_flat))
#mot.addAnotherTerms(problem, totalDOF, viewer.objectInfoWnd.Bc.value(), Jsup_2[3:], a_sup_2[3:] - np.dot(dJsup_2[3:], dth_flat))
rd_desPoints.append(desForePosR.copy())
rd_DesForePosL[0] = desForePosL
rd_DesForePosR[0] = desForePosR
rd_DesRearPosL[0] = desRearPosL
rd_DesRearPosR[0] = desRearPosR
##############################
#if Jsup_2 is not None:
# mot.addConstraint(problem, totalDOF, Jsup_2, dJsup_2, dth_flat, a_sup_2)
timeReport[4] += time.time() - curTime
curTime = time.time()
r = problem.solve()
#print frame
#Ashape = np.shape(problem.A)
#if len(Ashape) >0 :
# for i in range(0, Ashape[0]):
# print problem.A[i]
#print problem.A[]
#print problem.b
#print r
problem.clear()
#print r['x']
ype.nested(r['x'], ddth_sol)
#print ddth_sol
rootPos[0] = controlModel.getBodyPositionGlobal(selectedBody)
localPos = [[0, 0, 0]]
###########################################
##Jacobian Transpose control
# COM Position control
#fCom = Wcp*(pHatComDes - pHatCom) + Wcv*(vComDes - vCom) + Wcm*(footCenter_plane - CM_plane)
w1 = 10 #10.1
w2 = 1 #1#2*(w1**.5)
if frame > 100:
w1 = 10.1 #10.1
w2 = 1
footToCMVec = CM - footCenter
desCMPos = [footCenter[0], mm.length(footToCMVec), footCenter[2]]
#print("desCMPos", desCMPos)
#print("CM", CM)
fCom = w1 * (desCMPos - CM) + w2 * (-dCM)
#print("fCom", fCom)
#fCom[0] = 0.
#fCom[1] = 0
#fCom[2] = 0
rd_virtualForce[0] = fCom.copy()
#hipPos = controlModel.getBodyPositionGlobal(rootB)
headPos = controlModel.getBodyPositionGlobal(selectedBody)
hipPos = controlModel.getBodyPositionGlobal(rootB)
yjc.computeJacobian2(Jcom, DOFs, jointPositions, jointAxeses,
[headPos], comUpperJointMasks)
#yjc.computeJacobianDerivative2(dJcom, DOFs, jointPositions, jointAxeses, linkAngVelocities, [CM], comUpperJointMasks, False)
JcomT = Jcom.T
TauJT = np.dot(JcomT, fCom)
# Angular Momentum
Hc = ymt.getAngularMomentum(CM, linkInertias, linkAngVelocities,
linkPositions, linkMasses, linkVelocities)
Href = ymt.getAngularMomentum(CM_ref, linkInertias_ref,
linkAngVelocities_ref, linkPositions_ref,
linkMasses, linkVelocities_ref)
Wam = .05
Tam = Wam * (Href - Hc)
#print("Tam", Tam)
yjc.computeAngJacobian2(JcomAng, DOFs, jointPositions, jointAxeses,
[headPos], comUpperJointMasks)
TauAM = np.dot(JcomAng.T, Tam)
timeReport[5] += time.time() - curTime
curTime = time.time()
for i in range(stepsPerFrame):
# apply penalty force
bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(
bodyIDsToCheck, mus, Ks, Ds)
#print frame, bodyIDs, contactPositions, contactPositionLocals, contactForces
vpWorld.applyPenaltyForce(bodyIDs, contactPositionLocals,
contactForces)
extraForce[0] = viewer.GetForce()
if (extraForce[0][0] != 0 or extraForce[0][1] != 0
or extraForce[0][2] != 0):
forceApplyFrame += 1
#vpWorld.applyPenaltyForce(selectedBodyId, localPos, extraForce)
controlModel.applyBodyForceGlobal(selectedBody, extraForce[0])
applyedExtraForce[0] = extraForce[0]
if forceApplyFrame * wcfg.timeStep > 0.1:
viewer.ResetForce()
forceApplyFrame = 0
#print ddth_sol
controlModel.setDOFAccelerations(ddth_sol)
controlModel.solveHybridDynamics()
vpWorld.step()
#if frame%30==0: print 'elapsed time for 30 frames:', time.time()-pt[0]
# rendering
rd_footCenter[0] = footCenter
rd_CM[0] = CM.copy()
rd_CM_plane[0] = CM_plane.copy()
rd_footCenter_ref[0] = footCenter_ref
rd_CM_plane_ref[0] = CM_ref.copy()
rd_CM_ref[0] = CM_ref.copy()
rd_CM_ref_vec[0] = (CM_ref - footCenter_ref) * 3.
rd_CM_vec[0] = (CM - CM_plane)
rd_CM_des[0] = CM_ref_plane.copy()
rd_CM_des[0][1] = .01
#rd_CM_plane[0][1] = 0.
if (CP is not None) and (dCP is not None):
rd_CP[0] = CP
rd_CP_des[0] = CP_des
rd_dL_des_plane[0] = dL_des_plane
rd_dH_des[0] = dH_des
rd_grf_des[
0] = totalNormalForce # - totalMass*mm.s2v(wcfg.gravity)#dL_des_plane - totalMass*mm.s2v(wcfg.gravity)
rd_exf_des[0] = applyedExtraForce[0]
rd_root_des[0] = rootPos[0]
rd_CMP[0] = softConstPoint
rd_soft_const_vec[0] = controlModel.getBodyPositionGlobal(
constBody) - softConstPoint
del rd_contactForces[:]
del rd_contactPositions[:]
if CP is not None:
for i in range(len(lcpBodyIDs)):
rd_contactForces.append(lcpContactForces[i].copy() / 200.)
rd_contactPositions.append(lcpContactPositions[i].copy())
timeReport[6] += time.time() - curTime
# print timeReport
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1 / 30.)
viewer.show()
Fl.run()
def init():
global motion
global mcfg
global wcfg
global stepsPerFrame
global config
global mcfg_motion
global vpWorld
global controlModel
global totalDOF
global DOFs
global bodyIDsToCheck
global torques_nested
global ddth_des_flat
global dth_flat
global ddth_sol
global rd_cForces
global rd_cPositions
global rd_jointPos
global rd_cForcesControl
global rd_cPositionsControl
global rd_ForceControl
global rd_ForceDes
global rd_Position
global rd_PositionDes
global viewer
global motionModel
global solver
global IKModel
np.set_printoptions(precision=4, linewidth=200)
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_1()
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_vchain_5()
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_biped()
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_chiken_foot()
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_foot('fastswim.bvh')
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_foot_2('simpleJump_2.bvh')
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_capsule('simpleJump_onebody.bvh')
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_foot('simpleJump.bvh')
# motion, mcfg, wcfg, stepsPerFrame, config = mit.create_foot('simpleJump_long.bvh')
motion, mcfg, wcfg, stepsPerFrame, config = mit.create_legs('legs_robust.bvh')
mcfg_motion = mit.normal_mcfg()
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
IKModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
solver = hik.numIkSolver(wcfg, motion[0], mcfg)
# vpWorld.SetIntegrator("RK4")
# vpWorld.SetIntegrator("IMPLICIT_EULER_FAST")
vpWorld.SetIntegrator("EULER")
vpWorld.SetGlobalDamping(0.9999)
# controlModel.initializeHybridDynamics()
controlModel.initializeForwardDynamics()
ModelOffset = np.array([0., 2.5, 0.])
controlModel.translateByOffset(ModelOffset)
motionModel.translateByOffset(ModelOffset)
vpWorld.initialize()
totalDOF = controlModel.getTotalDOF()
DOFs = controlModel.getDOFs()
bodyIDsToCheck = range(vpWorld.getBodyNum())
# flat data structure
ddth_des_flat = ype.makeFlatList(totalDOF)
dth_flat = ype.makeFlatList(totalDOF)
ddth_sol = ype.makeNestedList(DOFs)
torques_nested = ype.makeNestedList(DOFs)
rd_cForces = [None]
rd_cPositions = [None]
rd_cForcesControl = [None]
rd_cPositionsControl = [None]
rd_ForceControl = [None]
rd_ForceDes = [None]
rd_Position = [None]
rd_PositionDes = [None]
rd_jointPos = [None]
viewer = hsv.hpSimpleViewer(title='main_Test')
viewer.doc.addObject('motion', motion)
# viewer.doc.addRenderer('motionModel', cvr.VpModelRenderer(
# motionModel, MOTION_COLOR, yr.POLYGON_FILL))
# viewer.doc.addRenderer('IKModel', cvr.VpModelRenderer(
# solver.model, MOTION_COLOR, yr.POLYGON_FILL))
viewer.doc.addRenderer('controlModel', cvr.VpModelRenderer(
controlModel, CHARACTER_COLOR, yr.POLYGON_FILL))
viewer.doc.addRenderer('rd_contactForcesControl', yr.VectorsRenderer(
rd_cForcesControl, rd_cPositionsControl, (255, 0, 0), .1))
viewer.doc.addRenderer('rd_contactForces', yr.VectorsRenderer(
rd_cForces, rd_cPositions, (0, 255, 0), .1))
viewer.doc.addRenderer('rd_contactForceControl', yr.VectorsRenderer(
rd_ForceControl, rd_Position, (0, 0, 255), .1))
viewer.doc.addRenderer('rd_contactForceDes', yr.VectorsRenderer(
rd_ForceDes, rd_PositionDes, (255, 0, 255), .1))
# viewer.doc.addRenderer('rd_jointPos', yr.PointsRenderer(rd_jointPos))
viewer.objectInfoWnd.add1DSlider(
'PD gain', minVal=0., maxVal=500., initVal=10., valStep=.1)
viewer.objectInfoWnd.add1DSlider(
'Joint Damping', minVal=1., maxVal=2000., initVal=35., valStep=1.)
viewer.objectInfoWnd.add1DSlider(
'steps per frame', minVal=1., maxVal=200., initVal=config['stepsPerFrame'], valStep=1.)
viewer.objectInfoWnd.add1DSlider(
'1/simul speed', minVal=1., maxVal=100., initVal=config['simulSpeedInv'], valStep=1.)
viewer.objectInfoWnd.add1DSlider(
'normal des force min', minVal=0., maxVal=1000., initVal=80., valStep=1.)
viewer.objectInfoWnd.add1DSlider(
'normal des force max', minVal=0., maxVal=1000., initVal=80., valStep=1.)
viewer.objectInfoWnd.add1DSlider(
'des force begin', minVal=0., maxVal=len(motion) - 1, initVal=70., valStep=1.)
viewer.objectInfoWnd.add1DSlider(
'des force dur', minVal=1., maxVal=len(motion) - 1, initVal=5., valStep=1.)
viewer.objectInfoWnd.add1DSlider(
'force weight', minVal=-10., maxVal=10., initVal=0., valStep=.01)
viewer.objectInfoWnd.add1DSlider(
'LCP weight', minVal=-10., maxVal=10., initVal=0., valStep=.01)
viewer.objectInfoWnd.add1DSlider(
'tau weight', minVal=-10., maxVal=10., initVal=0., valStep=.01)
viewer.objectInfoWnd.addBtn('image', viewer.motionViewWnd.dump)
viewer.objectInfoWnd.addBtn('image seq dump', viewer.motionViewWnd.dumpMov)
viewer.cForceWnd.addDataSet('expForce', FL_BLACK)
viewer.cForceWnd.addDataSet('desForceMin', FL_RED)
viewer.cForceWnd.addDataSet('desForceMax', FL_RED)
viewer.cForceWnd.addDataSet('realForce', FL_GREEN)
for i in range(motion[0].skeleton.getJointNum()):
print(i, motion[0].skeleton.getJointName(i))
print("(index, id, name)")
for i in range(controlModel.getBodyNum()):
print(i, controlModel.index2id(i), controlModel.index2name(i))
def test_getDesiredAngAccelerations():
# motion = yf.readBvhFile('block_3_rotate.bvh', 1)
motion = yf.readBvhFile('../samples/block_tree_rotate.bvh', 1)
motion = motion[0:]
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
wcfg.gravity = (0, 0, 0)
stepsPerFrame = 30
wcfg.timeStep = (1 / 30.) / stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
motionModel = cvm.VpMotionModel(vpWorld, motion[0], mcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics()
controlModel.fixBody(0)
p = []
ddth_des = []
viewer = ysv.SimpleViewer()
# viewer.record(False)
viewer.doc.addRenderer(
'motion',
yr.JointMotionRenderer(motion, (0, 255, 255), yr.LINK_BONE))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer(
'motionModel',
cvr.VpModelRenderer(motionModel, (255, 240, 255), yr.POLYGON_LINE))
viewer.doc.addRenderer(
'controlModel',
cvr.VpModelRenderer(controlModel, (255, 240, 255),
yr.POLYGON_FILL))
viewer.doc.addRenderer('ddth_des',
yr.VectorsRenderer(ddth_des, p, (255, 0, 0)))
def simulateCallback(frame):
th_r = motion.getInternalJointOrientationsLocal(frame)
th = controlModel.getInternalJointOrientationsLocal()
dth_r = motion.getInternalJointAngVelocitiesLocal(frame)
dth = controlModel.getInternalJointAngVelocitiesLocal()
ddth_r = motion.getInternalJointAngAccelerationsLocal(frame)
ddth_des[:] = getDesiredAngAccelerations(th_r, th, dth_r, dth,
ddth_r, 1, 1)
for i in range(stepsPerFrame):
controlModel.setInternalJointAngAccelerationsLocal(ddth_des)
controlModel.solveHybridDynamics()
vpWorld.step()
motionModel.update(motion[frame])
p[:] = motion.getInternalJointPositionsGlobal(frame)
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1 / 30.)
viewer.show()
Fl.run()
def test_joint_pos_vel_acc_funcs_and_tracking():
def getDesiredAngAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt):
ddth_des = [None]*len(th_r)
for i in range(len(th_r)):
ddth_des[i] = Kt*(mm.logSO3(np.dot(th[i].transpose(), th_r[i]))) + Dt*(dth_r[i] - dth[i]) + ddth_r[i]
return ddth_des
def getDesiredAcceleration(p_r, p, v_r, v, a_r, Kt, Dt):
return Kt*(p_r - p) + Dt*(v_r - v) + a_r
# bvhFilePath = '../samples/chain_1.bvh'
# bvhFilePath = '../samples/block_tree_rotate.bvh'
bvhFilePath = '../samples/chain_3_rotate_freely_move.bvh'
# bvhFilePath = '../samples/chain_3_rotate_freely.bvh'
# bvhFilePath = '../samples/chain_3_rotate_freely_expt_root.bvh'
# bvhFilePath = '../samples/chain_3_rotate.bvh'
# bvhFilePath = '../samples/chain_3_rotate_expt_root.bvh'
# bvhFilePath = '../samples/chain_6_rotate_expt_root.bvh'
# bvhFilePath = '../samples/chain_2_rotate_2axes.bvh'
motion = yf.readBvhFile(bvhFilePath)
mcfg = ypc.ModelConfig()
mcfg.defaultDensity = 1000.
mcfg.defaultBoneRatio = .8
for i in range(motion[0].skeleton.getElementNum()):
mcfg.addNode(motion[0].skeleton.getElementName(i))
wcfg = ypc.WorldConfig()
wcfg.planeHeight = -1.
wcfg.gravity = (0,0,0)
stepsPerFrame = 30
wcfg.timeStep = (1/30.)/stepsPerFrame
vpWorld = cvw.VpWorld(wcfg)
controlModel = cvm.VpControlModel(vpWorld, motion[0], mcfg)
vpWorld.initialize()
controlModel.initializeHybridDynamics(False)
# controlModel.fixBody(0)
controlModel.rotate(mm.exp(mm.v3(0,1,0)))
print controlModel
motion_p = []; motion_v = []; motion_a = []
motion_ap = []; motion_av = []; motion_aa = []
motion_ap_local = []; motion_av_local = []; motion_aa_local = []
model_p = []; model_v = []; model_a = []
model_ap = []; model_av = []; model_aa = []
model_ap_local = []; model_av_local = []; model_aa_local = []
model_body_p = []; model_body_a = []
prev_model_v = [(0.,0.,0.)]*controlModel.getJointNum()
prev_model_av = [(0.,0.,0.)]*controlModel.getJointNum()
prev_model_av_local = [(0.,0.,0.)]*controlModel.getJointNum()
viewer = ysv.SimpleViewer()
viewer.record(False)
viewer.doc.addRenderer('motion', yr.JointMotionRenderer(motion, (0,0,255), yr.LINK_WIREBOX))
viewer.doc.addObject('motion', motion)
viewer.doc.addRenderer('model', cvr.VpModelRenderer(controlModel, (255,240,255), yr.POLYGON_LINE))
# viewer.doc.addRenderer('motion_p', yr.PointsRenderer(motion_p, (255,0,0)))
# viewer.doc.addRenderer('model_p', yr.PointsRenderer(model_p, (0,255,0)))
#
# viewer.doc.addRenderer('motion_v', yr.VectorsRenderer(motion_v, motion_p, (255,0,0)))
# viewer.doc.addRenderer('model_v', yr.VectorsRenderer(model_v, model_p, (0,255,0)))
viewer.doc.addRenderer('motion_a', yr.VectorsRenderer(motion_a, motion_p, (255,0,0)))
viewer.doc.addRenderer('model_a', yr.VectorsRenderer(model_a, model_p, (0,255,0)))
# viewer.doc.addRenderer('model_body_a', yr.VectorsRenderer(model_body_a, model_body_p, (255,255,0)))
# viewer.doc.addRenderer('motion_ap', yr.OrientationsRenderer(motion_ap, motion_p, (255,0,0)))
# viewer.doc.addRenderer('model_ap', yr.OrientationsRenderer(model_ap, model_p, (0,255,0)))
# viewer.doc.addRenderer('motion_ap_local', yr.OrientationsRenderer(motion_ap_local, motion_p, (255,100,100)))
# viewer.doc.addRenderer('model_ap_local', yr.OrientationsRenderer(model_ap_local, model_p, (100,255,100)))
# viewer.doc.addRenderer('motion_av', yr.VectorsRenderer(motion_av, motion_p, (255,0,0)))
# viewer.doc.addRenderer('model_av', yr.VectorsRenderer(model_av, model_p, (0,255,0)))
# viewer.doc.addRenderer('motion_av_local', yr.VectorsRenderer(motion_av_local, motion_p, (255,100,100)))
# viewer.doc.addRenderer('model_av_local', yr.VectorsRenderer(model_av_local, model_p, (100,255,100)))
# viewer.doc.addRenderer('motion_aa', yr.VectorsRenderer(motion_aa, motion_p, (255,0,0)))
# viewer.doc.addRenderer('model_aa', yr.VectorsRenderer(model_aa, model_p, (0,255,0)))
# viewer.doc.addRenderer('motion_aa_local', yr.VectorsRenderer(motion_aa_local, motion_p, (255,100,100)))
# viewer.doc.addRenderer('model_aa_local', yr.VectorsRenderer(model_aa_local, model_p, (100,255,100)))
Kt = 200; Dt = 2*(Kt**.5)
def simulateCallback(frame):
th_r = motion.getJointOrientationsLocal(frame)
th = controlModel.getJointOrientationsLocal()
dth_r = motion.getJointAngVelocitiesLocal(frame)
dth = controlModel.getJointAngVelocitiesLocal()
ddth_r = motion.getJointAngAccelerationsLocal(frame)
ddth_des = getDesiredAngAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt)
p_r = motion.getJointPositionGlobal(0, frame)
p = controlModel.getJointPositionGlobal(0)
v_r = motion.getJointVelocityGlobal(0, frame)
v = controlModel.getJointVelocityGlobal(0)
a_r = motion.getJointAccelerationGlobal(0, frame)
a_des = getDesiredAcceleration(p_r, p, v_r, v, a_r, Kt, Dt)
th_r0 = motion.getJointOrientationGlobal(0, frame)
th0 = controlModel.getJointOrientationGlobal(0)
dth_r0 = motion.getJointAngVelocityGlobal(0, frame)
dth0 = controlModel.getJointAngVelocityGlobal(0)
ddth_r0 = motion.getJointAngAccelerationGlobal(0, frame)
ddth_des0 = getDesiredAngAccelerations([th_r0], [th0], [dth_r0], [dth0], [ddth_r0], Kt, Dt)[0]
for i in range(stepsPerFrame):
# controlModel.setBodyAccelerationGlobal(0, a_des)
# controlModel.setJointAngAccelerationsLocal(ddth_des)
controlModel.setJointAccelerationGlobal(0, a_des)
controlModel.setJointAngAccelerationGlobal(0, ddth_des0)
controlModel.setInternalJointAngAccelerationsLocal(ddth_des[1:])
controlModel.solveHybridDynamics()
vpWorld.step()
motion_p[:] = motion.getJointPositionsGlobal(frame)
motion_v[:] = motion.getJointVelocitiesGlobal(frame)
motion_a[:] = motion.getJointAccelerationsGlobal(frame)
motion_ap[:] = motion.getJointOrientationsGlobal(frame)
motion_av[:] = motion.getJointAngVelocitiesGlobal(frame)
motion_aa[:] = motion.getJointAngAccelerationsGlobal(frame)
motion_ap_local[:] = motion.getJointOrientationsLocal(frame)
motion_av_local[:] = motion.getJointAngVelocitiesLocal(frame)
motion_aa_local[:] = motion.getJointAngAccelerationsLocal(frame)
model_p[:] = controlModel.getJointPositionsGlobal()
model_v[:] = controlModel.getJointVelocitiesGlobal()
# model_a[:] = controlModel.getJointAccelerationsGlobal()
model_a[:] = map(lambda v1,v0: (v1-v0)/(1/30.), model_v, prev_model_v)
prev_model_v[:] = model_v
model_ap[:] = controlModel.getJointOrientationsGlobal()
model_av[:] = controlModel.getJointAngVelocitiesGlobal()
# model_aa[:] = controlModel.getJointAngAccelerationsGlobal()
model_aa[:] = map(lambda v1,v0: (v1-v0)/(1/30.), model_av, prev_model_av)
prev_model_av[:] = model_av
model_ap_local[:] = controlModel.getJointOrientationsLocal()
model_av_local[:] = controlModel.getJointAngVelocitiesLocal()
# model_aa_local[:] = controlModel.getJointAngAccelerationsLocal()
model_aa_local[:] = map(lambda v1,v0: (v1-v0)/(1/30.), model_av_local, prev_model_av_local)
prev_model_av_local[:] = model_av_local
model_body_p[:] = controlModel.getBodyPositionsGlobal()
model_body_a[:] = controlModel.getBodyAccelerationsGlobal()
viewer.setSimulateCallback(simulateCallback)
viewer.startTimer(1/30.)
viewer.show()
Fl.run()