def _startElement(self, name, attrs):
nodeName = attrs.get('name', None)
if (name == 'transform'):
t = transform.Transform()
t.takeParser(self._parser, self, attrs)
elif (name == 'geom'):
g = geom.Geom(nodeName, self)
g.takeParser(self._parser)
elif (name == 'group'):
# parse group
pass
elif (name == 'body'):
b = body.Body(nodeName, self, attrs)
b.takeParser(self._parser)
elif (name == 'jointgroup'):
# parse joint group
pass
elif (name == 'joint'):
j = joint.Joint(nodeName, self)
j.takeParser(self._parser)
elif (name == 'ext'):
# parse ext
pass
else:
raise errors.ChildError('space', name)
def __init__(self, name, mnemonic, operands, result, function_name, bound):
self.name = name
self.mnemonic = mnemonic
self.operands = operands.split(' ')
self.result = result
self.function_name = function_name
self.joints = {}
for elem in bound.split(' '):
self.joints[elem] = joint.Joint(self)
def test_joint_init(self):
Joint = joint.Joint(0, 0, 0, 0, 0, 0)
self.assertEqual(Joint.angle_limit_negative, 0)
self.assertEqual(Joint.angle_limit_positive, 0)
self.assertEqual(Joint.step_limit_max, 0)
self.assertEqual(Joint._degree_per_step, 0)
self.assertEqual(Joint.current_step, 0)
self.assertEqual(Joint._current_angle, 0)
def _startElement(self, name, attrs):
nodeName = attrs.get('name', None)
if (name == 'transform'):
t = transform.Transform()
t.takeParser(self._parser, self, attrs)
else:
self._applyTransform()
if (name == 'torque'):
self.getODEObject().setTorque(self._parser.parseVector(attrs))
elif (name == 'force'):
self.getODEObject().setForce(self._parser.parseVector(attrs))
elif (name == 'finiteRotation'):
mode = int(attrs['mode'])
try:
axis = (float(attrs['xaxis']),
float(attrs['yaxis']),
float(attrs['zaxis']))
except KeyError:
raise errors.InvalidError('finiteRotation element must have' \
' xaxis, yaxis and zaxis attributes')
if (mode not in [0, 1]):
raise errors.InvalidError('finiteRotation mode attribute must' \
' be either 0 or 1.')
self.getODEObject().setFiniteRotationMode(mode)
self.getODEObject().setFiniteRotationAxis(axis)
elif (name == 'linearVel'):
self.getODEObject().setLinearVel(self._parser.parseVector(attrs))
elif (name == 'angularVel'):
self.getODEObject().setAngularVel(self._parser.parseVector(attrs))
elif (name == 'mass'):
self._mass = Mass(nodeName, self)
self._mass.takeParser(self._parser)
elif (name == 'joint'):
j = joint.Joint(nodeName, self)
j.takeParser(self._parser)
elif (name == 'body'):
b = Body(nodeName, self, attrs)
b.takeParser(self._parser)
elif (name == 'geom'):
g = geom.Geom(nodeName, self)
g.takeParser(self._parser)
elif (name == 'transform'): # so it doesn't raise ChildError
pass
else:
raise errors.ChildError('body', name)
def __init__(self, number_of_joints):
""" Setup """
self.joints = []
for ii in range(0, number_of_joints):
self.joints.append(joint.Joint(-1, -1, -1, -1, -1, -1))
#TODO: add init values of joints
self.ser_com = sc.Serial_communication(5)
self.ser_com.open(self.ser_com)
self.calibrated = False
self.running = False
self.stop = False
self.current_line = 0
def file_main(self, photoPath):
#转码
#base64_data = base64.b64encode(photoPath)
# add by me
f = open(photoPath, 'rb')
img = base64.b64encode(f.read())
#img = self.get_file_content('{}'.format(photoPath))
""" 调用人体关键点识别 """
#此处只能对一个人进行关键点识别
#也就是说一个图片如果有好多人的话,只能标出一个人的关节特征
#此处可以做修改,即进行把一张图所有人的关节特征都表达出来
#------
print(self.client.bodyAnalysis(img))
result = self.client.bodyAnalysis(img)['person_info'][0]['body_parts']
jo = joint.Joint(result)
jo.xunhun(photoPath)
print(result)
def _startElement(self, name, attrs):
nodeName = attrs.get('name', None)
if (name == 'transform'):
t = transform.Transform()
t.takeParser(self._parser, self, attrs)
self._transformed = True
elif (name == 'box'):
self._parseGeomBox(attrs)
elif (name == 'cappedCylinder'):
self._parseGeomCCylinder(attrs)
elif (name == 'cone'):
raise NotImplementedError()
elif (name == 'cylinder'):
raise NotImplementedError()
elif (name == 'plane'):
self._parseGeomPlane(attrs)
elif (name == 'ray'):
self._parseGeomRay(attrs)
elif (name == 'sphere'):
self._parseGeomSphere(attrs)
elif (name == 'trimesh'):
self._parseTriMesh(attrs)
elif (name == 'geom'):
g = Geom(nodeName, self)
g.takeParser(self._parser)
elif (name == 'body'):
b = body.Body(nodeName, self, attrs)
b.takeParser(self._parser)
elif (name == 'joint'):
j = joint.Joint(nodename, self)
j.takeParser(self._parser)
elif (name == 'jointgroup'):
pass
elif (name == 'ext'):
pass
else:
raise errors.ChildError('geom', name)
image_type = "BASE64"
# params = "{\"image\":\"%s\",\"image_type\":\"BASE64\",\"face_field\":\"faceshape,facetype\"}"%image64
#params = {'image': image64,'image_type':"BASE64",'face_field': 'person_info'}
params = {'image': image64,'image_type':"BASE64"}
# 此处的faceshape和facetype需要自己加上去 更具自己需要的返回值
params = urllib.parse.urlencode(params).encode("utf-8")
access_token = '[24.fdd8df19e52da8ff449e1484aa582f42.2592000.1556250057.282335-15823849]'
request_url = request_url + "?access_token=" + access_token
request = urllib.request.urlopen(url=request_url, data=params) # 发送请求
content = request.read() # 将返回结果读取出来
print(content) # 显示返回结果
result = str(content,'utf-8')
res = json.loads(result)
print(res['person_info'][0]['body_parts'])
ress = res['person_info'][0]['body_parts']
jo = joint.Joint(ress)
jo.xunhun('/home/zhengr/Documents/data/1.jpg')
import urllib.request,sys,base64
import urllib.parse
def duplicateJoint(node, newName=str(), connections=False):
node = duplicate(node, newName, connections)
jnt = animJoint.Joint(node, cmds.xform(node, q=True, ws=True, t=True))
return jnt
def onNodeJoint(self, node):
"""Joint node.
"""
args = self.fillWorldObjectArgs(node)
# Compute transform
t = vec3(node.getAttrValue("translate", "t", "double3", 1, vec3(0)))
r = vec3(node.getAttrValue("rotate", "r", "double3", 1, vec3(0)))
s = vec3(node.getAttrValue("scale", "s", "double3", 1, vec3(1)))
ra = vec3(node.getAttrValue("rotateAxis", "ra", "double3", 1, vec3(0)))
roi = node.getAttrValue("rotationInterpolation", "roi", "int", 1, 1)
ro = node.getAttrValue("rotateOrder", "ro", "int", 1, default=0)
jo = vec3(node.getAttrValue("jointOrient", "jo", "double3", 1,
vec3(0)))
is_ = vec3(
node.getAttrValue("inverseScale", "is", "double3", 1, vec3(1)))
jot = node.getAttrValue("jointOrientType",
"jot",
"string",
1,
default="xyz")
S = mat4().scaling(s)
T = mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, t.x, t.y, t.z, 1)
IS = mat4().scaling(is_)
sx = sin(radians(ra.x))
cx = cos(radians(ra.x))
sy = sin(radians(ra.y))
cy = cos(radians(ra.y))
sz = sin(radians(ra.z))
cz = cos(radians(ra.z))
AX = mat4(1, 0, 0, 0, 0, cx, sx, 0, 0, -sx, cx, 0, 0, 0, 0, 1)
AY = mat4(cy, 0, -sy, 0, 0, 1, 0, 0, sy, 0, cy, 0, 0, 0, 0, 1)
AZ = mat4(cz, sz, 0, 0, -sz, cz, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
RA = AX * AY * AZ
# Euler-angle rotation (todo: quat)
sx = sin(radians(r.x))
cx = cos(radians(r.x))
sy = sin(radians(r.y))
cy = cos(radians(r.y))
sz = sin(radians(r.z))
cz = cos(radians(r.z))
RX = mat4(1, 0, 0, 0, 0, cx, sx, 0, 0, -sx, cx, 0, 0, 0, 0, 1)
RY = mat4(cy, 0, -sy, 0, 0, 1, 0, 0, sy, 0, cy, 0, 0, 0, 0, 1)
RZ = mat4(cz, sz, 0, 0, -sz, cz, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
a, b, c = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"][ro]
exec "R=R%s*R%s*R%s" % (a, b, c)
sx = sin(radians(jo.x))
cx = cos(radians(jo.x))
sy = sin(radians(jo.y))
cy = cos(radians(jo.y))
sz = sin(radians(jo.z))
cz = cos(radians(jo.z))
AX = mat4(1, 0, 0, 0, 0, cx, sx, 0, 0, -sx, cx, 0, 0, 0, 0, 1)
AY = mat4(cy, 0, -sy, 0, 0, 1, 0, 0, sy, 0, cy, 0, 0, 0, 0, 1)
AZ = mat4(cz, sz, 0, 0, -sz, cz, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
a, b, c = jot.upper()
exec "JO=A%s*A%s*A%s" % (a, b, c)
WT = S * RA * R * IS * T
# WT = S*RA*R*IS*T
# WT = T
WT = WT.transpose()
args["transform"] = WT
jnt = joint.Joint(radius=0.5 *
node.getAttrValue("radius", "radi", "float", 1, 1.0),
offsetTransform=JO.inverse(),
**args)
jnt.freezePivot()
# Reset offset transform (so that pivot frame and local frame coincide)
jnt.setOffsetTransform(mat4(1))
self.newWorldObject(jnt, node.getName())
def setUp(self):
self.Joint = joint.Joint(0, 300, 1400, 0.5, 0, 0)
