X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=pymeshio%2Fcommon.py;h=71775060e75fa2ee7ce0a6b5bd8174962a76a629;hb=cf6ec3e04ee67bbe635510486475961ed32e46f2;hp=8ec017d9b459dbc082e3f96ebfb6ea432c2e5cb3;hpb=9cbcf2ff293043fd2c46785621fb9e150786a064;p=meshio%2Fpymeshio.git

diff --git a/pymeshio/common.py b/pymeshio/common.py
index 8ec017d..7177506 100644
--- a/pymeshio/common.py
+++ b/pymeshio/common.py
@@ -3,20 +3,12 @@
 common utilities.
 """
 import math
-
-def radian_to_degree(x):
-    """darian to deglee"""
-
-    return x/math.pi * 180.0
+import struct
 
 
 """
 common structures.
 """
-class ParseException(Exception):
-    pass
-
-
 class Vector2(object):
     """
     2D coordinate for uv value
@@ -29,6 +21,9 @@ class Vector2(object):
     def __str__(self):
         return "<%f %f>" % (self.x, self.y)
 
+    def __eq__(self, rhs):
+        return self.x==rhs.x and self.y==rhs.y
+
     def __getitem__(self, key):
         if key==0:
             return self.x
@@ -40,6 +35,10 @@ class Vector2(object):
     def to_tuple(self):
         return (self.x, self.y)
 
+    def cross(self, rhs):
+        """cross(outer) product"""
+        return self.x*rhs.y-self.y*rhs.x
+
 
 class Vector3(object):
     """
@@ -54,6 +53,9 @@ class Vector3(object):
     def __str__(self):
         return "<%f %f %f>" % (self.x, self.y, self.z)
 
+    def __eq__(self, rhs):
+        return self.x==rhs.x and self.y==rhs.y and self.z==rhs.z
+
     def __getitem__(self, key):
         if key==0:
             return self.x
@@ -67,8 +69,39 @@ class Vector3(object):
     def to_tuple(self):
         return (self.x, self.y, self.z)
 
-    def __add__(l, r):
-        return Vector3(l.x+r.x, l.y+r.y, l.z+r.z)
+    def __add__(self, r):
+        return Vector3(self.x+r.x, self.y+r.y, self.z+r.z)
+
+    def __sub__(self, rhs):
+        return Vector3(self.x-rhs.x, self.y-rhs.y, self.z-rhs.z)
+
+    def getSqNorm(self):
+        return self.x*self.x + self.y*self.y + self.z*self.z
+
+    def getNorm(self):
+        return math.sqrt(self.getSqNorm())
+
+    def normalize(self):
+        factor=1.0/self.getNorm()
+        self.x*=factor
+        self.y*=factor
+        self.z*=factor
+        return self
+
+    def to_a(self):
+        return [self.x, self.y, self.z]
+
+    def dot(self, rhs):
+        """dot(inner) product"""
+        return self.x*rhs.x + self.y*rhs.y + self.z*rhs.z
+
+    def cross(self, rhs):
+        """cross(outer) product"""
+        return Vector3(
+                self.y*rhs.z - rhs.y*self.z,
+                self.z*rhs.x - rhs.z*self.x,
+                self.x*rhs.y - rhs.x*self.y,
+                )
 
 
 class Quaternion(object):
@@ -185,6 +218,9 @@ class RGB(object):
         self.g=g
         self.b=b
 
+    def __eq__(self, rhs):
+        return self.r==rhs.r and self.g==rhs.g and self.b==rhs.b
+
     def __getitem__(self, key):
         if key==0:
             return self.r
@@ -207,6 +243,9 @@ class RGBA(object):
         self.b=b
         self.a=a
 
+    def __eq__(self, rhs):
+        return self.r==rhs.r and self.g==rhs.g and self.b==rhs.b and self.a==rhs.a
+
     def __getitem__(self, key):
         if key==0:
             return self.r
@@ -219,3 +258,119 @@ class RGBA(object):
         else:
             assert(False)
 
+
+"""
+utilities
+"""
+def radian_to_degree(x):
+    """darian to deglee"""
+
+    return x/math.pi * 180.0
+
+
+class ParseException(Exception):
+    pass
+
+
+def readall(path):
+    """read all bytes from path
+    """
+    with open(path, "rb") as f:
+        return f.read()
+
+
+class BinaryReader(object):
+    """general BinaryReader
+    """
+    def __init__(self, ios):
+        self.ios=ios
+
+    def is_end(self):
+        return not self.ios.readable()
+
+    def unpack(self, fmt, size):
+        result=struct.unpack(fmt, self.ios.read(size))
+        return result[0]
+
+    def read_uint(self, size):
+        if size==1:
+            return self.unpack("B", size)
+        if size==2:
+            return self.unpack("H", size)
+        if size==4:
+            return self.unpack("I", size)
+        print("not reach here")
+        raise ParseException("invalid int size: "+size)
+
+    def read_float(self):
+        return self.unpack("f", 4)
+
+    def read_vector2(self):
+        return Vector2(
+                self.read_float(), 
+                self.read_float()
+                )
+
+    def read_vector3(self):
+        return Vector3(
+                self.read_float(), 
+                self.read_float(), 
+                self.read_float()
+                )
+
+    def read_rgba(self):
+        return RGBA(
+                self.read_float(), 
+                self.read_float(), 
+                self.read_float(),
+                self.read_float()
+                )
+
+    def read_rgb(self):
+        return RGB(
+                self.read_float(), 
+                self.read_float(), 
+                self.read_float()
+                )
+
+
+class WriteException(Exception):
+    pass
+
+
+class BinaryWriter(object):
+    def __init__(self, ios):
+        self.ios=ios
+
+    def write_bytes(self, v, size=None):
+        if size:
+            self.ios.write(struct.pack("={0}s".format(size), v))
+        else:
+            self.ios.write(v)
+
+    def write_float(self, v):
+        self.ios.write(struct.pack("f", v))
+
+    def write_uint(self, v, size):
+        if size==1:
+            self.ios.write(struct.pack("B", v))
+        elif size==2:
+            self.ios.write(struct.pack("H", v))
+        elif size==4:
+            self.ios.write(struct.pack("I", v))
+        else:
+            raise WriteError("invalid int uint size")
+
+    def write_vector2(self, v):
+        self.ios.write(struct.pack("=2f", v.x, v.y))
+
+    def write_vector3(self, v):
+        self.ios.write(struct.pack("=3f", v.x, v.y, v.z))
+
+    def write_rgb(self, v):
+        self.ios.write(struct.pack("=3f", v.r, v.g, v.b))
+
+    def write_rgba(self, v):
+        self.ios.write(struct.pack("=4f", v.r, v.g, v.b, v.a))
+
+