merge

surf/geometry.py

@@ -24,35 +24,38 @@ def cross(a, b):
     k = a.x * b.y - a.y * b.x
     return Vertex(i, j, k)
 
+    
 class Vertex(object):
     '''
     A vertex is a position along with other information such as color, normal
     vector and texture coordinates.
     '''
-    def __init__(self, polygon, x=0, y=0, z=0):
+    next_id
+    def __init__(self, polygon, parent_id=None, x=None, y=None, z=None, es=None):
+        '''
+        '''
         self.polygon = polygon
+        self.parent_id = parent_id
         self.x = x
         self.y = y
         self.z = z
-        self.edges = []
-
+        self.edge_ids = es or []
+        self.id = Vertex.next_id
+        Vertex.next_id += 1
+    
     def __eq__(self, other):
         if(self.x == other.x and self.y == other.y and self.z == other.z):
             return True
         else:
             return False
-
-    def __repr__(self):
-        return "[%.2f, %.2f, %.2f]" % (self.x, self.y, self.z)
-
+    
     def __add__(self, other):
         # for now just assume type(other) = Vertex... bad, I know
         return Vertex(self.x + other.x, self.y + other.y, self.z + other.z)
-
+    
     def __radd__(self, other):
         return other + self
-        # return self.__add__(other)
-
+    
     def __mul__(self, other):
         if isinstance(other, Vertex):
             return cross(self, other)
@@ -61,54 +64,175 @@ class Vertex(object):
         else:
             raise TypeError("{0} has an unexpected type: {1}".format(
                 other, type(other)))
-
+    
     def __rmul__(self, other):
         return self.__mul__(other)
-
+    
     def __div__(self, other):
         # same assumption as __mult__
         return Vertex(self.x / other, self.y / other, self.z / other)
     __truediv__ = __div__
-
+    
     def __neg__(self):
         return Vertex(-self.x, -self.y, -self.z)
+    
+    def __unicode__(self):
+        d = {
+            'id': self.id,
+            'parent_id': self.parent_id,
+            'coords': [self.x, self.y, self.z]
+        }
+        return pprint.pformat(d)
+    
+    __str__ = __unicode__
+    __repr__ = __unicode__
+
 
 class Edge(object):
     '''
     '''
     
-    def __init__(self, polygon):
+    next_id = 0
+    def __init__(self, polygon, parent_id=None, vs=None, es=None, fs=None):
+        '''
+        '''
         self.polygon = polygon
-        self.vertices = []
-        self.faces = []
-        self.edges = []
+        self.parent_id = parent_id
+        self.vertex_ids = vs or []
+        self.edge_ids = es or []
+        self.face_ids = fs or []
+        self.id = Edge.next_id
+        Edge.next_id += 1
         
-    def neighborFace(self, neighborFace):
+    def neighbor_face_id(self, neighbor_face_id):
         '''Get neighboring face id
         '''
-        if neighborFace == self.faces[0]:
-            return self.faces[1]
+        if neighbor_face_id == self.face_ids[0]:
+            return self.face_ids[1]
         else:
-            return self.faces[0]
+            return self.face_ids[0]
+    
+    def __unicode__(self):
+        d = {
+            'id': self.id, 
+            'vertex_ids': self.vertex_ids,
+            'edge_ids': self.edge_ids,
+            'face_ids': self.face_ids,
+        }
+        return pprint.pformat(d)
+    
+    __str__ = __unicode__
+    __repr__ = __unicode__
+    
+    @property
+    def vertices(self):
+        return [self.polygon.vertex(v_id) for v_id in self.vertex_ids]
+    
+    @property
+    def faces(self):
+        return [self.polygon.face(f_id) for f_id in self.face_ids]
+    
+    def winged_edges_at_vertex(self, index):
+        edge_ids = []
+        for edge in self.edges:
+            if self.vertex_ids[index] in edge.vertex_ids:
+                edge_ids.append(edge.id)
+        return edge_ids
 
 class Face(object):
     '''
-    A face is a closed set of edges, in which a triangle face has three edges,
+    A face is a closed set of edges,
+    in which a triangle face has three edges,
     and a quad face has four edges.
     '''
-    def __init__(self, polygon):
+    
+    next_id = 0
+    def __init__(self, polygon, parent_id=None, es=None):
+        '''
+        '''
         self.polygon = polygon
-        self.edges = []
+        self.parent_id = parent_id
+        self.edge_ids = es or []
+        self.id = Face.next_id
+        Face.next_id += 1 
         
+    def __unicode__(self):
+        d = {'id': self.id, 'edge_ids': self.edge_ids}
+        return pprint.pformat(d)
+    
+    __str__ = __unicode__
+    __repr__ = __unicode__
+
+    def edge(self, edge_id):
+        return self.polygon.edge(edge_id)
+    
+    @property
+    def edges(self):
+        return [self.polygon.edge(e_id) for e_id in self.edge_ids]
+    
+    @property
+    def vertices(self):
+        vertices = []
+        for edge_id in self.edge_ids:
+            edge = self.polygon.edge(edge_id)
+            vertices.extend(edge.vertices)
+        
+        return list(set(vertices))
+    
+    @property
+    def centroid(self):
+        '''
+        '''
+    
+        # gather all face vertex coords
+        face_vertices = self.vertices
+        
+        xs = [vertex.x for vertex in face_vertices]
+        ys = [vertex.y for vertex in face_vertices]
+        zs = [vertex.z for vertex in face_vertices]
+
+        # average each vertex component
+        x = sum(xs) / len(xs)
+        y = sum(ys) / len(ys)
+        z = sum(zs) / len(zs)
+        
+        return [x, y, z]
+
+    
 class Polygon(object):
     '''
     '''
-
+    
     def __init__(self, vs=None, es=None, fs=None):
         self.vertices = vs or []
         self.edges = es or []
         self.faces = fs or []
     
+    def face(self, face_id):
+        for face in self.faces:
+            if face.id == face_id:
+                return face
+        return None
+    
+    def edge(self, edge_id):
+        for edge in self.edges:
+            if edge.id == edge_id:
+                return edge
+        return None
+    
+    def vertex(self, vertex_id):
+        for vertex in self.vertices:
+            if vertex.id == vertex_id:
+                return vertex
+        return None
+
+    def edge_ids_with_parent(self, parent_edge_id):
+        child_edge_ids = []
+        for edge in self.edges:
+            if edge.parent_id == parent_edge_id:
+                child_edge_ids.append(edge.id)
+        return child_edge_ids
+        
     def __unicode__(self):
         d = {
             'vertices': self.vertices,
@@ -118,4 +242,5 @@ class Polygon(object):
         return pprint.pformat(d)
     
     __str__ = __unicode__
-    __repr__ = __unicode__  
+    __repr__ = __unicode__
+