import pprint ''' http://en.wikipedia.org/wiki/Polygon_mesh Polygon meshes may be represented in a variety of ways, using different methods to store the vertex, edge and face data. These include: - Face-vertex - Winged-edge - Half-edge - Quad-edge - Corner-tables - Vertex-vertex - Face-vertex We have chosen to use a winged-edge style mesh for our purpopses. v4 v5 *-----e8-----* | | | | e|4 f4 e|5 | | v4 v|0 v|1 v5 *-----e4-----*-----e0-----*-----e5-----* | | | | | | | | e11| f3 e|3 f0 e|1 f1 e|9 | | | | | | | | *-----e7-----*-----e2-----*-----e6-----* v7 v|3 v|2 v6 | | e|7 f2 e|6 | | v|7 v|6 *-----e10----* | | | | e|11 f5 e|9 | | | | *-----e8-----* v4 v5 v0 - <0,1,0> v1 - <1,1,0> v2 - <1,0,0> v3 - <0,0,0> v4 - <0,1,1> v5 - <1,1,1> v6 - <1,0,1> v7 - <0,0,1> face list f0 - e0, e1, e2, e3 f1 - e1, e5, e9, e6 f2 - e2, e6, e10, e7 f3 - e4, e3, e7, e11 f4 - e8, e5, e0, e4 f5 - e10, e9, e8, e11 winged edges ordered by face, then by vertex reference edge list e0 - v0, v1; f0, f4; e3, e1, e4, e5 e1 - v1, v2; f0, f1; e0, e2, e5, e6 e2 - v3, v2; f0, f2; e3, e7, e1, e6 e3 - v0, v3; f3, f0; e4, e7, e0, e2 e4 - v4, v0; f3, f4; e11, e3, e0 e8 e5 - v5, v1; f4, f1; e8, e0, e9, e1 e6 - v2, v6; f1, f2; e1, e9, e2, e10 e7 - v7, v3; f3, f2; e11, e3, e10, e2 e8 - v4, v5, f4, f5; e4, e5, e11, e9 e9 - v5, v6; f1, f5; e5, e6, e8, e10 e10 - v7, v6; f2, f5; e7, e6, e11, e9 e11 - v4, v7; f3, f5; e4, e7, e8, 10 vertex list v0 - e0, e3, e4 v1 - e0, e5, e1 v2 - e1, e6, e2 v3 - e2, e7, e3 v4 - e4, e11, e8 v5 - e5, e9, e8 v6 - e2, e9, e10 v7 - e7, e10, e11 ''' class Vertex(object): ''' A vertex is a position along with other information such as color, normal vector and texture coordinates. ''' def __init__(self, x=0, y=0, z=0): self.x = x self.y = y self.z = z self.edges = [] 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 self.__add__(other) def __mul__(self, other): # for now just assume type(other) = int or float return Vertex(self.x * other, self.y * other, self.z * other) def __rmul__(self, other): return self.__mul__(other) def __div__(self, other): # same assumption as __mult__ other = float(other) return Vertex(self.x / other, self.y / other, self.z / other) class Edge(object): ''' ''' def __init__(self): self.vertices = [] self.faces = [] self.edges = [] self.__edge_vertex = None self.__sub_edges = [] def neighborFace(self, neighborFace): if neighborFace == self.faces[0]: return self.faces[1] else: return self.faces[0] @property def mid_point(self): return sum(self.vertices, Vertex()) / len(self.vertices) @property def sub_edges(self): if not self.__sub_edges: self.__sub_edges = [Edge(), Edge()] self.__sub_edges[0].vertices = [self.vertices[0], self.edge_vertex] self.__sub_edges[1].vertices = [self.edge_vertex, self.vertices[1]] return self.__sub_edges @property def edge_vertex(self): ''' Set each edge vertices to be the average of the two neighboring face vertices and its two original end vertices. ''' if not self.__edge_vertex: # two neighboring face vertices: neighboringFaceVertices = [face.centroid for face 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 __averageVertices(self, vertices): return class Face(object): ''' 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): self.edges = [] self.__centroid = None self.__interior_edges = [] self.__sub_faces = [] @property 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 @property def sub_faces(self): self.__setupSubDivisions() return self.__sub_faces @property 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]) class Polygon(object): ''' Face splitting should happend on the polygon level(?). It doesn't make sense to split just one face since it needs to average vertices with all adjoinging faces ''' def __init__(self, v=None, e=None, f=None): self.vertices = v or [] self.edges = e or [] self.faces = f or [] def __unicode__(self): d = { 'vertices': self.vertices, 'edges': self.edges, 'faces': self.faces, } return pprint.pformat(d) __str__ = __unicode__ __repr__ = __unicode__