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

diff --git a/pymeshio/common.py b/pymeshio/common.py
index e67580d..7177506 100644
--- a/pymeshio/common.py
+++ b/pymeshio/common.py
@@ -21,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
@@ -32,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):
     """
@@ -46,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
@@ -59,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):
@@ -177,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
@@ -199,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
@@ -225,17 +272,24 @@ class ParseException(Exception):
     pass
 
 
-def readall(path: str) -> bytes:
+def readall(path):
+    """read all bytes from path
+    """
     with open(path, "rb") as f:
         return f.read()
 
 
-class BinaryLoader(object):
-    def __init__(self, io):
-        self.io=io
+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: str, size: int) -> "read value as format":
-        result=struct.unpack(fmt, self.io.read(size))
+    def unpack(self, fmt, size):
+        result=struct.unpack(fmt, self.ios.read(size))
         return result[0]
 
     def read_uint(self, size):
@@ -280,3 +334,43 @@ class BinaryLoader(object):
                 )
 
 
+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))
+
+