13 literal to unicode for python2 and python3 compatiblity.
\r
15 in python2 str to unicode.
\r
16 in python3 str(as unicode) to str.
\r
18 if sys.version_info[0]<3:
\r
19 return src.decode('utf-8')
\r
26 class Vector2(object):
\r
28 2D coordinate for uv value
\r
30 __slots__=['x', 'y']
\r
31 def __init__(self, x=0, y=0):
\r
36 return "<%f %f>" % (self.x, self.y)
\r
38 def __eq__(self, rhs):
\r
39 return self.x==rhs.x and self.y==rhs.y
\r
41 def __ne__(self, rhs):
\r
42 return not self.__eq__(rhs)
\r
44 def __getitem__(self, key):
\r
53 return (self.x, self.y)
\r
55 def cross(self, rhs):
\r
56 """cross(outer) product"""
\r
57 return self.x*rhs.y-self.y*rhs.x
\r
60 class Vector3(object):
\r
62 3D coordinate for vertex position, normal direction
\r
64 __slots__=['x', 'y', 'z']
\r
65 def __init__(self, x=0, y=0, z=0):
\r
71 return "<%f %.32f %f>" % (self.x, self.y, self.z)
\r
73 def __eq__(self, rhs):
\r
74 return self.x==rhs.x and self.y==rhs.y and self.z==rhs.z
\r
76 def __ne__(self, rhs):
\r
77 return not self.__eq__(rhs)
\r
79 def __getitem__(self, key):
\r
90 return (self.x, self.y, self.z)
\r
92 def __add__(self, r):
\r
93 return Vector3(self.x+r.x, self.y+r.y, self.z+r.z)
\r
95 def __sub__(self, rhs):
\r
96 return Vector3(self.x-rhs.x, self.y-rhs.y, self.z-rhs.z)
\r
98 def getSqNorm(self):
\r
99 return self.x*self.x + self.y*self.y + self.z*self.z
\r
102 return math.sqrt(self.getSqNorm())
\r
104 def normalize(self):
\r
105 factor=1.0/self.getNorm()
\r
112 return [self.x, self.y, self.z]
\r
114 def dot(self, rhs):
\r
115 """dot(inner) product"""
\r
116 return self.x*rhs.x + self.y*rhs.y + self.z*rhs.z
\r
118 def cross(self, rhs):
\r
119 """cross(outer) product"""
\r
121 self.y*rhs.z - rhs.y*self.z,
\r
122 self.z*rhs.x - rhs.z*self.x,
\r
123 self.x*rhs.y - rhs.x*self.y,
\r
127 class Quaternion(object):
\r
129 rotation representation in vmd motion
\r
131 __slots__=['x', 'y', 'z', 'w']
\r
132 def __init__(self, x=0, y=0, z=0, w=1):
\r
139 return "<%f %f %f %f>" % (self.x, self.y, self.z, self.w)
\r
141 def __mul__(self, rhs):
\r
142 u=numpy.array([self.x, self.y, self.z], 'f')
\r
143 v=numpy.array([rhs.x, rhs.y, rhs.z], 'f')
\r
144 xyz=self.w*v+rhs.w*u+numpy.cross(u, v)
\r
145 q=Quaternion(xyz[0], xyz[1], xyz[2], self.w*rhs.w-numpy.dot(u, v))
\r
148 def dot(self, rhs):
\r
149 return self.x*rhs.x+self.y*rhs.y+self.z*rhs.z+self.w*rhs.w
\r
151 def getMatrix(self):
\r
161 return numpy.array([
\r
163 [1-2*sqY-2*sqZ, 2*xy+2*wz, 2*xz-2*wy, 0],
\r
165 [2*xy-2*wz, 1-2*sqX-2*sqZ, 2*yz+2*wx, 0],
\r
167 [2*xz+2*wy, 2*yz-2*wx, 1-2*sqX-2*sqY, 0],
\r
172 def getRHMatrix(self):
\r
186 return numpy.array([
\r
188 [1-2*sqY-2*sqZ, 2*xy+2*wz, 2*xz-2*wy, 0],
\r
190 [2*xy-2*wz, 1-2*sqX-2*sqZ, 2*yz+2*wx, 0],
\r
192 [2*xz+2*wy, 2*yz-2*wx, 1-2*sqX-2*sqY, 0],
\r
197 def getRollPitchYaw(self):
\r
200 roll = math.atan2(m[0, 1], m[1, 1])
\r
201 pitch = math.asin(-m[2, 1])
\r
202 yaw = math.atan2(m[2, 0], m[2, 2])
\r
204 if math.fabs(math.cos(pitch)) < 1.0e-6:
\r
205 roll += m[0, 1] > math.pi if 0.0 else -math.pi
\r
206 yaw += m[2, 0] > math.pi if 0.0 else -math.pi
\r
208 return roll, pitch, yaw
\r
210 def getSqNorm(self):
\r
211 return self.x*self.x+self.y*self.y+self.z*self.z+self.w*self.w
\r
213 def getNormalized(self):
\r
214 f=1.0/self.getSqNorm()
\r
215 q=Quaternion(self.x*f, self.y*f, self.z*f, self.w*f)
\r
218 def getRightHanded(self):
\r
219 "swap y and z axis"
\r
220 return Quaternion(-self.x, -self.z, -self.y, self.w)
\r
223 def createFromAxisAngle(axis, rad):
\r
226 c=math.cos(half_rad)
\r
227 s=math.sin(half_rad)
\r
228 return Quaternion(axis[0]*s, axis[1]*s, axis[2]*s, c)
\r
235 __slots__=['r', 'g', 'b']
\r
236 def __init__(self, r=0, g=0, b=0):
\r
241 def __eq__(self, rhs):
\r
242 return self.r==rhs.r and self.g==rhs.g and self.b==rhs.b
\r
244 def __ne__(self, rhs):
\r
245 return not self.__eq__(rhs)
\r
247 def __getitem__(self, key):
\r
258 class RGBA(object):
\r
262 __slots__=['r', 'g', 'b', 'a']
\r
263 def __init__(self, r=0, g=0, b=0, a=1):
\r
269 def __eq__(self, rhs):
\r
270 return self.r==rhs.r and self.g==rhs.g and self.b==rhs.b and self.a==rhs.a
\r
272 def __ne__(self, rhs):
\r
273 return not self.__eq__(rhs)
\r
275 def __getitem__(self, key):
\r
291 def radian_to_degree(x):
\r
292 """darian to deglee"""
\r
294 return x/math.pi * 180.0
\r
297 class ParseException(Exception):
\r
299 Exception in reader
\r
305 """read all bytes from path
\r
307 with open(path, "rb") as f:
\r
311 class BinaryReader(object):
\r
312 """general BinaryReader
\r
314 def __init__(self, ios):
\r
316 ios.seek(0, io.SEEK_END)
\r
317 self.end=ios.tell()
\r
322 #print(self.ios.tell(), self.end)
\r
323 return self.ios.tell()>=self.end
\r
324 #return not self.ios.readable()
\r
326 def unpack(self, fmt, size):
\r
327 result=struct.unpack(fmt, self.ios.read(size))
\r
330 def read_int(self, size):
\r
332 return self.unpack("b", size)
\r
334 return self.unpack("h", size)
\r
336 return self.unpack("i", size)
\r
337 print("not reach here")
\r
338 raise ParseException("invalid int size: "+size)
\r
340 def read_uint(self, size):
\r
342 return self.unpack("B", size)
\r
344 return self.unpack("H", size)
\r
346 return self.unpack("I", size)
\r
347 print("not reach here")
\r
348 raise ParseException("invalid int size: "+size)
\r
350 def read_float(self):
\r
351 return self.unpack("f", 4)
\r
353 def read_vector2(self):
\r
355 self.read_float(),
\r
359 def read_vector3(self):
\r
361 self.read_float(),
\r
362 self.read_float(),
\r
366 def read_rgba(self):
\r
368 self.read_float(),
\r
369 self.read_float(),
\r
374 def read_rgb(self):
\r
376 self.read_float(),
\r
377 self.read_float(),
\r
382 class WriteException(Exception):
\r
384 Exception in writer
\r
389 class BinaryWriter(object):
\r
390 def __init__(self, ios):
\r
393 def write_bytes(self, v, size=None):
\r
395 self.ios.write(struct.pack("={0}s".format(size), v))
\r
399 def write_float(self, v):
\r
400 self.ios.write(struct.pack("f", v))
\r
402 def write_int(self, v, size):
\r
404 self.ios.write(struct.pack("b", v))
\r
406 self.ios.write(struct.pack("h", v))
\r
408 self.ios.write(struct.pack("i", v))
\r
410 raise WriteError("invalid int uint size")
\r
412 def write_uint(self, v, size):
\r
414 self.ios.write(struct.pack("B", v))
\r
416 self.ios.write(struct.pack("H", v))
\r
418 self.ios.write(struct.pack("I", v))
\r
420 raise WriteError("invalid int uint size")
\r
422 def write_vector2(self, v):
\r
423 self.ios.write(struct.pack("=2f", v.x, v.y))
\r
425 def write_vector3(self, v):
\r
426 self.ios.write(struct.pack("=3f", v.x, v.y, v.z))
\r
428 def write_rgb(self, v):
\r
429 self.ios.write(struct.pack("=3f", v.r, v.g, v.b))
\r
431 def write_rgba(self, v):
\r
432 self.ios.write(struct.pack("=4f", v.r, v.g, v.b, v.a))
\r