nothing

surf/subd/cc.py

@@ -1,5 +1,135 @@
 from surf.geometry import Vertex, Polygon
 
+def mid_point(self):
+    vertex_objs = [self.polygon.vertices[v_id] for v_id in self.vertices]
+    return sum(vertex_objs, Vertex()) / len(self.vertices)
+
+def sub_edges(self):
+    temp_p = Polygon()
+    temp_p.edges = [Edge(), Edge()]
+    temp_p.vertices = 
+    sub_edges[0].vertices = [self.vertices[0], self.edge_vertex]
+    sub_edges[1].vertices = [self.edge_vertex, self.vertices[1]]
+    return self.__sub_edges
+
+def edge_vertex(self):
+    '''
+    Set each edge vertices to be the average of the two neighboring
+        face vertices and its two original end vertices.
+    '''
+    # two neighboring face vertices:
+    neighboringFaceVertices = [p.faces[f_id].centroid for f_id in self.faces]
+    neighboringFaceVertices.extend(self.vertices)
+    xs = [vertex.x for vertex in neighboringFaceVertices]
+    ys = [vertex.y for vertex in neighboringFaceVertices]
+    zs = [vertex.z for vertex in neighboringFaceVertices]
+    x = sum(xs) / len(xs)
+    y = sum(ys) / len(ys)
+    z = sum(zs) / len(zs)
+    self.__edge_vertex = Vertex(x, y, z)
+    self.__edge_vertex.edges.extend(self.__sub_edges)
+    return self.__edge_vertex
+
+def centroid(self):
+    if not self.__centroid:
+        # gather all face vertex coords
+        face_vertices = list(set([vertex
+            for edge in self.edges for vertex in edge.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)
+
+        self.__centroid = Vertex(x, y, z)
+    return self.__centroid
+
+def sub_faces(self):
+    self.__setupSubDivisions()
+    return self.__sub_faces
+
+def interior_edges(self):
+    self.__setupSubDivisions()
+    return self.__interior_edges
+
+def __setupSubDivisions(self):
+    '''
+       v0      ev0    v1
+        *------e0-----*
+        |      |      |
+        |      |      |
+   ev3 e|11----f5----e|1 ev1
+        |      |      |
+        |      |      |
+        *------e2-----*
+       v3      ev2    v2
+    '''
+    if not self.__sub_faces:
+        # create empty sub_faces that will be filled with edge references
+        # below
+        #   these need to at least exist so the interior edges have
+        # something to reference
+        self.__sub_faces = [Face() for edge in self.edges]
+
+    if not self.__interior_edges:
+        # set up empty edge objects to be filled below
+        self.__interior_edges = [Edge() for edge in self.edges]
+
+        # each interior edge connects the exterior edge vertex (mid-point)
+        # to the faceVertex (centroid)
+        for index in range(len(self.edges)):
+            prevIndex = (index - 1) % len(self.edges)
+            nextIndex = (index + 1) % len(self.edges)
+
+            # end vertices are face centroid and currEdge edge_vertex
+            self.__interior_edges[index].vertices = [
+                self.edges[index].edge_vertex, self.centroid
+            ]
+
+            # wing edges are the current edge's sub_edges (ordered same as
+            # vertex order) and the prev and next interior edges
+            self.__interior_edges[index].edges = [
+                self.edges[index].sub_edges[0],
+                self.edges[index].sub_edges[1],
+                self.__interior_edges[prevIndex],
+                self.__interior_edges[nextIndex]
+            ]
+
+            # edge faces are the new sub_faces (current and next faces), the
+            # current will be define below
+            #   and the next will be defined on the next iteration (or
+            # already defined on the last iteration)
+            self.__interior_edges[index].faces = [
+                self.__sub_faces[index],
+                self.__sub_faces[nextIndex]
+            ]
+
+            # now reference the current edge back into the faces,
+            #   and the edge.sub_edges, and the edge.edge_vertex
+
+            # current subFace (same index as current interior edge)
+            #   set its edges to reference the same edges used to setup the
+            #      interior edge
+            #   order will be pretty important on these steps...
+            self.__sub_faces[index].edges = [
+                self.edges[index].sub_edges[0],
+                self.__interior_edges[index],
+                self.__interior_edges[prevIndex],
+                self.edges[prevIndex].sub_edges[1]
+            ]
+
+            # just set one of the vertex edges, the other belongs to
+            # another face and will get added when that face is run
+            self.edges[index].edge_vertex.edges.append(
+                    self.__interior_edges[index])
+
+            self.edges[index].sub_edges[0].faces.append(
+                    self.__sub_faces[index])
+            self.edges[index].sub_edges[0].faces.append(
+                    self.__sub_faces[index])
 
 def refine(poly):
     '''